1pub const JS_NAN_BOXING: u32 = 1;
4pub const JS_PROP_CONFIGURABLE: u32 = 1;
5pub const JS_PROP_WRITABLE: u32 = 2;
6pub const JS_PROP_ENUMERABLE: u32 = 4;
7pub const JS_PROP_C_W_E: u32 = 7;
8pub const JS_PROP_LENGTH: u32 = 8;
9pub const JS_PROP_TMASK: u32 = 48;
10pub const JS_PROP_NORMAL: u32 = 0;
11pub const JS_PROP_GETSET: u32 = 16;
12pub const JS_PROP_VARREF: u32 = 32;
13pub const JS_PROP_AUTOINIT: u32 = 48;
14pub const JS_PROP_HAS_SHIFT: u32 = 8;
15pub const JS_PROP_HAS_CONFIGURABLE: u32 = 256;
16pub const JS_PROP_HAS_WRITABLE: u32 = 512;
17pub const JS_PROP_HAS_ENUMERABLE: u32 = 1024;
18pub const JS_PROP_HAS_GET: u32 = 2048;
19pub const JS_PROP_HAS_SET: u32 = 4096;
20pub const JS_PROP_HAS_VALUE: u32 = 8192;
21pub const JS_PROP_THROW: u32 = 16384;
22pub const JS_PROP_THROW_STRICT: u32 = 32768;
23pub const JS_PROP_NO_ADD: u32 = 65536;
24pub const JS_PROP_NO_EXOTIC: u32 = 131072;
25pub const JS_PROP_DEFINE_PROPERTY: u32 = 262144;
26pub const JS_PROP_REFLECT_DEFINE_PROPERTY: u32 = 524288;
27pub const JS_DEFAULT_STACK_SIZE: u32 = 1048576;
28pub const JS_EVAL_TYPE_GLOBAL: u32 = 0;
29pub const JS_EVAL_TYPE_MODULE: u32 = 1;
30pub const JS_EVAL_TYPE_DIRECT: u32 = 2;
31pub const JS_EVAL_TYPE_INDIRECT: u32 = 3;
32pub const JS_EVAL_TYPE_MASK: u32 = 3;
33pub const JS_EVAL_FLAG_STRICT: u32 = 8;
34pub const JS_EVAL_FLAG_UNUSED: u32 = 16;
35pub const JS_EVAL_FLAG_COMPILE_ONLY: u32 = 32;
36pub const JS_EVAL_FLAG_BACKTRACE_BARRIER: u32 = 64;
37pub const JS_EVAL_FLAG_ASYNC: u32 = 128;
38pub const JS_DUMP_BYTECODE_FINAL: u32 = 1;
39pub const JS_DUMP_BYTECODE_PASS2: u32 = 2;
40pub const JS_DUMP_BYTECODE_PASS1: u32 = 4;
41pub const JS_DUMP_BYTECODE_HEX: u32 = 16;
42pub const JS_DUMP_BYTECODE_PC2LINE: u32 = 32;
43pub const JS_DUMP_BYTECODE_STACK: u32 = 64;
44pub const JS_DUMP_BYTECODE_STEP: u32 = 128;
45pub const JS_DUMP_READ_OBJECT: u32 = 256;
46pub const JS_DUMP_FREE: u32 = 512;
47pub const JS_DUMP_GC: u32 = 1024;
48pub const JS_DUMP_GC_FREE: u32 = 2048;
49pub const JS_DUMP_MODULE_RESOLVE: u32 = 4096;
50pub const JS_DUMP_PROMISE: u32 = 8192;
51pub const JS_DUMP_LEAKS: u32 = 16384;
52pub const JS_DUMP_ATOM_LEAKS: u32 = 32768;
53pub const JS_DUMP_MEM: u32 = 65536;
54pub const JS_DUMP_OBJECTS: u32 = 131072;
55pub const JS_DUMP_ATOMS: u32 = 262144;
56pub const JS_DUMP_SHAPES: u32 = 524288;
57pub const JS_ATOM_NULL: u32 = 0;
58pub const JS_CALL_FLAG_CONSTRUCTOR: u32 = 1;
59pub const JS_INVALID_CLASS_ID: u32 = 0;
60pub const JS_GPN_STRING_MASK: u32 = 1;
61pub const JS_GPN_SYMBOL_MASK: u32 = 2;
62pub const JS_GPN_PRIVATE_MASK: u32 = 4;
63pub const JS_GPN_ENUM_ONLY: u32 = 16;
64pub const JS_GPN_SET_ENUM: u32 = 32;
65pub const JS_WRITE_OBJ_BYTECODE: u32 = 1;
66pub const JS_WRITE_OBJ_BSWAP: u32 = 0;
67pub const JS_WRITE_OBJ_SAB: u32 = 4;
68pub const JS_WRITE_OBJ_REFERENCE: u32 = 8;
69pub const JS_WRITE_OBJ_STRIP_SOURCE: u32 = 16;
70pub const JS_WRITE_OBJ_STRIP_DEBUG: u32 = 32;
71pub const JS_READ_OBJ_BYTECODE: u32 = 1;
72pub const JS_READ_OBJ_ROM_DATA: u32 = 0;
73pub const JS_READ_OBJ_SAB: u32 = 4;
74pub const JS_READ_OBJ_REFERENCE: u32 = 8;
75pub const JS_DEF_CFUNC: u32 = 0;
76pub const JS_DEF_CGETSET: u32 = 1;
77pub const JS_DEF_CGETSET_MAGIC: u32 = 2;
78pub const JS_DEF_PROP_STRING: u32 = 3;
79pub const JS_DEF_PROP_INT32: u32 = 4;
80pub const JS_DEF_PROP_INT64: u32 = 5;
81pub const JS_DEF_PROP_DOUBLE: u32 = 6;
82pub const JS_DEF_PROP_UNDEFINED: u32 = 7;
83pub const JS_DEF_OBJECT: u32 = 8;
84pub const JS_DEF_ALIAS: u32 = 9;
85pub type size_t = ::std::os::raw::c_uint;
86#[repr(C)]
87#[derive(Debug, Copy, Clone)]
88pub struct JSRuntime {
89 _unused: [u8; 0],
90}
91#[repr(C)]
92#[derive(Debug, Copy, Clone)]
93pub struct JSContext {
94 _unused: [u8; 0],
95}
96#[repr(C)]
97#[derive(Debug, Copy, Clone)]
98pub struct JSObject {
99 _unused: [u8; 0],
100}
101#[repr(C)]
102#[derive(Debug, Copy, Clone)]
103pub struct JSClass {
104 _unused: [u8; 0],
105}
106pub type JSClassID = u32;
107pub type JSAtom = u32;
108pub const JS_TAG_FIRST: _bindgen_ty_3 = -9;
109pub const JS_TAG_BIG_INT: _bindgen_ty_3 = -9;
110pub const JS_TAG_SYMBOL: _bindgen_ty_3 = -8;
111pub const JS_TAG_STRING: _bindgen_ty_3 = -7;
112pub const JS_TAG_MODULE: _bindgen_ty_3 = -3;
113pub const JS_TAG_FUNCTION_BYTECODE: _bindgen_ty_3 = -2;
114pub const JS_TAG_OBJECT: _bindgen_ty_3 = -1;
115pub const JS_TAG_INT: _bindgen_ty_3 = 0;
116pub const JS_TAG_BOOL: _bindgen_ty_3 = 1;
117pub const JS_TAG_NULL: _bindgen_ty_3 = 2;
118pub const JS_TAG_UNDEFINED: _bindgen_ty_3 = 3;
119pub const JS_TAG_UNINITIALIZED: _bindgen_ty_3 = 4;
120pub const JS_TAG_CATCH_OFFSET: _bindgen_ty_3 = 5;
121pub const JS_TAG_EXCEPTION: _bindgen_ty_3 = 6;
122pub const JS_TAG_FLOAT64: _bindgen_ty_3 = 7;
123pub type _bindgen_ty_3 = ::std::os::raw::c_int;
124pub type JSValue = u64;
125pub type JSCFunction = ::std::option::Option<
126 unsafe extern "C" fn(
127 ctx: *mut JSContext,
128 this_val: JSValue,
129 argc: ::std::os::raw::c_int,
130 argv: *mut JSValue,
131 ) -> JSValue,
132>;
133pub type JSCFunctionMagic = ::std::option::Option<
134 unsafe extern "C" fn(
135 ctx: *mut JSContext,
136 this_val: JSValue,
137 argc: ::std::os::raw::c_int,
138 argv: *mut JSValue,
139 magic: ::std::os::raw::c_int,
140 ) -> JSValue,
141>;
142pub type JSCFunctionData = ::std::option::Option<
143 unsafe extern "C" fn(
144 ctx: *mut JSContext,
145 this_val: JSValue,
146 argc: ::std::os::raw::c_int,
147 argv: *mut JSValue,
148 magic: ::std::os::raw::c_int,
149 func_data: *mut JSValue,
150 ) -> JSValue,
151>;
152#[repr(C)]
153#[derive(Debug, Copy, Clone)]
154pub struct JSMallocFunctions {
155 pub js_calloc: ::std::option::Option<
156 unsafe extern "C" fn(
157 opaque: *mut ::std::os::raw::c_void,
158 count: size_t,
159 size: size_t,
160 ) -> *mut ::std::os::raw::c_void,
161 >,
162 pub js_malloc: ::std::option::Option<
163 unsafe extern "C" fn(
164 opaque: *mut ::std::os::raw::c_void,
165 size: size_t,
166 ) -> *mut ::std::os::raw::c_void,
167 >,
168 pub js_free: ::std::option::Option<
169 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
170 >,
171 pub js_realloc: ::std::option::Option<
172 unsafe extern "C" fn(
173 opaque: *mut ::std::os::raw::c_void,
174 ptr: *mut ::std::os::raw::c_void,
175 size: size_t,
176 ) -> *mut ::std::os::raw::c_void,
177 >,
178 pub js_malloc_usable_size:
179 ::std::option::Option<unsafe extern "C" fn(ptr: *const ::std::os::raw::c_void) -> size_t>,
180}
181#[test]
182fn bindgen_test_layout_JSMallocFunctions() {
183 const UNINIT: ::std::mem::MaybeUninit<JSMallocFunctions> = ::std::mem::MaybeUninit::uninit();
184 let ptr = UNINIT.as_ptr();
185 assert_eq!(
186 ::std::mem::size_of::<JSMallocFunctions>(),
187 20usize,
188 concat!("Size of: ", stringify!(JSMallocFunctions))
189 );
190 assert_eq!(
191 ::std::mem::align_of::<JSMallocFunctions>(),
192 4usize,
193 concat!("Alignment of ", stringify!(JSMallocFunctions))
194 );
195 assert_eq!(
196 unsafe { ::std::ptr::addr_of!((*ptr).js_calloc) as usize - ptr as usize },
197 0usize,
198 concat!(
199 "Offset of field: ",
200 stringify!(JSMallocFunctions),
201 "::",
202 stringify!(js_calloc)
203 )
204 );
205 assert_eq!(
206 unsafe { ::std::ptr::addr_of!((*ptr).js_malloc) as usize - ptr as usize },
207 4usize,
208 concat!(
209 "Offset of field: ",
210 stringify!(JSMallocFunctions),
211 "::",
212 stringify!(js_malloc)
213 )
214 );
215 assert_eq!(
216 unsafe { ::std::ptr::addr_of!((*ptr).js_free) as usize - ptr as usize },
217 8usize,
218 concat!(
219 "Offset of field: ",
220 stringify!(JSMallocFunctions),
221 "::",
222 stringify!(js_free)
223 )
224 );
225 assert_eq!(
226 unsafe { ::std::ptr::addr_of!((*ptr).js_realloc) as usize - ptr as usize },
227 12usize,
228 concat!(
229 "Offset of field: ",
230 stringify!(JSMallocFunctions),
231 "::",
232 stringify!(js_realloc)
233 )
234 );
235 assert_eq!(
236 unsafe { ::std::ptr::addr_of!((*ptr).js_malloc_usable_size) as usize - ptr as usize },
237 16usize,
238 concat!(
239 "Offset of field: ",
240 stringify!(JSMallocFunctions),
241 "::",
242 stringify!(js_malloc_usable_size)
243 )
244 );
245}
246pub type JSRuntimeFinalizer = ::std::option::Option<
247 unsafe extern "C" fn(rt: *mut JSRuntime, arg: *mut ::std::os::raw::c_void),
248>;
249#[repr(C)]
250#[derive(Debug, Copy, Clone)]
251pub struct JSGCObjectHeader {
252 _unused: [u8; 0],
253}
254extern "C" {
255 pub fn JS_NewRuntime() -> *mut JSRuntime;
256}
257extern "C" {
258 pub fn JS_SetRuntimeInfo(rt: *mut JSRuntime, info: *const ::std::os::raw::c_char);
259}
260extern "C" {
261 pub fn JS_SetMemoryLimit(rt: *mut JSRuntime, limit: size_t);
262}
263extern "C" {
264 pub fn JS_SetDumpFlags(rt: *mut JSRuntime, flags: u64);
265}
266extern "C" {
267 pub fn JS_GetDumpFlags(rt: *mut JSRuntime) -> u64;
268}
269extern "C" {
270 pub fn JS_GetGCThreshold(rt: *mut JSRuntime) -> size_t;
271}
272extern "C" {
273 pub fn JS_SetGCThreshold(rt: *mut JSRuntime, gc_threshold: size_t);
274}
275extern "C" {
276 pub fn JS_SetMaxStackSize(rt: *mut JSRuntime, stack_size: size_t);
277}
278extern "C" {
279 pub fn JS_UpdateStackTop(rt: *mut JSRuntime);
280}
281extern "C" {
282 pub fn JS_NewRuntime2(
283 mf: *const JSMallocFunctions,
284 opaque: *mut ::std::os::raw::c_void,
285 ) -> *mut JSRuntime;
286}
287extern "C" {
288 pub fn JS_FreeRuntime(rt: *mut JSRuntime);
289}
290extern "C" {
291 pub fn JS_GetRuntimeOpaque(rt: *mut JSRuntime) -> *mut ::std::os::raw::c_void;
292}
293extern "C" {
294 pub fn JS_SetRuntimeOpaque(rt: *mut JSRuntime, opaque: *mut ::std::os::raw::c_void);
295}
296extern "C" {
297 pub fn JS_AddRuntimeFinalizer(
298 rt: *mut JSRuntime,
299 finalizer: JSRuntimeFinalizer,
300 arg: *mut ::std::os::raw::c_void,
301 ) -> ::std::os::raw::c_int;
302}
303pub type JS_MarkFunc =
304 ::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime, gp: *mut JSGCObjectHeader)>;
305extern "C" {
306 pub fn JS_MarkValue(rt: *mut JSRuntime, val: JSValue, mark_func: JS_MarkFunc);
307}
308extern "C" {
309 pub fn JS_RunGC(rt: *mut JSRuntime);
310}
311extern "C" {
312 pub fn JS_IsLiveObject(rt: *mut JSRuntime, obj: JSValue) -> bool;
313}
314extern "C" {
315 pub fn JS_NewContext(rt: *mut JSRuntime) -> *mut JSContext;
316}
317extern "C" {
318 pub fn JS_FreeContext(s: *mut JSContext);
319}
320extern "C" {
321 pub fn JS_DupContext(ctx: *mut JSContext) -> *mut JSContext;
322}
323extern "C" {
324 pub fn JS_GetContextOpaque(ctx: *mut JSContext) -> *mut ::std::os::raw::c_void;
325}
326extern "C" {
327 pub fn JS_SetContextOpaque(ctx: *mut JSContext, opaque: *mut ::std::os::raw::c_void);
328}
329extern "C" {
330 pub fn JS_GetRuntime(ctx: *mut JSContext) -> *mut JSRuntime;
331}
332extern "C" {
333 pub fn JS_SetClassProto(ctx: *mut JSContext, class_id: JSClassID, obj: JSValue);
334}
335extern "C" {
336 pub fn JS_GetClassProto(ctx: *mut JSContext, class_id: JSClassID) -> JSValue;
337}
338extern "C" {
339 pub fn JS_GetFunctionProto(ctx: *mut JSContext) -> JSValue;
340}
341extern "C" {
342 pub fn JS_NewContextRaw(rt: *mut JSRuntime) -> *mut JSContext;
343}
344extern "C" {
345 pub fn JS_AddIntrinsicBaseObjects(ctx: *mut JSContext);
346}
347extern "C" {
348 pub fn JS_AddIntrinsicDate(ctx: *mut JSContext);
349}
350extern "C" {
351 pub fn JS_AddIntrinsicEval(ctx: *mut JSContext);
352}
353extern "C" {
354 pub fn JS_AddIntrinsicRegExpCompiler(ctx: *mut JSContext);
355}
356extern "C" {
357 pub fn JS_AddIntrinsicRegExp(ctx: *mut JSContext);
358}
359extern "C" {
360 pub fn JS_AddIntrinsicJSON(ctx: *mut JSContext);
361}
362extern "C" {
363 pub fn JS_AddIntrinsicProxy(ctx: *mut JSContext);
364}
365extern "C" {
366 pub fn JS_AddIntrinsicMapSet(ctx: *mut JSContext);
367}
368extern "C" {
369 pub fn JS_AddIntrinsicTypedArrays(ctx: *mut JSContext);
370}
371extern "C" {
372 pub fn JS_AddIntrinsicPromise(ctx: *mut JSContext);
373}
374extern "C" {
375 pub fn JS_AddIntrinsicBigInt(ctx: *mut JSContext);
376}
377extern "C" {
378 pub fn JS_AddIntrinsicWeakRef(ctx: *mut JSContext);
379}
380extern "C" {
381 pub fn JS_AddPerformance(ctx: *mut JSContext);
382}
383extern "C" {
384 pub fn JS_IsEqual(ctx: *mut JSContext, op1: JSValue, op2: JSValue) -> ::std::os::raw::c_int;
385}
386extern "C" {
387 pub fn JS_IsStrictEqual(ctx: *mut JSContext, op1: JSValue, op2: JSValue) -> bool;
388}
389extern "C" {
390 pub fn JS_IsSameValue(ctx: *mut JSContext, op1: JSValue, op2: JSValue) -> bool;
391}
392extern "C" {
393 pub fn JS_IsSameValueZero(ctx: *mut JSContext, op1: JSValue, op2: JSValue) -> bool;
394}
395extern "C" {
396 pub fn js_string_codePointRange(
397 ctx: *mut JSContext,
398 this_val: JSValue,
399 argc: ::std::os::raw::c_int,
400 argv: *mut JSValue,
401 ) -> JSValue;
402}
403extern "C" {
404 pub fn js_calloc_rt(
405 rt: *mut JSRuntime,
406 count: size_t,
407 size: size_t,
408 ) -> *mut ::std::os::raw::c_void;
409}
410extern "C" {
411 pub fn js_malloc_rt(rt: *mut JSRuntime, size: size_t) -> *mut ::std::os::raw::c_void;
412}
413extern "C" {
414 pub fn js_free_rt(rt: *mut JSRuntime, ptr: *mut ::std::os::raw::c_void);
415}
416extern "C" {
417 pub fn js_realloc_rt(
418 rt: *mut JSRuntime,
419 ptr: *mut ::std::os::raw::c_void,
420 size: size_t,
421 ) -> *mut ::std::os::raw::c_void;
422}
423extern "C" {
424 pub fn js_malloc_usable_size_rt(
425 rt: *mut JSRuntime,
426 ptr: *const ::std::os::raw::c_void,
427 ) -> size_t;
428}
429extern "C" {
430 pub fn js_mallocz_rt(rt: *mut JSRuntime, size: size_t) -> *mut ::std::os::raw::c_void;
431}
432extern "C" {
433 pub fn js_calloc(
434 ctx: *mut JSContext,
435 count: size_t,
436 size: size_t,
437 ) -> *mut ::std::os::raw::c_void;
438}
439extern "C" {
440 pub fn js_malloc(ctx: *mut JSContext, size: size_t) -> *mut ::std::os::raw::c_void;
441}
442extern "C" {
443 pub fn js_free(ctx: *mut JSContext, ptr: *mut ::std::os::raw::c_void);
444}
445extern "C" {
446 pub fn js_realloc(
447 ctx: *mut JSContext,
448 ptr: *mut ::std::os::raw::c_void,
449 size: size_t,
450 ) -> *mut ::std::os::raw::c_void;
451}
452extern "C" {
453 pub fn js_malloc_usable_size(ctx: *mut JSContext, ptr: *const ::std::os::raw::c_void)
454 -> size_t;
455}
456extern "C" {
457 pub fn js_realloc2(
458 ctx: *mut JSContext,
459 ptr: *mut ::std::os::raw::c_void,
460 size: size_t,
461 pslack: *mut size_t,
462 ) -> *mut ::std::os::raw::c_void;
463}
464extern "C" {
465 pub fn js_mallocz(ctx: *mut JSContext, size: size_t) -> *mut ::std::os::raw::c_void;
466}
467extern "C" {
468 pub fn js_strdup(
469 ctx: *mut JSContext,
470 str_: *const ::std::os::raw::c_char,
471 ) -> *mut ::std::os::raw::c_char;
472}
473extern "C" {
474 pub fn js_strndup(
475 ctx: *mut JSContext,
476 s: *const ::std::os::raw::c_char,
477 n: size_t,
478 ) -> *mut ::std::os::raw::c_char;
479}
480#[repr(C)]
481#[derive(Debug, Copy, Clone)]
482pub struct JSMemoryUsage {
483 pub malloc_size: i64,
484 pub malloc_limit: i64,
485 pub memory_used_size: i64,
486 pub malloc_count: i64,
487 pub memory_used_count: i64,
488 pub atom_count: i64,
489 pub atom_size: i64,
490 pub str_count: i64,
491 pub str_size: i64,
492 pub obj_count: i64,
493 pub obj_size: i64,
494 pub prop_count: i64,
495 pub prop_size: i64,
496 pub shape_count: i64,
497 pub shape_size: i64,
498 pub js_func_count: i64,
499 pub js_func_size: i64,
500 pub js_func_code_size: i64,
501 pub js_func_pc2line_count: i64,
502 pub js_func_pc2line_size: i64,
503 pub c_func_count: i64,
504 pub array_count: i64,
505 pub fast_array_count: i64,
506 pub fast_array_elements: i64,
507 pub binary_object_count: i64,
508 pub binary_object_size: i64,
509}
510#[test]
511fn bindgen_test_layout_JSMemoryUsage() {
512 const UNINIT: ::std::mem::MaybeUninit<JSMemoryUsage> = ::std::mem::MaybeUninit::uninit();
513 let ptr = UNINIT.as_ptr();
514 assert_eq!(
515 ::std::mem::size_of::<JSMemoryUsage>(),
516 208usize,
517 concat!("Size of: ", stringify!(JSMemoryUsage))
518 );
519 assert_eq!(
520 ::std::mem::align_of::<JSMemoryUsage>(),
521 4usize,
522 concat!("Alignment of ", stringify!(JSMemoryUsage))
523 );
524 assert_eq!(
525 unsafe { ::std::ptr::addr_of!((*ptr).malloc_size) as usize - ptr as usize },
526 0usize,
527 concat!(
528 "Offset of field: ",
529 stringify!(JSMemoryUsage),
530 "::",
531 stringify!(malloc_size)
532 )
533 );
534 assert_eq!(
535 unsafe { ::std::ptr::addr_of!((*ptr).malloc_limit) as usize - ptr as usize },
536 8usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(JSMemoryUsage),
540 "::",
541 stringify!(malloc_limit)
542 )
543 );
544 assert_eq!(
545 unsafe { ::std::ptr::addr_of!((*ptr).memory_used_size) as usize - ptr as usize },
546 16usize,
547 concat!(
548 "Offset of field: ",
549 stringify!(JSMemoryUsage),
550 "::",
551 stringify!(memory_used_size)
552 )
553 );
554 assert_eq!(
555 unsafe { ::std::ptr::addr_of!((*ptr).malloc_count) as usize - ptr as usize },
556 24usize,
557 concat!(
558 "Offset of field: ",
559 stringify!(JSMemoryUsage),
560 "::",
561 stringify!(malloc_count)
562 )
563 );
564 assert_eq!(
565 unsafe { ::std::ptr::addr_of!((*ptr).memory_used_count) as usize - ptr as usize },
566 32usize,
567 concat!(
568 "Offset of field: ",
569 stringify!(JSMemoryUsage),
570 "::",
571 stringify!(memory_used_count)
572 )
573 );
574 assert_eq!(
575 unsafe { ::std::ptr::addr_of!((*ptr).atom_count) as usize - ptr as usize },
576 40usize,
577 concat!(
578 "Offset of field: ",
579 stringify!(JSMemoryUsage),
580 "::",
581 stringify!(atom_count)
582 )
583 );
584 assert_eq!(
585 unsafe { ::std::ptr::addr_of!((*ptr).atom_size) as usize - ptr as usize },
586 48usize,
587 concat!(
588 "Offset of field: ",
589 stringify!(JSMemoryUsage),
590 "::",
591 stringify!(atom_size)
592 )
593 );
594 assert_eq!(
595 unsafe { ::std::ptr::addr_of!((*ptr).str_count) as usize - ptr as usize },
596 56usize,
597 concat!(
598 "Offset of field: ",
599 stringify!(JSMemoryUsage),
600 "::",
601 stringify!(str_count)
602 )
603 );
604 assert_eq!(
605 unsafe { ::std::ptr::addr_of!((*ptr).str_size) as usize - ptr as usize },
606 64usize,
607 concat!(
608 "Offset of field: ",
609 stringify!(JSMemoryUsage),
610 "::",
611 stringify!(str_size)
612 )
613 );
614 assert_eq!(
615 unsafe { ::std::ptr::addr_of!((*ptr).obj_count) as usize - ptr as usize },
616 72usize,
617 concat!(
618 "Offset of field: ",
619 stringify!(JSMemoryUsage),
620 "::",
621 stringify!(obj_count)
622 )
623 );
624 assert_eq!(
625 unsafe { ::std::ptr::addr_of!((*ptr).obj_size) as usize - ptr as usize },
626 80usize,
627 concat!(
628 "Offset of field: ",
629 stringify!(JSMemoryUsage),
630 "::",
631 stringify!(obj_size)
632 )
633 );
634 assert_eq!(
635 unsafe { ::std::ptr::addr_of!((*ptr).prop_count) as usize - ptr as usize },
636 88usize,
637 concat!(
638 "Offset of field: ",
639 stringify!(JSMemoryUsage),
640 "::",
641 stringify!(prop_count)
642 )
643 );
644 assert_eq!(
645 unsafe { ::std::ptr::addr_of!((*ptr).prop_size) as usize - ptr as usize },
646 96usize,
647 concat!(
648 "Offset of field: ",
649 stringify!(JSMemoryUsage),
650 "::",
651 stringify!(prop_size)
652 )
653 );
654 assert_eq!(
655 unsafe { ::std::ptr::addr_of!((*ptr).shape_count) as usize - ptr as usize },
656 104usize,
657 concat!(
658 "Offset of field: ",
659 stringify!(JSMemoryUsage),
660 "::",
661 stringify!(shape_count)
662 )
663 );
664 assert_eq!(
665 unsafe { ::std::ptr::addr_of!((*ptr).shape_size) as usize - ptr as usize },
666 112usize,
667 concat!(
668 "Offset of field: ",
669 stringify!(JSMemoryUsage),
670 "::",
671 stringify!(shape_size)
672 )
673 );
674 assert_eq!(
675 unsafe { ::std::ptr::addr_of!((*ptr).js_func_count) as usize - ptr as usize },
676 120usize,
677 concat!(
678 "Offset of field: ",
679 stringify!(JSMemoryUsage),
680 "::",
681 stringify!(js_func_count)
682 )
683 );
684 assert_eq!(
685 unsafe { ::std::ptr::addr_of!((*ptr).js_func_size) as usize - ptr as usize },
686 128usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(JSMemoryUsage),
690 "::",
691 stringify!(js_func_size)
692 )
693 );
694 assert_eq!(
695 unsafe { ::std::ptr::addr_of!((*ptr).js_func_code_size) as usize - ptr as usize },
696 136usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(JSMemoryUsage),
700 "::",
701 stringify!(js_func_code_size)
702 )
703 );
704 assert_eq!(
705 unsafe { ::std::ptr::addr_of!((*ptr).js_func_pc2line_count) as usize - ptr as usize },
706 144usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(JSMemoryUsage),
710 "::",
711 stringify!(js_func_pc2line_count)
712 )
713 );
714 assert_eq!(
715 unsafe { ::std::ptr::addr_of!((*ptr).js_func_pc2line_size) as usize - ptr as usize },
716 152usize,
717 concat!(
718 "Offset of field: ",
719 stringify!(JSMemoryUsage),
720 "::",
721 stringify!(js_func_pc2line_size)
722 )
723 );
724 assert_eq!(
725 unsafe { ::std::ptr::addr_of!((*ptr).c_func_count) as usize - ptr as usize },
726 160usize,
727 concat!(
728 "Offset of field: ",
729 stringify!(JSMemoryUsage),
730 "::",
731 stringify!(c_func_count)
732 )
733 );
734 assert_eq!(
735 unsafe { ::std::ptr::addr_of!((*ptr).array_count) as usize - ptr as usize },
736 168usize,
737 concat!(
738 "Offset of field: ",
739 stringify!(JSMemoryUsage),
740 "::",
741 stringify!(array_count)
742 )
743 );
744 assert_eq!(
745 unsafe { ::std::ptr::addr_of!((*ptr).fast_array_count) as usize - ptr as usize },
746 176usize,
747 concat!(
748 "Offset of field: ",
749 stringify!(JSMemoryUsage),
750 "::",
751 stringify!(fast_array_count)
752 )
753 );
754 assert_eq!(
755 unsafe { ::std::ptr::addr_of!((*ptr).fast_array_elements) as usize - ptr as usize },
756 184usize,
757 concat!(
758 "Offset of field: ",
759 stringify!(JSMemoryUsage),
760 "::",
761 stringify!(fast_array_elements)
762 )
763 );
764 assert_eq!(
765 unsafe { ::std::ptr::addr_of!((*ptr).binary_object_count) as usize - ptr as usize },
766 192usize,
767 concat!(
768 "Offset of field: ",
769 stringify!(JSMemoryUsage),
770 "::",
771 stringify!(binary_object_count)
772 )
773 );
774 assert_eq!(
775 unsafe { ::std::ptr::addr_of!((*ptr).binary_object_size) as usize - ptr as usize },
776 200usize,
777 concat!(
778 "Offset of field: ",
779 stringify!(JSMemoryUsage),
780 "::",
781 stringify!(binary_object_size)
782 )
783 );
784}
785extern "C" {
786 pub fn JS_ComputeMemoryUsage(rt: *mut JSRuntime, s: *mut JSMemoryUsage);
787}
788extern "C" {
789 pub fn JS_NewAtomLen(
790 ctx: *mut JSContext,
791 str_: *const ::std::os::raw::c_char,
792 len: size_t,
793 ) -> JSAtom;
794}
795extern "C" {
796 pub fn JS_NewAtom(ctx: *mut JSContext, str_: *const ::std::os::raw::c_char) -> JSAtom;
797}
798extern "C" {
799 pub fn JS_NewAtomUInt32(ctx: *mut JSContext, n: u32) -> JSAtom;
800}
801extern "C" {
802 pub fn JS_DupAtom(ctx: *mut JSContext, v: JSAtom) -> JSAtom;
803}
804extern "C" {
805 pub fn JS_FreeAtom(ctx: *mut JSContext, v: JSAtom);
806}
807extern "C" {
808 pub fn JS_FreeAtomRT(rt: *mut JSRuntime, v: JSAtom);
809}
810extern "C" {
811 pub fn JS_AtomToValue(ctx: *mut JSContext, atom: JSAtom) -> JSValue;
812}
813extern "C" {
814 pub fn JS_AtomToString(ctx: *mut JSContext, atom: JSAtom) -> JSValue;
815}
816extern "C" {
817 pub fn JS_AtomToCString(ctx: *mut JSContext, atom: JSAtom) -> *const ::std::os::raw::c_char;
818}
819extern "C" {
820 pub fn JS_ValueToAtom(ctx: *mut JSContext, val: JSValue) -> JSAtom;
821}
822#[repr(C)]
823#[derive(Debug, Copy, Clone)]
824pub struct JSPropertyEnum {
825 pub is_enumerable: bool,
826 pub atom: JSAtom,
827}
828#[test]
829fn bindgen_test_layout_JSPropertyEnum() {
830 const UNINIT: ::std::mem::MaybeUninit<JSPropertyEnum> = ::std::mem::MaybeUninit::uninit();
831 let ptr = UNINIT.as_ptr();
832 assert_eq!(
833 ::std::mem::size_of::<JSPropertyEnum>(),
834 8usize,
835 concat!("Size of: ", stringify!(JSPropertyEnum))
836 );
837 assert_eq!(
838 ::std::mem::align_of::<JSPropertyEnum>(),
839 4usize,
840 concat!("Alignment of ", stringify!(JSPropertyEnum))
841 );
842 assert_eq!(
843 unsafe { ::std::ptr::addr_of!((*ptr).is_enumerable) as usize - ptr as usize },
844 0usize,
845 concat!(
846 "Offset of field: ",
847 stringify!(JSPropertyEnum),
848 "::",
849 stringify!(is_enumerable)
850 )
851 );
852 assert_eq!(
853 unsafe { ::std::ptr::addr_of!((*ptr).atom) as usize - ptr as usize },
854 4usize,
855 concat!(
856 "Offset of field: ",
857 stringify!(JSPropertyEnum),
858 "::",
859 stringify!(atom)
860 )
861 );
862}
863#[repr(C)]
864#[derive(Debug, Copy, Clone)]
865pub struct JSPropertyDescriptor {
866 pub flags: ::std::os::raw::c_int,
867 pub value: JSValue,
868 pub getter: JSValue,
869 pub setter: JSValue,
870}
871#[test]
872fn bindgen_test_layout_JSPropertyDescriptor() {
873 const UNINIT: ::std::mem::MaybeUninit<JSPropertyDescriptor> = ::std::mem::MaybeUninit::uninit();
874 let ptr = UNINIT.as_ptr();
875 assert_eq!(
876 ::std::mem::size_of::<JSPropertyDescriptor>(),
877 28usize,
878 concat!("Size of: ", stringify!(JSPropertyDescriptor))
879 );
880 assert_eq!(
881 ::std::mem::align_of::<JSPropertyDescriptor>(),
882 4usize,
883 concat!("Alignment of ", stringify!(JSPropertyDescriptor))
884 );
885 assert_eq!(
886 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
887 0usize,
888 concat!(
889 "Offset of field: ",
890 stringify!(JSPropertyDescriptor),
891 "::",
892 stringify!(flags)
893 )
894 );
895 assert_eq!(
896 unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
897 4usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(JSPropertyDescriptor),
901 "::",
902 stringify!(value)
903 )
904 );
905 assert_eq!(
906 unsafe { ::std::ptr::addr_of!((*ptr).getter) as usize - ptr as usize },
907 12usize,
908 concat!(
909 "Offset of field: ",
910 stringify!(JSPropertyDescriptor),
911 "::",
912 stringify!(getter)
913 )
914 );
915 assert_eq!(
916 unsafe { ::std::ptr::addr_of!((*ptr).setter) as usize - ptr as usize },
917 20usize,
918 concat!(
919 "Offset of field: ",
920 stringify!(JSPropertyDescriptor),
921 "::",
922 stringify!(setter)
923 )
924 );
925}
926#[repr(C)]
927#[derive(Debug, Copy, Clone)]
928pub struct JSClassExoticMethods {
929 pub get_own_property: ::std::option::Option<
930 unsafe extern "C" fn(
931 ctx: *mut JSContext,
932 desc: *mut JSPropertyDescriptor,
933 obj: JSValue,
934 prop: JSAtom,
935 ) -> ::std::os::raw::c_int,
936 >,
937 pub get_own_property_names: ::std::option::Option<
938 unsafe extern "C" fn(
939 ctx: *mut JSContext,
940 ptab: *mut *mut JSPropertyEnum,
941 plen: *mut u32,
942 obj: JSValue,
943 ) -> ::std::os::raw::c_int,
944 >,
945 pub delete_property: ::std::option::Option<
946 unsafe extern "C" fn(
947 ctx: *mut JSContext,
948 obj: JSValue,
949 prop: JSAtom,
950 ) -> ::std::os::raw::c_int,
951 >,
952 pub define_own_property: ::std::option::Option<
953 unsafe extern "C" fn(
954 ctx: *mut JSContext,
955 this_obj: JSValue,
956 prop: JSAtom,
957 val: JSValue,
958 getter: JSValue,
959 setter: JSValue,
960 flags: ::std::os::raw::c_int,
961 ) -> ::std::os::raw::c_int,
962 >,
963 pub has_property: ::std::option::Option<
964 unsafe extern "C" fn(
965 ctx: *mut JSContext,
966 obj: JSValue,
967 atom: JSAtom,
968 ) -> ::std::os::raw::c_int,
969 >,
970 pub get_property: ::std::option::Option<
971 unsafe extern "C" fn(
972 ctx: *mut JSContext,
973 obj: JSValue,
974 atom: JSAtom,
975 receiver: JSValue,
976 ) -> JSValue,
977 >,
978 pub set_property: ::std::option::Option<
979 unsafe extern "C" fn(
980 ctx: *mut JSContext,
981 obj: JSValue,
982 atom: JSAtom,
983 value: JSValue,
984 receiver: JSValue,
985 flags: ::std::os::raw::c_int,
986 ) -> ::std::os::raw::c_int,
987 >,
988}
989#[test]
990fn bindgen_test_layout_JSClassExoticMethods() {
991 const UNINIT: ::std::mem::MaybeUninit<JSClassExoticMethods> = ::std::mem::MaybeUninit::uninit();
992 let ptr = UNINIT.as_ptr();
993 assert_eq!(
994 ::std::mem::size_of::<JSClassExoticMethods>(),
995 28usize,
996 concat!("Size of: ", stringify!(JSClassExoticMethods))
997 );
998 assert_eq!(
999 ::std::mem::align_of::<JSClassExoticMethods>(),
1000 4usize,
1001 concat!("Alignment of ", stringify!(JSClassExoticMethods))
1002 );
1003 assert_eq!(
1004 unsafe { ::std::ptr::addr_of!((*ptr).get_own_property) as usize - ptr as usize },
1005 0usize,
1006 concat!(
1007 "Offset of field: ",
1008 stringify!(JSClassExoticMethods),
1009 "::",
1010 stringify!(get_own_property)
1011 )
1012 );
1013 assert_eq!(
1014 unsafe { ::std::ptr::addr_of!((*ptr).get_own_property_names) as usize - ptr as usize },
1015 4usize,
1016 concat!(
1017 "Offset of field: ",
1018 stringify!(JSClassExoticMethods),
1019 "::",
1020 stringify!(get_own_property_names)
1021 )
1022 );
1023 assert_eq!(
1024 unsafe { ::std::ptr::addr_of!((*ptr).delete_property) as usize - ptr as usize },
1025 8usize,
1026 concat!(
1027 "Offset of field: ",
1028 stringify!(JSClassExoticMethods),
1029 "::",
1030 stringify!(delete_property)
1031 )
1032 );
1033 assert_eq!(
1034 unsafe { ::std::ptr::addr_of!((*ptr).define_own_property) as usize - ptr as usize },
1035 12usize,
1036 concat!(
1037 "Offset of field: ",
1038 stringify!(JSClassExoticMethods),
1039 "::",
1040 stringify!(define_own_property)
1041 )
1042 );
1043 assert_eq!(
1044 unsafe { ::std::ptr::addr_of!((*ptr).has_property) as usize - ptr as usize },
1045 16usize,
1046 concat!(
1047 "Offset of field: ",
1048 stringify!(JSClassExoticMethods),
1049 "::",
1050 stringify!(has_property)
1051 )
1052 );
1053 assert_eq!(
1054 unsafe { ::std::ptr::addr_of!((*ptr).get_property) as usize - ptr as usize },
1055 20usize,
1056 concat!(
1057 "Offset of field: ",
1058 stringify!(JSClassExoticMethods),
1059 "::",
1060 stringify!(get_property)
1061 )
1062 );
1063 assert_eq!(
1064 unsafe { ::std::ptr::addr_of!((*ptr).set_property) as usize - ptr as usize },
1065 24usize,
1066 concat!(
1067 "Offset of field: ",
1068 stringify!(JSClassExoticMethods),
1069 "::",
1070 stringify!(set_property)
1071 )
1072 );
1073}
1074pub type JSClassFinalizer =
1075 ::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime, val: JSValue)>;
1076pub type JSClassGCMark = ::std::option::Option<
1077 unsafe extern "C" fn(rt: *mut JSRuntime, val: JSValue, mark_func: JS_MarkFunc),
1078>;
1079pub type JSClassCall = ::std::option::Option<
1080 unsafe extern "C" fn(
1081 ctx: *mut JSContext,
1082 func_obj: JSValue,
1083 this_val: JSValue,
1084 argc: ::std::os::raw::c_int,
1085 argv: *mut JSValue,
1086 flags: ::std::os::raw::c_int,
1087 ) -> JSValue,
1088>;
1089#[repr(C)]
1090#[derive(Debug, Copy, Clone)]
1091pub struct JSClassDef {
1092 pub class_name: *const ::std::os::raw::c_char,
1093 pub finalizer: JSClassFinalizer,
1094 pub gc_mark: JSClassGCMark,
1095 pub call: JSClassCall,
1096 pub exotic: *mut JSClassExoticMethods,
1097}
1098#[test]
1099fn bindgen_test_layout_JSClassDef() {
1100 const UNINIT: ::std::mem::MaybeUninit<JSClassDef> = ::std::mem::MaybeUninit::uninit();
1101 let ptr = UNINIT.as_ptr();
1102 assert_eq!(
1103 ::std::mem::size_of::<JSClassDef>(),
1104 20usize,
1105 concat!("Size of: ", stringify!(JSClassDef))
1106 );
1107 assert_eq!(
1108 ::std::mem::align_of::<JSClassDef>(),
1109 4usize,
1110 concat!("Alignment of ", stringify!(JSClassDef))
1111 );
1112 assert_eq!(
1113 unsafe { ::std::ptr::addr_of!((*ptr).class_name) as usize - ptr as usize },
1114 0usize,
1115 concat!(
1116 "Offset of field: ",
1117 stringify!(JSClassDef),
1118 "::",
1119 stringify!(class_name)
1120 )
1121 );
1122 assert_eq!(
1123 unsafe { ::std::ptr::addr_of!((*ptr).finalizer) as usize - ptr as usize },
1124 4usize,
1125 concat!(
1126 "Offset of field: ",
1127 stringify!(JSClassDef),
1128 "::",
1129 stringify!(finalizer)
1130 )
1131 );
1132 assert_eq!(
1133 unsafe { ::std::ptr::addr_of!((*ptr).gc_mark) as usize - ptr as usize },
1134 8usize,
1135 concat!(
1136 "Offset of field: ",
1137 stringify!(JSClassDef),
1138 "::",
1139 stringify!(gc_mark)
1140 )
1141 );
1142 assert_eq!(
1143 unsafe { ::std::ptr::addr_of!((*ptr).call) as usize - ptr as usize },
1144 12usize,
1145 concat!(
1146 "Offset of field: ",
1147 stringify!(JSClassDef),
1148 "::",
1149 stringify!(call)
1150 )
1151 );
1152 assert_eq!(
1153 unsafe { ::std::ptr::addr_of!((*ptr).exotic) as usize - ptr as usize },
1154 16usize,
1155 concat!(
1156 "Offset of field: ",
1157 stringify!(JSClassDef),
1158 "::",
1159 stringify!(exotic)
1160 )
1161 );
1162}
1163extern "C" {
1164 pub fn JS_NewClassID(rt: *mut JSRuntime, pclass_id: *mut JSClassID) -> JSClassID;
1165}
1166extern "C" {
1167 pub fn JS_GetClassID(v: JSValue) -> JSClassID;
1168}
1169extern "C" {
1170 pub fn JS_NewClass(
1171 rt: *mut JSRuntime,
1172 class_id: JSClassID,
1173 class_def: *const JSClassDef,
1174 ) -> ::std::os::raw::c_int;
1175}
1176extern "C" {
1177 pub fn JS_IsRegisteredClass(rt: *mut JSRuntime, class_id: JSClassID) -> bool;
1178}
1179extern "C" {
1180 pub fn JS_NewNumber(ctx: *mut JSContext, d: f64) -> JSValue;
1181}
1182extern "C" {
1183 pub fn JS_NewBigInt64(ctx: *mut JSContext, v: i64) -> JSValue;
1184}
1185extern "C" {
1186 pub fn JS_NewBigUint64(ctx: *mut JSContext, v: u64) -> JSValue;
1187}
1188extern "C" {
1189 pub fn JS_Throw(ctx: *mut JSContext, obj: JSValue) -> JSValue;
1190}
1191extern "C" {
1192 pub fn JS_GetException(ctx: *mut JSContext) -> JSValue;
1193}
1194extern "C" {
1195 pub fn JS_HasException(ctx: *mut JSContext) -> bool;
1196}
1197extern "C" {
1198 pub fn JS_IsError(ctx: *mut JSContext, val: JSValue) -> bool;
1199}
1200extern "C" {
1201 pub fn JS_IsUncatchableError(ctx: *mut JSContext, val: JSValue) -> bool;
1202}
1203extern "C" {
1204 pub fn JS_SetUncatchableError(ctx: *mut JSContext, val: JSValue);
1205}
1206extern "C" {
1207 pub fn JS_ClearUncatchableError(ctx: *mut JSContext, val: JSValue);
1208}
1209extern "C" {
1210 pub fn JS_ResetUncatchableError(ctx: *mut JSContext);
1211}
1212extern "C" {
1213 pub fn JS_NewError(ctx: *mut JSContext) -> JSValue;
1214}
1215extern "C" {
1216 pub fn JS_ThrowPlainError(
1217 ctx: *mut JSContext,
1218 fmt: *const ::std::os::raw::c_char,
1219 ...
1220 ) -> JSValue;
1221}
1222extern "C" {
1223 pub fn JS_ThrowSyntaxError(
1224 ctx: *mut JSContext,
1225 fmt: *const ::std::os::raw::c_char,
1226 ...
1227 ) -> JSValue;
1228}
1229extern "C" {
1230 pub fn JS_ThrowTypeError(
1231 ctx: *mut JSContext,
1232 fmt: *const ::std::os::raw::c_char,
1233 ...
1234 ) -> JSValue;
1235}
1236extern "C" {
1237 pub fn JS_ThrowReferenceError(
1238 ctx: *mut JSContext,
1239 fmt: *const ::std::os::raw::c_char,
1240 ...
1241 ) -> JSValue;
1242}
1243extern "C" {
1244 pub fn JS_ThrowRangeError(
1245 ctx: *mut JSContext,
1246 fmt: *const ::std::os::raw::c_char,
1247 ...
1248 ) -> JSValue;
1249}
1250extern "C" {
1251 pub fn JS_ThrowInternalError(
1252 ctx: *mut JSContext,
1253 fmt: *const ::std::os::raw::c_char,
1254 ...
1255 ) -> JSValue;
1256}
1257extern "C" {
1258 pub fn JS_ThrowOutOfMemory(ctx: *mut JSContext) -> JSValue;
1259}
1260extern "C" {
1261 pub fn JS_FreeValue(ctx: *mut JSContext, v: JSValue);
1262}
1263extern "C" {
1264 pub fn JS_FreeValueRT(rt: *mut JSRuntime, v: JSValue);
1265}
1266extern "C" {
1267 pub fn JS_DupValue(ctx: *mut JSContext, v: JSValue) -> JSValue;
1268}
1269extern "C" {
1270 pub fn JS_DupValueRT(rt: *mut JSRuntime, v: JSValue) -> JSValue;
1271}
1272extern "C" {
1273 pub fn JS_ToBool(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
1274}
1275extern "C" {
1276 pub fn JS_ToNumber(ctx: *mut JSContext, val: JSValue) -> JSValue;
1277}
1278extern "C" {
1279 pub fn JS_ToInt32(ctx: *mut JSContext, pres: *mut i32, val: JSValue) -> ::std::os::raw::c_int;
1280}
1281extern "C" {
1282 pub fn JS_ToInt64(ctx: *mut JSContext, pres: *mut i64, val: JSValue) -> ::std::os::raw::c_int;
1283}
1284extern "C" {
1285 pub fn JS_ToIndex(ctx: *mut JSContext, plen: *mut u64, val: JSValue) -> ::std::os::raw::c_int;
1286}
1287extern "C" {
1288 pub fn JS_ToFloat64(ctx: *mut JSContext, pres: *mut f64, val: JSValue)
1289 -> ::std::os::raw::c_int;
1290}
1291extern "C" {
1292 pub fn JS_ToBigInt64(
1293 ctx: *mut JSContext,
1294 pres: *mut i64,
1295 val: JSValue,
1296 ) -> ::std::os::raw::c_int;
1297}
1298extern "C" {
1299 pub fn JS_ToBigUint64(
1300 ctx: *mut JSContext,
1301 pres: *mut u64,
1302 val: JSValue,
1303 ) -> ::std::os::raw::c_int;
1304}
1305extern "C" {
1306 pub fn JS_ToInt64Ext(
1307 ctx: *mut JSContext,
1308 pres: *mut i64,
1309 val: JSValue,
1310 ) -> ::std::os::raw::c_int;
1311}
1312extern "C" {
1313 pub fn JS_NewStringLen(
1314 ctx: *mut JSContext,
1315 str1: *const ::std::os::raw::c_char,
1316 len1: size_t,
1317 ) -> JSValue;
1318}
1319extern "C" {
1320 pub fn JS_NewAtomString(ctx: *mut JSContext, str_: *const ::std::os::raw::c_char) -> JSValue;
1321}
1322extern "C" {
1323 pub fn JS_ToString(ctx: *mut JSContext, val: JSValue) -> JSValue;
1324}
1325extern "C" {
1326 pub fn JS_ToPropertyKey(ctx: *mut JSContext, val: JSValue) -> JSValue;
1327}
1328extern "C" {
1329 pub fn JS_ToCStringLen2(
1330 ctx: *mut JSContext,
1331 plen: *mut size_t,
1332 val1: JSValue,
1333 cesu8: bool,
1334 ) -> *const ::std::os::raw::c_char;
1335}
1336extern "C" {
1337 pub fn JS_FreeCString(ctx: *mut JSContext, ptr: *const ::std::os::raw::c_char);
1338}
1339extern "C" {
1340 pub fn JS_NewObjectProtoClass(
1341 ctx: *mut JSContext,
1342 proto: JSValue,
1343 class_id: JSClassID,
1344 ) -> JSValue;
1345}
1346extern "C" {
1347 pub fn JS_NewObjectClass(ctx: *mut JSContext, class_id: ::std::os::raw::c_int) -> JSValue;
1348}
1349extern "C" {
1350 pub fn JS_NewObjectProto(ctx: *mut JSContext, proto: JSValue) -> JSValue;
1351}
1352extern "C" {
1353 pub fn JS_NewObject(ctx: *mut JSContext) -> JSValue;
1354}
1355extern "C" {
1356 pub fn JS_ToObject(ctx: *mut JSContext, val: JSValue) -> JSValue;
1357}
1358extern "C" {
1359 pub fn JS_ToObjectString(ctx: *mut JSContext, val: JSValue) -> JSValue;
1360}
1361extern "C" {
1362 pub fn JS_IsFunction(ctx: *mut JSContext, val: JSValue) -> bool;
1363}
1364extern "C" {
1365 pub fn JS_IsConstructor(ctx: *mut JSContext, val: JSValue) -> bool;
1366}
1367extern "C" {
1368 pub fn JS_SetConstructorBit(ctx: *mut JSContext, func_obj: JSValue, val: bool) -> bool;
1369}
1370extern "C" {
1371 pub fn JS_IsRegExp(val: JSValue) -> bool;
1372}
1373extern "C" {
1374 pub fn JS_IsMap(val: JSValue) -> bool;
1375}
1376extern "C" {
1377 pub fn JS_NewArray(ctx: *mut JSContext) -> JSValue;
1378}
1379extern "C" {
1380 pub fn JS_IsArray(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
1381}
1382extern "C" {
1383 pub fn JS_NewDate(ctx: *mut JSContext, epoch_ms: f64) -> JSValue;
1384}
1385extern "C" {
1386 pub fn JS_IsDate(v: JSValue) -> bool;
1387}
1388extern "C" {
1389 pub fn JS_GetProperty(ctx: *mut JSContext, this_obj: JSValue, prop: JSAtom) -> JSValue;
1390}
1391extern "C" {
1392 pub fn JS_GetPropertyUint32(ctx: *mut JSContext, this_obj: JSValue, idx: u32) -> JSValue;
1393}
1394extern "C" {
1395 pub fn JS_GetPropertyInt64(ctx: *mut JSContext, this_obj: JSValue, idx: i64) -> JSValue;
1396}
1397extern "C" {
1398 pub fn JS_GetPropertyStr(
1399 ctx: *mut JSContext,
1400 this_obj: JSValue,
1401 prop: *const ::std::os::raw::c_char,
1402 ) -> JSValue;
1403}
1404extern "C" {
1405 pub fn JS_SetProperty(
1406 ctx: *mut JSContext,
1407 this_obj: JSValue,
1408 prop: JSAtom,
1409 val: JSValue,
1410 ) -> ::std::os::raw::c_int;
1411}
1412extern "C" {
1413 pub fn JS_SetPropertyUint32(
1414 ctx: *mut JSContext,
1415 this_obj: JSValue,
1416 idx: u32,
1417 val: JSValue,
1418 ) -> ::std::os::raw::c_int;
1419}
1420extern "C" {
1421 pub fn JS_SetPropertyInt64(
1422 ctx: *mut JSContext,
1423 this_obj: JSValue,
1424 idx: i64,
1425 val: JSValue,
1426 ) -> ::std::os::raw::c_int;
1427}
1428extern "C" {
1429 pub fn JS_SetPropertyStr(
1430 ctx: *mut JSContext,
1431 this_obj: JSValue,
1432 prop: *const ::std::os::raw::c_char,
1433 val: JSValue,
1434 ) -> ::std::os::raw::c_int;
1435}
1436extern "C" {
1437 pub fn JS_HasProperty(
1438 ctx: *mut JSContext,
1439 this_obj: JSValue,
1440 prop: JSAtom,
1441 ) -> ::std::os::raw::c_int;
1442}
1443extern "C" {
1444 pub fn JS_IsExtensible(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
1445}
1446extern "C" {
1447 pub fn JS_PreventExtensions(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
1448}
1449extern "C" {
1450 pub fn JS_DeleteProperty(
1451 ctx: *mut JSContext,
1452 obj: JSValue,
1453 prop: JSAtom,
1454 flags: ::std::os::raw::c_int,
1455 ) -> ::std::os::raw::c_int;
1456}
1457extern "C" {
1458 pub fn JS_SetPrototype(
1459 ctx: *mut JSContext,
1460 obj: JSValue,
1461 proto_val: JSValue,
1462 ) -> ::std::os::raw::c_int;
1463}
1464extern "C" {
1465 pub fn JS_GetPrototype(ctx: *mut JSContext, val: JSValue) -> JSValue;
1466}
1467extern "C" {
1468 pub fn JS_GetLength(ctx: *mut JSContext, obj: JSValue, pres: *mut i64)
1469 -> ::std::os::raw::c_int;
1470}
1471extern "C" {
1472 pub fn JS_SetLength(ctx: *mut JSContext, obj: JSValue, len: i64) -> ::std::os::raw::c_int;
1473}
1474extern "C" {
1475 pub fn JS_SealObject(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
1476}
1477extern "C" {
1478 pub fn JS_FreezeObject(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
1479}
1480extern "C" {
1481 pub fn JS_GetOwnPropertyNames(
1482 ctx: *mut JSContext,
1483 ptab: *mut *mut JSPropertyEnum,
1484 plen: *mut u32,
1485 obj: JSValue,
1486 flags: ::std::os::raw::c_int,
1487 ) -> ::std::os::raw::c_int;
1488}
1489extern "C" {
1490 pub fn JS_GetOwnProperty(
1491 ctx: *mut JSContext,
1492 desc: *mut JSPropertyDescriptor,
1493 obj: JSValue,
1494 prop: JSAtom,
1495 ) -> ::std::os::raw::c_int;
1496}
1497extern "C" {
1498 pub fn JS_FreePropertyEnum(ctx: *mut JSContext, tab: *mut JSPropertyEnum, len: u32);
1499}
1500extern "C" {
1501 pub fn JS_Call(
1502 ctx: *mut JSContext,
1503 func_obj: JSValue,
1504 this_obj: JSValue,
1505 argc: ::std::os::raw::c_int,
1506 argv: *mut JSValue,
1507 ) -> JSValue;
1508}
1509extern "C" {
1510 pub fn JS_Invoke(
1511 ctx: *mut JSContext,
1512 this_val: JSValue,
1513 atom: JSAtom,
1514 argc: ::std::os::raw::c_int,
1515 argv: *mut JSValue,
1516 ) -> JSValue;
1517}
1518extern "C" {
1519 pub fn JS_CallConstructor(
1520 ctx: *mut JSContext,
1521 func_obj: JSValue,
1522 argc: ::std::os::raw::c_int,
1523 argv: *mut JSValue,
1524 ) -> JSValue;
1525}
1526extern "C" {
1527 pub fn JS_CallConstructor2(
1528 ctx: *mut JSContext,
1529 func_obj: JSValue,
1530 new_target: JSValue,
1531 argc: ::std::os::raw::c_int,
1532 argv: *mut JSValue,
1533 ) -> JSValue;
1534}
1535extern "C" {
1536 pub fn JS_DetectModule(input: *const ::std::os::raw::c_char, input_len: size_t) -> bool;
1537}
1538extern "C" {
1539 pub fn JS_Eval(
1540 ctx: *mut JSContext,
1541 input: *const ::std::os::raw::c_char,
1542 input_len: size_t,
1543 filename: *const ::std::os::raw::c_char,
1544 eval_flags: ::std::os::raw::c_int,
1545 ) -> JSValue;
1546}
1547extern "C" {
1548 pub fn JS_EvalThis(
1549 ctx: *mut JSContext,
1550 this_obj: JSValue,
1551 input: *const ::std::os::raw::c_char,
1552 input_len: size_t,
1553 filename: *const ::std::os::raw::c_char,
1554 eval_flags: ::std::os::raw::c_int,
1555 ) -> JSValue;
1556}
1557extern "C" {
1558 pub fn JS_GetGlobalObject(ctx: *mut JSContext) -> JSValue;
1559}
1560extern "C" {
1561 pub fn JS_IsInstanceOf(
1562 ctx: *mut JSContext,
1563 val: JSValue,
1564 obj: JSValue,
1565 ) -> ::std::os::raw::c_int;
1566}
1567extern "C" {
1568 pub fn JS_DefineProperty(
1569 ctx: *mut JSContext,
1570 this_obj: JSValue,
1571 prop: JSAtom,
1572 val: JSValue,
1573 getter: JSValue,
1574 setter: JSValue,
1575 flags: ::std::os::raw::c_int,
1576 ) -> ::std::os::raw::c_int;
1577}
1578extern "C" {
1579 pub fn JS_DefinePropertyValue(
1580 ctx: *mut JSContext,
1581 this_obj: JSValue,
1582 prop: JSAtom,
1583 val: JSValue,
1584 flags: ::std::os::raw::c_int,
1585 ) -> ::std::os::raw::c_int;
1586}
1587extern "C" {
1588 pub fn JS_DefinePropertyValueUint32(
1589 ctx: *mut JSContext,
1590 this_obj: JSValue,
1591 idx: u32,
1592 val: JSValue,
1593 flags: ::std::os::raw::c_int,
1594 ) -> ::std::os::raw::c_int;
1595}
1596extern "C" {
1597 pub fn JS_DefinePropertyValueStr(
1598 ctx: *mut JSContext,
1599 this_obj: JSValue,
1600 prop: *const ::std::os::raw::c_char,
1601 val: JSValue,
1602 flags: ::std::os::raw::c_int,
1603 ) -> ::std::os::raw::c_int;
1604}
1605extern "C" {
1606 pub fn JS_DefinePropertyGetSet(
1607 ctx: *mut JSContext,
1608 this_obj: JSValue,
1609 prop: JSAtom,
1610 getter: JSValue,
1611 setter: JSValue,
1612 flags: ::std::os::raw::c_int,
1613 ) -> ::std::os::raw::c_int;
1614}
1615extern "C" {
1616 pub fn JS_SetOpaque(obj: JSValue, opaque: *mut ::std::os::raw::c_void)
1617 -> ::std::os::raw::c_int;
1618}
1619extern "C" {
1620 pub fn JS_GetOpaque(obj: JSValue, class_id: JSClassID) -> *mut ::std::os::raw::c_void;
1621}
1622extern "C" {
1623 pub fn JS_GetOpaque2(
1624 ctx: *mut JSContext,
1625 obj: JSValue,
1626 class_id: JSClassID,
1627 ) -> *mut ::std::os::raw::c_void;
1628}
1629extern "C" {
1630 pub fn JS_GetAnyOpaque(obj: JSValue, class_id: *mut JSClassID) -> *mut ::std::os::raw::c_void;
1631}
1632extern "C" {
1633 pub fn JS_ParseJSON(
1634 ctx: *mut JSContext,
1635 buf: *const ::std::os::raw::c_char,
1636 buf_len: size_t,
1637 filename: *const ::std::os::raw::c_char,
1638 ) -> JSValue;
1639}
1640extern "C" {
1641 pub fn JS_JSONStringify(
1642 ctx: *mut JSContext,
1643 obj: JSValue,
1644 replacer: JSValue,
1645 space0: JSValue,
1646 ) -> JSValue;
1647}
1648pub type JSFreeArrayBufferDataFunc = ::std::option::Option<
1649 unsafe extern "C" fn(
1650 rt: *mut JSRuntime,
1651 opaque: *mut ::std::os::raw::c_void,
1652 ptr: *mut ::std::os::raw::c_void,
1653 ),
1654>;
1655extern "C" {
1656 pub fn JS_NewArrayBuffer(
1657 ctx: *mut JSContext,
1658 buf: *mut u8,
1659 len: size_t,
1660 free_func: JSFreeArrayBufferDataFunc,
1661 opaque: *mut ::std::os::raw::c_void,
1662 is_shared: bool,
1663 ) -> JSValue;
1664}
1665extern "C" {
1666 pub fn JS_NewArrayBufferCopy(ctx: *mut JSContext, buf: *const u8, len: size_t) -> JSValue;
1667}
1668extern "C" {
1669 pub fn JS_DetachArrayBuffer(ctx: *mut JSContext, obj: JSValue);
1670}
1671extern "C" {
1672 pub fn JS_GetArrayBuffer(ctx: *mut JSContext, psize: *mut size_t, obj: JSValue) -> *mut u8;
1673}
1674extern "C" {
1675 pub fn JS_IsArrayBuffer(obj: JSValue) -> bool;
1676}
1677extern "C" {
1678 pub fn JS_GetUint8Array(ctx: *mut JSContext, psize: *mut size_t, obj: JSValue) -> *mut u8;
1679}
1680pub const JSTypedArrayEnum_JS_TYPED_ARRAY_UINT8C: JSTypedArrayEnum = 0;
1681pub const JSTypedArrayEnum_JS_TYPED_ARRAY_INT8: JSTypedArrayEnum = 1;
1682pub const JSTypedArrayEnum_JS_TYPED_ARRAY_UINT8: JSTypedArrayEnum = 2;
1683pub const JSTypedArrayEnum_JS_TYPED_ARRAY_INT16: JSTypedArrayEnum = 3;
1684pub const JSTypedArrayEnum_JS_TYPED_ARRAY_UINT16: JSTypedArrayEnum = 4;
1685pub const JSTypedArrayEnum_JS_TYPED_ARRAY_INT32: JSTypedArrayEnum = 5;
1686pub const JSTypedArrayEnum_JS_TYPED_ARRAY_UINT32: JSTypedArrayEnum = 6;
1687pub const JSTypedArrayEnum_JS_TYPED_ARRAY_BIG_INT64: JSTypedArrayEnum = 7;
1688pub const JSTypedArrayEnum_JS_TYPED_ARRAY_BIG_UINT64: JSTypedArrayEnum = 8;
1689pub const JSTypedArrayEnum_JS_TYPED_ARRAY_FLOAT16: JSTypedArrayEnum = 9;
1690pub const JSTypedArrayEnum_JS_TYPED_ARRAY_FLOAT32: JSTypedArrayEnum = 10;
1691pub const JSTypedArrayEnum_JS_TYPED_ARRAY_FLOAT64: JSTypedArrayEnum = 11;
1692pub type JSTypedArrayEnum = ::std::os::raw::c_uint;
1693extern "C" {
1694 pub fn JS_NewTypedArray(
1695 ctx: *mut JSContext,
1696 argc: ::std::os::raw::c_int,
1697 argv: *mut JSValue,
1698 array_type: JSTypedArrayEnum,
1699 ) -> JSValue;
1700}
1701extern "C" {
1702 pub fn JS_GetTypedArrayBuffer(
1703 ctx: *mut JSContext,
1704 obj: JSValue,
1705 pbyte_offset: *mut size_t,
1706 pbyte_length: *mut size_t,
1707 pbytes_per_element: *mut size_t,
1708 ) -> JSValue;
1709}
1710extern "C" {
1711 pub fn JS_NewUint8Array(
1712 ctx: *mut JSContext,
1713 buf: *mut u8,
1714 len: size_t,
1715 free_func: JSFreeArrayBufferDataFunc,
1716 opaque: *mut ::std::os::raw::c_void,
1717 is_shared: bool,
1718 ) -> JSValue;
1719}
1720extern "C" {
1721 pub fn JS_GetTypedArrayType(obj: JSValue) -> ::std::os::raw::c_int;
1722}
1723extern "C" {
1724 pub fn JS_NewUint8ArrayCopy(ctx: *mut JSContext, buf: *const u8, len: size_t) -> JSValue;
1725}
1726#[repr(C)]
1727#[derive(Debug, Copy, Clone)]
1728pub struct JSSharedArrayBufferFunctions {
1729 pub sab_alloc: ::std::option::Option<
1730 unsafe extern "C" fn(
1731 opaque: *mut ::std::os::raw::c_void,
1732 size: size_t,
1733 ) -> *mut ::std::os::raw::c_void,
1734 >,
1735 pub sab_free: ::std::option::Option<
1736 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
1737 >,
1738 pub sab_dup: ::std::option::Option<
1739 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
1740 >,
1741 pub sab_opaque: *mut ::std::os::raw::c_void,
1742}
1743#[test]
1744fn bindgen_test_layout_JSSharedArrayBufferFunctions() {
1745 const UNINIT: ::std::mem::MaybeUninit<JSSharedArrayBufferFunctions> =
1746 ::std::mem::MaybeUninit::uninit();
1747 let ptr = UNINIT.as_ptr();
1748 assert_eq!(
1749 ::std::mem::size_of::<JSSharedArrayBufferFunctions>(),
1750 16usize,
1751 concat!("Size of: ", stringify!(JSSharedArrayBufferFunctions))
1752 );
1753 assert_eq!(
1754 ::std::mem::align_of::<JSSharedArrayBufferFunctions>(),
1755 4usize,
1756 concat!("Alignment of ", stringify!(JSSharedArrayBufferFunctions))
1757 );
1758 assert_eq!(
1759 unsafe { ::std::ptr::addr_of!((*ptr).sab_alloc) as usize - ptr as usize },
1760 0usize,
1761 concat!(
1762 "Offset of field: ",
1763 stringify!(JSSharedArrayBufferFunctions),
1764 "::",
1765 stringify!(sab_alloc)
1766 )
1767 );
1768 assert_eq!(
1769 unsafe { ::std::ptr::addr_of!((*ptr).sab_free) as usize - ptr as usize },
1770 4usize,
1771 concat!(
1772 "Offset of field: ",
1773 stringify!(JSSharedArrayBufferFunctions),
1774 "::",
1775 stringify!(sab_free)
1776 )
1777 );
1778 assert_eq!(
1779 unsafe { ::std::ptr::addr_of!((*ptr).sab_dup) as usize - ptr as usize },
1780 8usize,
1781 concat!(
1782 "Offset of field: ",
1783 stringify!(JSSharedArrayBufferFunctions),
1784 "::",
1785 stringify!(sab_dup)
1786 )
1787 );
1788 assert_eq!(
1789 unsafe { ::std::ptr::addr_of!((*ptr).sab_opaque) as usize - ptr as usize },
1790 12usize,
1791 concat!(
1792 "Offset of field: ",
1793 stringify!(JSSharedArrayBufferFunctions),
1794 "::",
1795 stringify!(sab_opaque)
1796 )
1797 );
1798}
1799extern "C" {
1800 pub fn JS_SetSharedArrayBufferFunctions(
1801 rt: *mut JSRuntime,
1802 sf: *const JSSharedArrayBufferFunctions,
1803 );
1804}
1805pub const JSPromiseStateEnum_JS_PROMISE_PENDING: JSPromiseStateEnum = 0;
1806pub const JSPromiseStateEnum_JS_PROMISE_FULFILLED: JSPromiseStateEnum = 1;
1807pub const JSPromiseStateEnum_JS_PROMISE_REJECTED: JSPromiseStateEnum = 2;
1808pub type JSPromiseStateEnum = ::std::os::raw::c_uint;
1809extern "C" {
1810 pub fn JS_NewPromiseCapability(ctx: *mut JSContext, resolving_funcs: *mut JSValue) -> JSValue;
1811}
1812extern "C" {
1813 pub fn JS_PromiseState(ctx: *mut JSContext, promise: JSValue) -> JSPromiseStateEnum;
1814}
1815extern "C" {
1816 pub fn JS_PromiseResult(ctx: *mut JSContext, promise: JSValue) -> JSValue;
1817}
1818extern "C" {
1819 pub fn JS_IsPromise(val: JSValue) -> bool;
1820}
1821extern "C" {
1822 pub fn JS_NewSymbol(
1823 ctx: *mut JSContext,
1824 description: *const ::std::os::raw::c_char,
1825 is_global: bool,
1826 ) -> JSValue;
1827}
1828pub type JSHostPromiseRejectionTracker = ::std::option::Option<
1829 unsafe extern "C" fn(
1830 ctx: *mut JSContext,
1831 promise: JSValue,
1832 reason: JSValue,
1833 is_handled: bool,
1834 opaque: *mut ::std::os::raw::c_void,
1835 ),
1836>;
1837extern "C" {
1838 pub fn JS_SetHostPromiseRejectionTracker(
1839 rt: *mut JSRuntime,
1840 cb: JSHostPromiseRejectionTracker,
1841 opaque: *mut ::std::os::raw::c_void,
1842 );
1843}
1844pub type JSInterruptHandler = ::std::option::Option<
1845 unsafe extern "C" fn(
1846 rt: *mut JSRuntime,
1847 opaque: *mut ::std::os::raw::c_void,
1848 ) -> ::std::os::raw::c_int,
1849>;
1850extern "C" {
1851 pub fn JS_SetInterruptHandler(
1852 rt: *mut JSRuntime,
1853 cb: JSInterruptHandler,
1854 opaque: *mut ::std::os::raw::c_void,
1855 );
1856}
1857extern "C" {
1858 pub fn JS_SetCanBlock(rt: *mut JSRuntime, can_block: bool);
1859}
1860extern "C" {
1861 pub fn JS_SetIsHTMLDDA(ctx: *mut JSContext, obj: JSValue);
1862}
1863#[repr(C)]
1864#[derive(Debug, Copy, Clone)]
1865pub struct JSModuleDef {
1866 _unused: [u8; 0],
1867}
1868pub type JSModuleNormalizeFunc = ::std::option::Option<
1869 unsafe extern "C" fn(
1870 ctx: *mut JSContext,
1871 module_base_name: *const ::std::os::raw::c_char,
1872 module_name: *const ::std::os::raw::c_char,
1873 opaque: *mut ::std::os::raw::c_void,
1874 ) -> *mut ::std::os::raw::c_char,
1875>;
1876pub type JSModuleLoaderFunc = ::std::option::Option<
1877 unsafe extern "C" fn(
1878 ctx: *mut JSContext,
1879 module_name: *const ::std::os::raw::c_char,
1880 opaque: *mut ::std::os::raw::c_void,
1881 ) -> *mut JSModuleDef,
1882>;
1883extern "C" {
1884 pub fn JS_SetModuleLoaderFunc(
1885 rt: *mut JSRuntime,
1886 module_normalize: JSModuleNormalizeFunc,
1887 module_loader: JSModuleLoaderFunc,
1888 opaque: *mut ::std::os::raw::c_void,
1889 );
1890}
1891extern "C" {
1892 pub fn JS_GetImportMeta(ctx: *mut JSContext, m: *mut JSModuleDef) -> JSValue;
1893}
1894extern "C" {
1895 pub fn JS_GetModuleName(ctx: *mut JSContext, m: *mut JSModuleDef) -> JSAtom;
1896}
1897extern "C" {
1898 pub fn JS_GetModuleNamespace(ctx: *mut JSContext, m: *mut JSModuleDef) -> JSValue;
1899}
1900pub type JSJobFunc = ::std::option::Option<
1901 unsafe extern "C" fn(
1902 ctx: *mut JSContext,
1903 argc: ::std::os::raw::c_int,
1904 argv: *mut JSValue,
1905 ) -> JSValue,
1906>;
1907extern "C" {
1908 pub fn JS_EnqueueJob(
1909 ctx: *mut JSContext,
1910 job_func: JSJobFunc,
1911 argc: ::std::os::raw::c_int,
1912 argv: *mut JSValue,
1913 ) -> ::std::os::raw::c_int;
1914}
1915extern "C" {
1916 pub fn JS_IsJobPending(rt: *mut JSRuntime) -> bool;
1917}
1918extern "C" {
1919 pub fn JS_ExecutePendingJob(
1920 rt: *mut JSRuntime,
1921 pctx: *mut *mut JSContext,
1922 ) -> ::std::os::raw::c_int;
1923}
1924#[repr(C)]
1925#[derive(Debug, Copy, Clone)]
1926pub struct JSSABTab {
1927 pub tab: *mut *mut u8,
1928 pub len: size_t,
1929}
1930#[test]
1931fn bindgen_test_layout_JSSABTab() {
1932 const UNINIT: ::std::mem::MaybeUninit<JSSABTab> = ::std::mem::MaybeUninit::uninit();
1933 let ptr = UNINIT.as_ptr();
1934 assert_eq!(
1935 ::std::mem::size_of::<JSSABTab>(),
1936 8usize,
1937 concat!("Size of: ", stringify!(JSSABTab))
1938 );
1939 assert_eq!(
1940 ::std::mem::align_of::<JSSABTab>(),
1941 4usize,
1942 concat!("Alignment of ", stringify!(JSSABTab))
1943 );
1944 assert_eq!(
1945 unsafe { ::std::ptr::addr_of!((*ptr).tab) as usize - ptr as usize },
1946 0usize,
1947 concat!(
1948 "Offset of field: ",
1949 stringify!(JSSABTab),
1950 "::",
1951 stringify!(tab)
1952 )
1953 );
1954 assert_eq!(
1955 unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
1956 4usize,
1957 concat!(
1958 "Offset of field: ",
1959 stringify!(JSSABTab),
1960 "::",
1961 stringify!(len)
1962 )
1963 );
1964}
1965extern "C" {
1966 pub fn JS_WriteObject(
1967 ctx: *mut JSContext,
1968 psize: *mut size_t,
1969 obj: JSValue,
1970 flags: ::std::os::raw::c_int,
1971 ) -> *mut u8;
1972}
1973extern "C" {
1974 pub fn JS_WriteObject2(
1975 ctx: *mut JSContext,
1976 psize: *mut size_t,
1977 obj: JSValue,
1978 flags: ::std::os::raw::c_int,
1979 psab_tab: *mut JSSABTab,
1980 ) -> *mut u8;
1981}
1982extern "C" {
1983 pub fn JS_ReadObject(
1984 ctx: *mut JSContext,
1985 buf: *const u8,
1986 buf_len: size_t,
1987 flags: ::std::os::raw::c_int,
1988 ) -> JSValue;
1989}
1990extern "C" {
1991 pub fn JS_ReadObject2(
1992 ctx: *mut JSContext,
1993 buf: *const u8,
1994 buf_len: size_t,
1995 flags: ::std::os::raw::c_int,
1996 psab_tab: *mut JSSABTab,
1997 ) -> JSValue;
1998}
1999extern "C" {
2000 pub fn JS_EvalFunction(ctx: *mut JSContext, fun_obj: JSValue) -> JSValue;
2001}
2002extern "C" {
2003 pub fn JS_ResolveModule(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
2004}
2005extern "C" {
2006 pub fn JS_GetScriptOrModuleName(
2007 ctx: *mut JSContext,
2008 n_stack_levels: ::std::os::raw::c_int,
2009 ) -> JSAtom;
2010}
2011extern "C" {
2012 pub fn JS_LoadModule(
2013 ctx: *mut JSContext,
2014 basename: *const ::std::os::raw::c_char,
2015 filename: *const ::std::os::raw::c_char,
2016 ) -> JSValue;
2017}
2018pub const JSCFunctionEnum_JS_CFUNC_generic: JSCFunctionEnum = 0;
2019pub const JSCFunctionEnum_JS_CFUNC_generic_magic: JSCFunctionEnum = 1;
2020pub const JSCFunctionEnum_JS_CFUNC_constructor: JSCFunctionEnum = 2;
2021pub const JSCFunctionEnum_JS_CFUNC_constructor_magic: JSCFunctionEnum = 3;
2022pub const JSCFunctionEnum_JS_CFUNC_constructor_or_func: JSCFunctionEnum = 4;
2023pub const JSCFunctionEnum_JS_CFUNC_constructor_or_func_magic: JSCFunctionEnum = 5;
2024pub const JSCFunctionEnum_JS_CFUNC_f_f: JSCFunctionEnum = 6;
2025pub const JSCFunctionEnum_JS_CFUNC_f_f_f: JSCFunctionEnum = 7;
2026pub const JSCFunctionEnum_JS_CFUNC_getter: JSCFunctionEnum = 8;
2027pub const JSCFunctionEnum_JS_CFUNC_setter: JSCFunctionEnum = 9;
2028pub const JSCFunctionEnum_JS_CFUNC_getter_magic: JSCFunctionEnum = 10;
2029pub const JSCFunctionEnum_JS_CFUNC_setter_magic: JSCFunctionEnum = 11;
2030pub const JSCFunctionEnum_JS_CFUNC_iterator_next: JSCFunctionEnum = 12;
2031pub type JSCFunctionEnum = ::std::os::raw::c_uint;
2032#[repr(C)]
2033#[derive(Copy, Clone)]
2034pub union JSCFunctionType {
2035 pub generic: JSCFunction,
2036 pub generic_magic: ::std::option::Option<
2037 unsafe extern "C" fn(
2038 ctx: *mut JSContext,
2039 this_val: JSValue,
2040 argc: ::std::os::raw::c_int,
2041 argv: *mut JSValue,
2042 magic: ::std::os::raw::c_int,
2043 ) -> JSValue,
2044 >,
2045 pub constructor: JSCFunction,
2046 pub constructor_magic: ::std::option::Option<
2047 unsafe extern "C" fn(
2048 ctx: *mut JSContext,
2049 new_target: JSValue,
2050 argc: ::std::os::raw::c_int,
2051 argv: *mut JSValue,
2052 magic: ::std::os::raw::c_int,
2053 ) -> JSValue,
2054 >,
2055 pub constructor_or_func: JSCFunction,
2056 pub f_f: ::std::option::Option<unsafe extern "C" fn(arg1: f64) -> f64>,
2057 pub f_f_f: ::std::option::Option<unsafe extern "C" fn(arg1: f64, arg2: f64) -> f64>,
2058 pub getter: ::std::option::Option<
2059 unsafe extern "C" fn(ctx: *mut JSContext, this_val: JSValue) -> JSValue,
2060 >,
2061 pub setter: ::std::option::Option<
2062 unsafe extern "C" fn(ctx: *mut JSContext, this_val: JSValue, val: JSValue) -> JSValue,
2063 >,
2064 pub getter_magic: ::std::option::Option<
2065 unsafe extern "C" fn(
2066 ctx: *mut JSContext,
2067 this_val: JSValue,
2068 magic: ::std::os::raw::c_int,
2069 ) -> JSValue,
2070 >,
2071 pub setter_magic: ::std::option::Option<
2072 unsafe extern "C" fn(
2073 ctx: *mut JSContext,
2074 this_val: JSValue,
2075 val: JSValue,
2076 magic: ::std::os::raw::c_int,
2077 ) -> JSValue,
2078 >,
2079 pub iterator_next: ::std::option::Option<
2080 unsafe extern "C" fn(
2081 ctx: *mut JSContext,
2082 this_val: JSValue,
2083 argc: ::std::os::raw::c_int,
2084 argv: *mut JSValue,
2085 pdone: *mut ::std::os::raw::c_int,
2086 magic: ::std::os::raw::c_int,
2087 ) -> JSValue,
2088 >,
2089}
2090#[test]
2091fn bindgen_test_layout_JSCFunctionType() {
2092 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionType> = ::std::mem::MaybeUninit::uninit();
2093 let ptr = UNINIT.as_ptr();
2094 assert_eq!(
2095 ::std::mem::size_of::<JSCFunctionType>(),
2096 4usize,
2097 concat!("Size of: ", stringify!(JSCFunctionType))
2098 );
2099 assert_eq!(
2100 ::std::mem::align_of::<JSCFunctionType>(),
2101 4usize,
2102 concat!("Alignment of ", stringify!(JSCFunctionType))
2103 );
2104 assert_eq!(
2105 unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize },
2106 0usize,
2107 concat!(
2108 "Offset of field: ",
2109 stringify!(JSCFunctionType),
2110 "::",
2111 stringify!(generic)
2112 )
2113 );
2114 assert_eq!(
2115 unsafe { ::std::ptr::addr_of!((*ptr).generic_magic) as usize - ptr as usize },
2116 0usize,
2117 concat!(
2118 "Offset of field: ",
2119 stringify!(JSCFunctionType),
2120 "::",
2121 stringify!(generic_magic)
2122 )
2123 );
2124 assert_eq!(
2125 unsafe { ::std::ptr::addr_of!((*ptr).constructor) as usize - ptr as usize },
2126 0usize,
2127 concat!(
2128 "Offset of field: ",
2129 stringify!(JSCFunctionType),
2130 "::",
2131 stringify!(constructor)
2132 )
2133 );
2134 assert_eq!(
2135 unsafe { ::std::ptr::addr_of!((*ptr).constructor_magic) as usize - ptr as usize },
2136 0usize,
2137 concat!(
2138 "Offset of field: ",
2139 stringify!(JSCFunctionType),
2140 "::",
2141 stringify!(constructor_magic)
2142 )
2143 );
2144 assert_eq!(
2145 unsafe { ::std::ptr::addr_of!((*ptr).constructor_or_func) as usize - ptr as usize },
2146 0usize,
2147 concat!(
2148 "Offset of field: ",
2149 stringify!(JSCFunctionType),
2150 "::",
2151 stringify!(constructor_or_func)
2152 )
2153 );
2154 assert_eq!(
2155 unsafe { ::std::ptr::addr_of!((*ptr).f_f) as usize - ptr as usize },
2156 0usize,
2157 concat!(
2158 "Offset of field: ",
2159 stringify!(JSCFunctionType),
2160 "::",
2161 stringify!(f_f)
2162 )
2163 );
2164 assert_eq!(
2165 unsafe { ::std::ptr::addr_of!((*ptr).f_f_f) as usize - ptr as usize },
2166 0usize,
2167 concat!(
2168 "Offset of field: ",
2169 stringify!(JSCFunctionType),
2170 "::",
2171 stringify!(f_f_f)
2172 )
2173 );
2174 assert_eq!(
2175 unsafe { ::std::ptr::addr_of!((*ptr).getter) as usize - ptr as usize },
2176 0usize,
2177 concat!(
2178 "Offset of field: ",
2179 stringify!(JSCFunctionType),
2180 "::",
2181 stringify!(getter)
2182 )
2183 );
2184 assert_eq!(
2185 unsafe { ::std::ptr::addr_of!((*ptr).setter) as usize - ptr as usize },
2186 0usize,
2187 concat!(
2188 "Offset of field: ",
2189 stringify!(JSCFunctionType),
2190 "::",
2191 stringify!(setter)
2192 )
2193 );
2194 assert_eq!(
2195 unsafe { ::std::ptr::addr_of!((*ptr).getter_magic) as usize - ptr as usize },
2196 0usize,
2197 concat!(
2198 "Offset of field: ",
2199 stringify!(JSCFunctionType),
2200 "::",
2201 stringify!(getter_magic)
2202 )
2203 );
2204 assert_eq!(
2205 unsafe { ::std::ptr::addr_of!((*ptr).setter_magic) as usize - ptr as usize },
2206 0usize,
2207 concat!(
2208 "Offset of field: ",
2209 stringify!(JSCFunctionType),
2210 "::",
2211 stringify!(setter_magic)
2212 )
2213 );
2214 assert_eq!(
2215 unsafe { ::std::ptr::addr_of!((*ptr).iterator_next) as usize - ptr as usize },
2216 0usize,
2217 concat!(
2218 "Offset of field: ",
2219 stringify!(JSCFunctionType),
2220 "::",
2221 stringify!(iterator_next)
2222 )
2223 );
2224}
2225extern "C" {
2226 pub fn JS_NewCFunction2(
2227 ctx: *mut JSContext,
2228 func: JSCFunction,
2229 name: *const ::std::os::raw::c_char,
2230 length: ::std::os::raw::c_int,
2231 cproto: JSCFunctionEnum,
2232 magic: ::std::os::raw::c_int,
2233 ) -> JSValue;
2234}
2235extern "C" {
2236 pub fn JS_NewCFunctionData(
2237 ctx: *mut JSContext,
2238 func: JSCFunctionData,
2239 length: ::std::os::raw::c_int,
2240 magic: ::std::os::raw::c_int,
2241 data_len: ::std::os::raw::c_int,
2242 data: *mut JSValue,
2243 ) -> JSValue;
2244}
2245extern "C" {
2246 pub fn JS_SetConstructor(ctx: *mut JSContext, func_obj: JSValue, proto: JSValue);
2247}
2248#[repr(C)]
2249#[derive(Copy, Clone)]
2250pub struct JSCFunctionListEntry {
2251 pub name: *const ::std::os::raw::c_char,
2252 pub prop_flags: u8,
2253 pub def_type: u8,
2254 pub magic: i16,
2255 pub u: JSCFunctionListEntry__bindgen_ty_1,
2256}
2257#[repr(C)]
2258#[derive(Copy, Clone)]
2259pub union JSCFunctionListEntry__bindgen_ty_1 {
2260 pub func: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1,
2261 pub getset: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2,
2262 pub alias: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3,
2263 pub prop_list: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4,
2264 pub str_: *const ::std::os::raw::c_char,
2265 pub i32_: i32,
2266 pub i64_: i64,
2267 pub u64_: u64,
2268 pub f64_: f64,
2269}
2270#[repr(C)]
2271#[derive(Copy, Clone)]
2272pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1 {
2273 pub length: u8,
2274 pub cproto: u8,
2275 pub cfunc: JSCFunctionType,
2276}
2277#[test]
2278fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1() {
2279 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1> =
2280 ::std::mem::MaybeUninit::uninit();
2281 let ptr = UNINIT.as_ptr();
2282 assert_eq!(
2283 ::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>(),
2284 8usize,
2285 concat!(
2286 "Size of: ",
2287 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1)
2288 )
2289 );
2290 assert_eq!(
2291 ::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>(),
2292 4usize,
2293 concat!(
2294 "Alignment of ",
2295 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1)
2296 )
2297 );
2298 assert_eq!(
2299 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
2300 0usize,
2301 concat!(
2302 "Offset of field: ",
2303 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
2304 "::",
2305 stringify!(length)
2306 )
2307 );
2308 assert_eq!(
2309 unsafe { ::std::ptr::addr_of!((*ptr).cproto) as usize - ptr as usize },
2310 1usize,
2311 concat!(
2312 "Offset of field: ",
2313 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
2314 "::",
2315 stringify!(cproto)
2316 )
2317 );
2318 assert_eq!(
2319 unsafe { ::std::ptr::addr_of!((*ptr).cfunc) as usize - ptr as usize },
2320 4usize,
2321 concat!(
2322 "Offset of field: ",
2323 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
2324 "::",
2325 stringify!(cfunc)
2326 )
2327 );
2328}
2329#[repr(C)]
2330#[derive(Copy, Clone)]
2331pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2 {
2332 pub get: JSCFunctionType,
2333 pub set: JSCFunctionType,
2334}
2335#[test]
2336fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2() {
2337 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2> =
2338 ::std::mem::MaybeUninit::uninit();
2339 let ptr = UNINIT.as_ptr();
2340 assert_eq!(
2341 ::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>(),
2342 8usize,
2343 concat!(
2344 "Size of: ",
2345 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2)
2346 )
2347 );
2348 assert_eq!(
2349 ::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>(),
2350 4usize,
2351 concat!(
2352 "Alignment of ",
2353 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2)
2354 )
2355 );
2356 assert_eq!(
2357 unsafe { ::std::ptr::addr_of!((*ptr).get) as usize - ptr as usize },
2358 0usize,
2359 concat!(
2360 "Offset of field: ",
2361 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2),
2362 "::",
2363 stringify!(get)
2364 )
2365 );
2366 assert_eq!(
2367 unsafe { ::std::ptr::addr_of!((*ptr).set) as usize - ptr as usize },
2368 4usize,
2369 concat!(
2370 "Offset of field: ",
2371 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2),
2372 "::",
2373 stringify!(set)
2374 )
2375 );
2376}
2377#[repr(C)]
2378#[derive(Debug, Copy, Clone)]
2379pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3 {
2380 pub name: *const ::std::os::raw::c_char,
2381 pub base: ::std::os::raw::c_int,
2382}
2383#[test]
2384fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3() {
2385 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3> =
2386 ::std::mem::MaybeUninit::uninit();
2387 let ptr = UNINIT.as_ptr();
2388 assert_eq!(
2389 ::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>(),
2390 8usize,
2391 concat!(
2392 "Size of: ",
2393 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3)
2394 )
2395 );
2396 assert_eq!(
2397 ::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>(),
2398 4usize,
2399 concat!(
2400 "Alignment of ",
2401 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3)
2402 )
2403 );
2404 assert_eq!(
2405 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2406 0usize,
2407 concat!(
2408 "Offset of field: ",
2409 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3),
2410 "::",
2411 stringify!(name)
2412 )
2413 );
2414 assert_eq!(
2415 unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
2416 4usize,
2417 concat!(
2418 "Offset of field: ",
2419 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3),
2420 "::",
2421 stringify!(base)
2422 )
2423 );
2424}
2425#[repr(C)]
2426#[derive(Debug, Copy, Clone)]
2427pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4 {
2428 pub tab: *const JSCFunctionListEntry,
2429 pub len: ::std::os::raw::c_int,
2430}
2431#[test]
2432fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4() {
2433 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4> =
2434 ::std::mem::MaybeUninit::uninit();
2435 let ptr = UNINIT.as_ptr();
2436 assert_eq!(
2437 ::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>(),
2438 8usize,
2439 concat!(
2440 "Size of: ",
2441 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4)
2442 )
2443 );
2444 assert_eq!(
2445 ::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>(),
2446 4usize,
2447 concat!(
2448 "Alignment of ",
2449 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4)
2450 )
2451 );
2452 assert_eq!(
2453 unsafe { ::std::ptr::addr_of!((*ptr).tab) as usize - ptr as usize },
2454 0usize,
2455 concat!(
2456 "Offset of field: ",
2457 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4),
2458 "::",
2459 stringify!(tab)
2460 )
2461 );
2462 assert_eq!(
2463 unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
2464 4usize,
2465 concat!(
2466 "Offset of field: ",
2467 stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4),
2468 "::",
2469 stringify!(len)
2470 )
2471 );
2472}
2473#[test]
2474fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1() {
2475 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry__bindgen_ty_1> =
2476 ::std::mem::MaybeUninit::uninit();
2477 let ptr = UNINIT.as_ptr();
2478 assert_eq!(
2479 ::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1>(),
2480 8usize,
2481 concat!("Size of: ", stringify!(JSCFunctionListEntry__bindgen_ty_1))
2482 );
2483 assert_eq!(
2484 ::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1>(),
2485 4usize,
2486 concat!(
2487 "Alignment of ",
2488 stringify!(JSCFunctionListEntry__bindgen_ty_1)
2489 )
2490 );
2491 assert_eq!(
2492 unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
2493 0usize,
2494 concat!(
2495 "Offset of field: ",
2496 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2497 "::",
2498 stringify!(func)
2499 )
2500 );
2501 assert_eq!(
2502 unsafe { ::std::ptr::addr_of!((*ptr).getset) as usize - ptr as usize },
2503 0usize,
2504 concat!(
2505 "Offset of field: ",
2506 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2507 "::",
2508 stringify!(getset)
2509 )
2510 );
2511 assert_eq!(
2512 unsafe { ::std::ptr::addr_of!((*ptr).alias) as usize - ptr as usize },
2513 0usize,
2514 concat!(
2515 "Offset of field: ",
2516 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2517 "::",
2518 stringify!(alias)
2519 )
2520 );
2521 assert_eq!(
2522 unsafe { ::std::ptr::addr_of!((*ptr).prop_list) as usize - ptr as usize },
2523 0usize,
2524 concat!(
2525 "Offset of field: ",
2526 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2527 "::",
2528 stringify!(prop_list)
2529 )
2530 );
2531 assert_eq!(
2532 unsafe { ::std::ptr::addr_of!((*ptr).str_) as usize - ptr as usize },
2533 0usize,
2534 concat!(
2535 "Offset of field: ",
2536 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2537 "::",
2538 stringify!(str_)
2539 )
2540 );
2541 assert_eq!(
2542 unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
2543 0usize,
2544 concat!(
2545 "Offset of field: ",
2546 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2547 "::",
2548 stringify!(i32_)
2549 )
2550 );
2551 assert_eq!(
2552 unsafe { ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize },
2553 0usize,
2554 concat!(
2555 "Offset of field: ",
2556 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2557 "::",
2558 stringify!(i64_)
2559 )
2560 );
2561 assert_eq!(
2562 unsafe { ::std::ptr::addr_of!((*ptr).u64_) as usize - ptr as usize },
2563 0usize,
2564 concat!(
2565 "Offset of field: ",
2566 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2567 "::",
2568 stringify!(u64_)
2569 )
2570 );
2571 assert_eq!(
2572 unsafe { ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize },
2573 0usize,
2574 concat!(
2575 "Offset of field: ",
2576 stringify!(JSCFunctionListEntry__bindgen_ty_1),
2577 "::",
2578 stringify!(f64_)
2579 )
2580 );
2581}
2582#[test]
2583fn bindgen_test_layout_JSCFunctionListEntry() {
2584 const UNINIT: ::std::mem::MaybeUninit<JSCFunctionListEntry> = ::std::mem::MaybeUninit::uninit();
2585 let ptr = UNINIT.as_ptr();
2586 assert_eq!(
2587 ::std::mem::size_of::<JSCFunctionListEntry>(),
2588 16usize,
2589 concat!("Size of: ", stringify!(JSCFunctionListEntry))
2590 );
2591 assert_eq!(
2592 ::std::mem::align_of::<JSCFunctionListEntry>(),
2593 4usize,
2594 concat!("Alignment of ", stringify!(JSCFunctionListEntry))
2595 );
2596 assert_eq!(
2597 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2598 0usize,
2599 concat!(
2600 "Offset of field: ",
2601 stringify!(JSCFunctionListEntry),
2602 "::",
2603 stringify!(name)
2604 )
2605 );
2606 assert_eq!(
2607 unsafe { ::std::ptr::addr_of!((*ptr).prop_flags) as usize - ptr as usize },
2608 4usize,
2609 concat!(
2610 "Offset of field: ",
2611 stringify!(JSCFunctionListEntry),
2612 "::",
2613 stringify!(prop_flags)
2614 )
2615 );
2616 assert_eq!(
2617 unsafe { ::std::ptr::addr_of!((*ptr).def_type) as usize - ptr as usize },
2618 5usize,
2619 concat!(
2620 "Offset of field: ",
2621 stringify!(JSCFunctionListEntry),
2622 "::",
2623 stringify!(def_type)
2624 )
2625 );
2626 assert_eq!(
2627 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2628 6usize,
2629 concat!(
2630 "Offset of field: ",
2631 stringify!(JSCFunctionListEntry),
2632 "::",
2633 stringify!(magic)
2634 )
2635 );
2636 assert_eq!(
2637 unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
2638 8usize,
2639 concat!(
2640 "Offset of field: ",
2641 stringify!(JSCFunctionListEntry),
2642 "::",
2643 stringify!(u)
2644 )
2645 );
2646}
2647extern "C" {
2648 pub fn JS_SetPropertyFunctionList(
2649 ctx: *mut JSContext,
2650 obj: JSValue,
2651 tab: *const JSCFunctionListEntry,
2652 len: ::std::os::raw::c_int,
2653 );
2654}
2655pub type JSModuleInitFunc = ::std::option::Option<
2656 unsafe extern "C" fn(ctx: *mut JSContext, m: *mut JSModuleDef) -> ::std::os::raw::c_int,
2657>;
2658extern "C" {
2659 pub fn JS_NewCModule(
2660 ctx: *mut JSContext,
2661 name_str: *const ::std::os::raw::c_char,
2662 func: JSModuleInitFunc,
2663 ) -> *mut JSModuleDef;
2664}
2665extern "C" {
2666 pub fn JS_AddModuleExport(
2667 ctx: *mut JSContext,
2668 m: *mut JSModuleDef,
2669 name_str: *const ::std::os::raw::c_char,
2670 ) -> ::std::os::raw::c_int;
2671}
2672extern "C" {
2673 pub fn JS_AddModuleExportList(
2674 ctx: *mut JSContext,
2675 m: *mut JSModuleDef,
2676 tab: *const JSCFunctionListEntry,
2677 len: ::std::os::raw::c_int,
2678 ) -> ::std::os::raw::c_int;
2679}
2680extern "C" {
2681 pub fn JS_SetModuleExport(
2682 ctx: *mut JSContext,
2683 m: *mut JSModuleDef,
2684 export_name: *const ::std::os::raw::c_char,
2685 val: JSValue,
2686 ) -> ::std::os::raw::c_int;
2687}
2688extern "C" {
2689 pub fn JS_SetModuleExportList(
2690 ctx: *mut JSContext,
2691 m: *mut JSModuleDef,
2692 tab: *const JSCFunctionListEntry,
2693 len: ::std::os::raw::c_int,
2694 ) -> ::std::os::raw::c_int;
2695}
2696extern "C" {
2697 pub fn JS_GetVersion() -> *const ::std::os::raw::c_char;
2698}
2699extern "C" {
2700 pub fn js_std_cmd(cmd: ::std::os::raw::c_int, ...) -> usize;
2701}
2702pub const __JS_ATOM_NULL: _bindgen_ty_4 = 0;
2703pub const JS_ATOM_null: _bindgen_ty_4 = 1;
2704pub const JS_ATOM_false: _bindgen_ty_4 = 2;
2705pub const JS_ATOM_true: _bindgen_ty_4 = 3;
2706pub const JS_ATOM_if: _bindgen_ty_4 = 4;
2707pub const JS_ATOM_else: _bindgen_ty_4 = 5;
2708pub const JS_ATOM_return: _bindgen_ty_4 = 6;
2709pub const JS_ATOM_var: _bindgen_ty_4 = 7;
2710pub const JS_ATOM_this: _bindgen_ty_4 = 8;
2711pub const JS_ATOM_delete: _bindgen_ty_4 = 9;
2712pub const JS_ATOM_void: _bindgen_ty_4 = 10;
2713pub const JS_ATOM_typeof: _bindgen_ty_4 = 11;
2714pub const JS_ATOM_new: _bindgen_ty_4 = 12;
2715pub const JS_ATOM_in: _bindgen_ty_4 = 13;
2716pub const JS_ATOM_instanceof: _bindgen_ty_4 = 14;
2717pub const JS_ATOM_do: _bindgen_ty_4 = 15;
2718pub const JS_ATOM_while: _bindgen_ty_4 = 16;
2719pub const JS_ATOM_for: _bindgen_ty_4 = 17;
2720pub const JS_ATOM_break: _bindgen_ty_4 = 18;
2721pub const JS_ATOM_continue: _bindgen_ty_4 = 19;
2722pub const JS_ATOM_switch: _bindgen_ty_4 = 20;
2723pub const JS_ATOM_case: _bindgen_ty_4 = 21;
2724pub const JS_ATOM_default: _bindgen_ty_4 = 22;
2725pub const JS_ATOM_throw: _bindgen_ty_4 = 23;
2726pub const JS_ATOM_try: _bindgen_ty_4 = 24;
2727pub const JS_ATOM_catch: _bindgen_ty_4 = 25;
2728pub const JS_ATOM_finally: _bindgen_ty_4 = 26;
2729pub const JS_ATOM_function: _bindgen_ty_4 = 27;
2730pub const JS_ATOM_debugger: _bindgen_ty_4 = 28;
2731pub const JS_ATOM_with: _bindgen_ty_4 = 29;
2732pub const JS_ATOM_class: _bindgen_ty_4 = 30;
2733pub const JS_ATOM_const: _bindgen_ty_4 = 31;
2734pub const JS_ATOM_enum: _bindgen_ty_4 = 32;
2735pub const JS_ATOM_export: _bindgen_ty_4 = 33;
2736pub const JS_ATOM_extends: _bindgen_ty_4 = 34;
2737pub const JS_ATOM_import: _bindgen_ty_4 = 35;
2738pub const JS_ATOM_super: _bindgen_ty_4 = 36;
2739pub const JS_ATOM_implements: _bindgen_ty_4 = 37;
2740pub const JS_ATOM_interface: _bindgen_ty_4 = 38;
2741pub const JS_ATOM_let: _bindgen_ty_4 = 39;
2742pub const JS_ATOM_package: _bindgen_ty_4 = 40;
2743pub const JS_ATOM_private: _bindgen_ty_4 = 41;
2744pub const JS_ATOM_protected: _bindgen_ty_4 = 42;
2745pub const JS_ATOM_public: _bindgen_ty_4 = 43;
2746pub const JS_ATOM_static: _bindgen_ty_4 = 44;
2747pub const JS_ATOM_yield: _bindgen_ty_4 = 45;
2748pub const JS_ATOM_await: _bindgen_ty_4 = 46;
2749pub const JS_ATOM_empty_string: _bindgen_ty_4 = 47;
2750pub const JS_ATOM_keys: _bindgen_ty_4 = 48;
2751pub const JS_ATOM_size: _bindgen_ty_4 = 49;
2752pub const JS_ATOM_length: _bindgen_ty_4 = 50;
2753pub const JS_ATOM_message: _bindgen_ty_4 = 51;
2754pub const JS_ATOM_cause: _bindgen_ty_4 = 52;
2755pub const JS_ATOM_errors: _bindgen_ty_4 = 53;
2756pub const JS_ATOM_stack: _bindgen_ty_4 = 54;
2757pub const JS_ATOM_name: _bindgen_ty_4 = 55;
2758pub const JS_ATOM_toString: _bindgen_ty_4 = 56;
2759pub const JS_ATOM_toLocaleString: _bindgen_ty_4 = 57;
2760pub const JS_ATOM_valueOf: _bindgen_ty_4 = 58;
2761pub const JS_ATOM_eval: _bindgen_ty_4 = 59;
2762pub const JS_ATOM_prototype: _bindgen_ty_4 = 60;
2763pub const JS_ATOM_constructor: _bindgen_ty_4 = 61;
2764pub const JS_ATOM_configurable: _bindgen_ty_4 = 62;
2765pub const JS_ATOM_writable: _bindgen_ty_4 = 63;
2766pub const JS_ATOM_enumerable: _bindgen_ty_4 = 64;
2767pub const JS_ATOM_value: _bindgen_ty_4 = 65;
2768pub const JS_ATOM_get: _bindgen_ty_4 = 66;
2769pub const JS_ATOM_set: _bindgen_ty_4 = 67;
2770pub const JS_ATOM_of: _bindgen_ty_4 = 68;
2771pub const JS_ATOM___proto__: _bindgen_ty_4 = 69;
2772pub const JS_ATOM_undefined: _bindgen_ty_4 = 70;
2773pub const JS_ATOM_number: _bindgen_ty_4 = 71;
2774pub const JS_ATOM_boolean: _bindgen_ty_4 = 72;
2775pub const JS_ATOM_string: _bindgen_ty_4 = 73;
2776pub const JS_ATOM_object: _bindgen_ty_4 = 74;
2777pub const JS_ATOM_symbol: _bindgen_ty_4 = 75;
2778pub const JS_ATOM_integer: _bindgen_ty_4 = 76;
2779pub const JS_ATOM_unknown: _bindgen_ty_4 = 77;
2780pub const JS_ATOM_arguments: _bindgen_ty_4 = 78;
2781pub const JS_ATOM_callee: _bindgen_ty_4 = 79;
2782pub const JS_ATOM_caller: _bindgen_ty_4 = 80;
2783pub const JS_ATOM__eval_: _bindgen_ty_4 = 81;
2784pub const JS_ATOM__ret_: _bindgen_ty_4 = 82;
2785pub const JS_ATOM__var_: _bindgen_ty_4 = 83;
2786pub const JS_ATOM__arg_var_: _bindgen_ty_4 = 84;
2787pub const JS_ATOM__with_: _bindgen_ty_4 = 85;
2788pub const JS_ATOM_lastIndex: _bindgen_ty_4 = 86;
2789pub const JS_ATOM_target: _bindgen_ty_4 = 87;
2790pub const JS_ATOM_index: _bindgen_ty_4 = 88;
2791pub const JS_ATOM_input: _bindgen_ty_4 = 89;
2792pub const JS_ATOM_defineProperties: _bindgen_ty_4 = 90;
2793pub const JS_ATOM_apply: _bindgen_ty_4 = 91;
2794pub const JS_ATOM_join: _bindgen_ty_4 = 92;
2795pub const JS_ATOM_concat: _bindgen_ty_4 = 93;
2796pub const JS_ATOM_split: _bindgen_ty_4 = 94;
2797pub const JS_ATOM_construct: _bindgen_ty_4 = 95;
2798pub const JS_ATOM_getPrototypeOf: _bindgen_ty_4 = 96;
2799pub const JS_ATOM_setPrototypeOf: _bindgen_ty_4 = 97;
2800pub const JS_ATOM_isExtensible: _bindgen_ty_4 = 98;
2801pub const JS_ATOM_preventExtensions: _bindgen_ty_4 = 99;
2802pub const JS_ATOM_has: _bindgen_ty_4 = 100;
2803pub const JS_ATOM_deleteProperty: _bindgen_ty_4 = 101;
2804pub const JS_ATOM_defineProperty: _bindgen_ty_4 = 102;
2805pub const JS_ATOM_getOwnPropertyDescriptor: _bindgen_ty_4 = 103;
2806pub const JS_ATOM_ownKeys: _bindgen_ty_4 = 104;
2807pub const JS_ATOM_add: _bindgen_ty_4 = 105;
2808pub const JS_ATOM_done: _bindgen_ty_4 = 106;
2809pub const JS_ATOM_next: _bindgen_ty_4 = 107;
2810pub const JS_ATOM_values: _bindgen_ty_4 = 108;
2811pub const JS_ATOM_source: _bindgen_ty_4 = 109;
2812pub const JS_ATOM_flags: _bindgen_ty_4 = 110;
2813pub const JS_ATOM_global: _bindgen_ty_4 = 111;
2814pub const JS_ATOM_unicode: _bindgen_ty_4 = 112;
2815pub const JS_ATOM_raw: _bindgen_ty_4 = 113;
2816pub const JS_ATOM_new_target: _bindgen_ty_4 = 114;
2817pub const JS_ATOM_this_active_func: _bindgen_ty_4 = 115;
2818pub const JS_ATOM_home_object: _bindgen_ty_4 = 116;
2819pub const JS_ATOM_computed_field: _bindgen_ty_4 = 117;
2820pub const JS_ATOM_static_computed_field: _bindgen_ty_4 = 118;
2821pub const JS_ATOM_class_fields_init: _bindgen_ty_4 = 119;
2822pub const JS_ATOM_brand: _bindgen_ty_4 = 120;
2823pub const JS_ATOM_hash_constructor: _bindgen_ty_4 = 121;
2824pub const JS_ATOM_as: _bindgen_ty_4 = 122;
2825pub const JS_ATOM_from: _bindgen_ty_4 = 123;
2826pub const JS_ATOM_meta: _bindgen_ty_4 = 124;
2827pub const JS_ATOM__default_: _bindgen_ty_4 = 125;
2828pub const JS_ATOM__star_: _bindgen_ty_4 = 126;
2829pub const JS_ATOM_Module: _bindgen_ty_4 = 127;
2830pub const JS_ATOM_then: _bindgen_ty_4 = 128;
2831pub const JS_ATOM_resolve: _bindgen_ty_4 = 129;
2832pub const JS_ATOM_reject: _bindgen_ty_4 = 130;
2833pub const JS_ATOM_promise: _bindgen_ty_4 = 131;
2834pub const JS_ATOM_proxy: _bindgen_ty_4 = 132;
2835pub const JS_ATOM_revoke: _bindgen_ty_4 = 133;
2836pub const JS_ATOM_async: _bindgen_ty_4 = 134;
2837pub const JS_ATOM_exec: _bindgen_ty_4 = 135;
2838pub const JS_ATOM_groups: _bindgen_ty_4 = 136;
2839pub const JS_ATOM_indices: _bindgen_ty_4 = 137;
2840pub const JS_ATOM_status: _bindgen_ty_4 = 138;
2841pub const JS_ATOM_reason: _bindgen_ty_4 = 139;
2842pub const JS_ATOM_globalThis: _bindgen_ty_4 = 140;
2843pub const JS_ATOM_bigint: _bindgen_ty_4 = 141;
2844pub const JS_ATOM_not_equal: _bindgen_ty_4 = 142;
2845pub const JS_ATOM_timed_out: _bindgen_ty_4 = 143;
2846pub const JS_ATOM_ok: _bindgen_ty_4 = 144;
2847pub const JS_ATOM_toJSON: _bindgen_ty_4 = 145;
2848pub const JS_ATOM_maxByteLength: _bindgen_ty_4 = 146;
2849pub const JS_ATOM_Object: _bindgen_ty_4 = 147;
2850pub const JS_ATOM_Array: _bindgen_ty_4 = 148;
2851pub const JS_ATOM_Error: _bindgen_ty_4 = 149;
2852pub const JS_ATOM_Number: _bindgen_ty_4 = 150;
2853pub const JS_ATOM_String: _bindgen_ty_4 = 151;
2854pub const JS_ATOM_Boolean: _bindgen_ty_4 = 152;
2855pub const JS_ATOM_Symbol: _bindgen_ty_4 = 153;
2856pub const JS_ATOM_Arguments: _bindgen_ty_4 = 154;
2857pub const JS_ATOM_Math: _bindgen_ty_4 = 155;
2858pub const JS_ATOM_JSON: _bindgen_ty_4 = 156;
2859pub const JS_ATOM_Date: _bindgen_ty_4 = 157;
2860pub const JS_ATOM_Function: _bindgen_ty_4 = 158;
2861pub const JS_ATOM_GeneratorFunction: _bindgen_ty_4 = 159;
2862pub const JS_ATOM_ForInIterator: _bindgen_ty_4 = 160;
2863pub const JS_ATOM_RegExp: _bindgen_ty_4 = 161;
2864pub const JS_ATOM_ArrayBuffer: _bindgen_ty_4 = 162;
2865pub const JS_ATOM_SharedArrayBuffer: _bindgen_ty_4 = 163;
2866pub const JS_ATOM_Uint8ClampedArray: _bindgen_ty_4 = 164;
2867pub const JS_ATOM_Int8Array: _bindgen_ty_4 = 165;
2868pub const JS_ATOM_Uint8Array: _bindgen_ty_4 = 166;
2869pub const JS_ATOM_Int16Array: _bindgen_ty_4 = 167;
2870pub const JS_ATOM_Uint16Array: _bindgen_ty_4 = 168;
2871pub const JS_ATOM_Int32Array: _bindgen_ty_4 = 169;
2872pub const JS_ATOM_Uint32Array: _bindgen_ty_4 = 170;
2873pub const JS_ATOM_BigInt64Array: _bindgen_ty_4 = 171;
2874pub const JS_ATOM_BigUint64Array: _bindgen_ty_4 = 172;
2875pub const JS_ATOM_Float16Array: _bindgen_ty_4 = 173;
2876pub const JS_ATOM_Float32Array: _bindgen_ty_4 = 174;
2877pub const JS_ATOM_Float64Array: _bindgen_ty_4 = 175;
2878pub const JS_ATOM_DataView: _bindgen_ty_4 = 176;
2879pub const JS_ATOM_BigInt: _bindgen_ty_4 = 177;
2880pub const JS_ATOM_WeakRef: _bindgen_ty_4 = 178;
2881pub const JS_ATOM_FinalizationRegistry: _bindgen_ty_4 = 179;
2882pub const JS_ATOM_Map: _bindgen_ty_4 = 180;
2883pub const JS_ATOM_Set: _bindgen_ty_4 = 181;
2884pub const JS_ATOM_WeakMap: _bindgen_ty_4 = 182;
2885pub const JS_ATOM_WeakSet: _bindgen_ty_4 = 183;
2886pub const JS_ATOM_Iterator: _bindgen_ty_4 = 184;
2887pub const JS_ATOM_IteratorHelper: _bindgen_ty_4 = 185;
2888pub const JS_ATOM_IteratorWrap: _bindgen_ty_4 = 186;
2889pub const JS_ATOM_Map_Iterator: _bindgen_ty_4 = 187;
2890pub const JS_ATOM_Set_Iterator: _bindgen_ty_4 = 188;
2891pub const JS_ATOM_Array_Iterator: _bindgen_ty_4 = 189;
2892pub const JS_ATOM_String_Iterator: _bindgen_ty_4 = 190;
2893pub const JS_ATOM_RegExp_String_Iterator: _bindgen_ty_4 = 191;
2894pub const JS_ATOM_Generator: _bindgen_ty_4 = 192;
2895pub const JS_ATOM_Proxy: _bindgen_ty_4 = 193;
2896pub const JS_ATOM_Promise: _bindgen_ty_4 = 194;
2897pub const JS_ATOM_PromiseResolveFunction: _bindgen_ty_4 = 195;
2898pub const JS_ATOM_PromiseRejectFunction: _bindgen_ty_4 = 196;
2899pub const JS_ATOM_AsyncFunction: _bindgen_ty_4 = 197;
2900pub const JS_ATOM_AsyncFunctionResolve: _bindgen_ty_4 = 198;
2901pub const JS_ATOM_AsyncFunctionReject: _bindgen_ty_4 = 199;
2902pub const JS_ATOM_AsyncGeneratorFunction: _bindgen_ty_4 = 200;
2903pub const JS_ATOM_AsyncGenerator: _bindgen_ty_4 = 201;
2904pub const JS_ATOM_EvalError: _bindgen_ty_4 = 202;
2905pub const JS_ATOM_RangeError: _bindgen_ty_4 = 203;
2906pub const JS_ATOM_ReferenceError: _bindgen_ty_4 = 204;
2907pub const JS_ATOM_SyntaxError: _bindgen_ty_4 = 205;
2908pub const JS_ATOM_TypeError: _bindgen_ty_4 = 206;
2909pub const JS_ATOM_URIError: _bindgen_ty_4 = 207;
2910pub const JS_ATOM_InternalError: _bindgen_ty_4 = 208;
2911pub const JS_ATOM_CallSite: _bindgen_ty_4 = 209;
2912pub const JS_ATOM_Private_brand: _bindgen_ty_4 = 210;
2913pub const JS_ATOM_Symbol_toPrimitive: _bindgen_ty_4 = 211;
2914pub const JS_ATOM_Symbol_iterator: _bindgen_ty_4 = 212;
2915pub const JS_ATOM_Symbol_match: _bindgen_ty_4 = 213;
2916pub const JS_ATOM_Symbol_matchAll: _bindgen_ty_4 = 214;
2917pub const JS_ATOM_Symbol_replace: _bindgen_ty_4 = 215;
2918pub const JS_ATOM_Symbol_search: _bindgen_ty_4 = 216;
2919pub const JS_ATOM_Symbol_split: _bindgen_ty_4 = 217;
2920pub const JS_ATOM_Symbol_toStringTag: _bindgen_ty_4 = 218;
2921pub const JS_ATOM_Symbol_isConcatSpreadable: _bindgen_ty_4 = 219;
2922pub const JS_ATOM_Symbol_hasInstance: _bindgen_ty_4 = 220;
2923pub const JS_ATOM_Symbol_species: _bindgen_ty_4 = 221;
2924pub const JS_ATOM_Symbol_unscopables: _bindgen_ty_4 = 222;
2925pub const JS_ATOM_Symbol_asyncIterator: _bindgen_ty_4 = 223;
2926pub const JS_ATOM_END: _bindgen_ty_4 = 224;
2927pub type _bindgen_ty_4 = ::std::os::raw::c_uint;