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