inlined more cases for equality operators

new release

Check return values of fallible functions (#518)

Port of https://github.com/quickjs-ng/quickjs/pull/1409 (bnoordhuis).
I modified it to prevent an atom leak in js_parse_statement_or_decl,
otherwise it's the same.

Add fuzz targets for ES6 modules, JSON, RegExp, and bytecode (#512)

* Add fuzz targets for ES6 modules, JSON, RegExp, and bytecode

Adds 4 new fuzzers targeting high-complexity, low-coverage functions:

- fuzz_module_export: Tests ES6 module export/import parsing (complexity 6727)

- fuzz_json: Tests JSON stringify/parse (complexity ~5000)

- fuzz_regexp_compile: Tests RegExp compilation (complexity 5528)

- fuzz_bytecode: Tests bytecode execution (complexity 5383)

Identified by Fuzz Introspector as having 0% runtime coverage.

Build integration for fuzz/Makefile and build.sh included.

* Convert fuzz targets from C++ to C and use standard C headers

doc update

keep more generic cpu_count() for non Linux systems

fixed microbench with d8

faster add, sub and mul for mixed integer floating point operands

exclude few very slow and currently useless test262 tests

fixed large performance regression with recent GCC versions

add optional define to add asm labels for each opcode to ease code inspection and profiling

added multi-threading support in run-test262 (initial patch by bnoordhuis) - fixed unsafe thread termination in show_progress() - use the number of physical cores by default - added -T option to force the number of threads - avoid hardcoding the maximum number of threads

removed CONFIG_AGENT

fixed win32 compilation

ArrayBuffer.prototype.transfer: avoid destroying the old array buffer in case the allocation of the new array buffer fails. Also avoid setting opaque = NULL for the custom array buffer free function

add line number info in variable initialization (#458)

use the host malloc() for all allocations when ASAN is enabled

fixed setuid() / setgid() ordering (#517)

disable inlining of malloc() wrappers to avoid problems with LTO (#515)

added poll() support so that the number of file handles is not limited (#502)

Add run-test262 --no-can-block flag (#505)

The flag is needed to pass the two CanBlockIsFalse tests from test262
when running individual preprocessed tests via run-test262 -N.

fixed compilation with clang

added custom malloc for small blocks (11% faster on bench-v8)

Add Uint8Array base64/hex methods (initial patch by saghul)

memcpy() (currently) has undefined behavior if a pointer is NULL with zero size (#500)

fixed error handling in os.exec() (#503)

added missing NULL pointer check (#504)

use __EMSCRIPTEN__ define instead of EMSCRIPTEN

fixed (again) JS atomics in case of typed array resizing - use same function name as quickjs-ng for js_atomics_get_buf() (#508)

added libunicode unicode version (#509)

Merge pull request #496 from bptato/fix-hex-access

Fix member access on non-decimal numeric literals

Merge pull request #495 from nickva/fix-initializer-string-warning

Avoid initializer-string warning for the digits array

Fix member access on non-decimal numeric literals

In other engines, 0x0.toString() returns '0', but QJS would try to parse it
as a float and then throw.
Also removes remnants of hex float parsing which is no longer supported
anyway.

(Port of https://github.com/quickjs-ng/quickjs/pull/377)

Avoid initializer-string warning for the digits array

Some newer compilers emit this warning:

```
warning: initializer-string for character array is too long, array size is 36
     but initializer has size 37 (including the null terminating character);
     did you mean to use the 'nonstring' attribute? [-Wunterminated-string-initialization]
 12146 | static char const digits[36] = "0123456789abcdefghijklmnopqrstuvwxyz";
       |                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```

To avoid the warning initialize the array as individual characters

added JSON.parse source text access

added basic protection against too large function in serialized bytecode

fixed use-after-free via re-entrant GC in FinalizationRegistry weak reference cleanup (#494)

Fix async generator lifecycle bug (bnoordhuis) (quickjs-ng/quickjs#1355)

fixed RegExp.escape

fixed buffer overflow in Atomics with resizable typed arrays

typo

Fix memory leak in Iterator.prototype.map (saghul) (#493)

fixed buffer overflow in TypedArray.prototype.with (#492)

Fix stack underflow with generator in iterable (saghul) (#488)

test262 update

fixed TypedArray constructor semantics which removes a buffer overflow (#478)

fixed TypedArray sort semantics by copying the array before calling the comparison function. Fixed buffer overflow when the array is resized (#477)

modified js_allocate_fast_array() so that the array is fully initialized. It is slightly slower but avoids several nasty bugs (#471)

regexp: removed alloca() is lre_exec() - added specific opcodes for \s and \S to have a smaller bytecode - optimized \b and \B

\x{N} is a syntax error

slightly faster lexical variable assignment

Don't call well-known Symbol methods for RegExp on primitive values

removed use after free in js_create_module_bytecode_function() (#467)

removed memory leak in case of error in cpool_add() (#468)

fixed fast array extension optimization when there are multiple realms

added regexp duplicate named groups - fixed reset of captures with quantizers

updated to unicode 17.0.0 - updated test262 version

added missing lre_poll_timeout()

regexp: cosmetic: make it clearer that there is now a set of registers instead of an auxiliary stack

regexp: ensure that the bytecode size grows linearly with respect to
the input regexp.

This way, pathological regexps such as
/(:?(:?(:?(:?(:?(:?(:?(:?(:?(:?(:?(:?(:?(?:a|)+|)+|)+|)+|)+|)+|)+|)+|)+|)+|)+|)+|)+|)+/ are no longer an issue. The generated bytecode is also simpler and
faster.

removed buffer overflows introduced in regexp optimizations

fixed Worker freeing logic (#462)

- optimized Regexp.prototype.exec
- optimized String.prototype.replace
- optimized 'arguments' object creation
- optimized access to non strict 'arguments' elements

faster and simpler implementation of regexp backtracking

fixed BJSON array serialization (#457)

- Added Iterator.concat (initial patch by bnoordhuis)
- optimized js_iterator_concat_next()
- added more guards against recursion in Iterator.concat operations

optimized add/sub int32 overflow

added error checking in JS_InstantiateFunctionListItem()

- Closure optimization (go from quadratic to linear time when the number
of closure variables is large)
- Separated JSVarDef and JSBytecodeVarDef to simplify the code and save memory
- fixed debug info stripping with global variables

Restore a mistakenly removed goto on error in js_build_module_ns() (igorburago)

fixed JS_PROP_AUTOINIT handling in js_closure_define_global_var() (#455)

fixed exception handling in put_var operation (regression introduced by commit a6816be) (#454)

More informative "not a constructor" error message (initial patch by bnoordhuis) (#368)

Fix length check in ArrayBuffer.prototype.slice (bnoordhuis) (#451)

fixed DataView resizing

Fix use-after-free in ArrayBuffer.prototype.transfer (bnoordhuis) (#450) - use js_array_buffer_update_typed_arrays() in JS_DetachArrayBuffer()

qjs: added --strict option - don't consider included files as modules - allow module and strict code with -e option

removed duplicate test

Much faster destructuring at the expense of a slight incompatibility
with the spec when direct evals are present (v8 behaves the same way).

optimized global variable access

removed uninitialized variable

updated test results

fixed operation order in Regexp constructor

changed module rejection order according to spec change

optimized Array.prototype.push

inlined the get_length operation

added js_string_eq()

stricter year parsing in Date

fixed argument evaluation order in Date constructor and Date.UTC()

faster and safer dbuf functions (#443)

test262 update

fixed regression in error message display introduced in commit 42eb279

compilation fix for clang

Faster context creation and exception checks in JS_NewContext (#404)

- simplified internal object init
- check exceptions in JS_NewContext()
- preallocated std object properties
- preallocated more atoms

update

faster appending of elements in arrays

optimized string_buffer_putc()

optimized post_inc and post_dec

optimized array access by inlining get_array_el, get_array_el2, get_array_el3 and put_array_el

removed JS_PROP_NO_ADD