removed memory leak

CI: disable CONFIG_TEMPORAL_INTL on linux/arm/v6 and linux/arm/v7

fixed bad rounding in duration computation

fixed bad rounding in duration computation

disable Temporal and Intl on 32 bit hosts because int128 is not always supported in this case - avoid depending on float128 for duration division - simplified some int128 code

removed some warnings - fixed win32 compilation

undo Makefile change

added missing file

added experimental AI coded Temporal and Intl support. There is no external dependency. Intl includes its own locale data (can be manually updated from the CLDR) and Temporal includes the calendar algorithms and a timezone database (can be manually updated from the system TZif files)

exported JS_NewCConstructor()

exported iterator helpers

added JS_CFUNC_constructor_or_func_flags

export JS_OrdinaryIsInstanceOf()

export JS_ThisDateValue()

exported JS_CreateFromConstructor()

added JS_ToCStringNZ() and exported JS_ToUTF32String()

exported JS_ToPrimitive(), JS_ToObject() and JS_ToInt32Sat()

libunicode: added lre_is_soft_dotted() and exported unicode_get_cc()

removed unused arguments of JS_IteratorNext()

fixed class elements parsing after a line terminator following get, set or static (#567)

repect the spec operation order in Object.defineProperties

fix Proxy getOwnPropertyDescriptor invariant check for values and accessors

exclude more tests we don't need to fix

fixed Function.prototype.bind prototype inheritance

fix anonymous function name inference in for-in loop initializers

fix super property assignment on non-extensible receiver with existing property

fixed module ambiguous export test

spec update for Promise.try

exclude the test: test262/test/language/identifier-resolution/assign-to-global-undefined.js

Annex B: allow call expression as assignment target in non-strict mode, but throw ReferenceError at runtime.

simplified and fixed yield/await identifier parsing

fixed returned value of empty catch blocks

fixed TypedArray.prototype.at

fixed 'return' invocation in Iterator helpers - fixed 'next' method get in Iterator.prototype.flatMap (#539)

added clarification for the JS_PrintValue callback (#558)

fixed ArrayBuffer.prototype.resize

added JS_ToBigInt128(), JS_ToBigInt128Sat() and JS_NewBigInt128()

fixed potential bug in 32 bit JS_ToBigInt64() (cannot happen with canonicalized bigints)

run-test2: don't increment the test number for strict mode - fixed print_error() for large error messages - don't return an exit code different from 0 if there are errors when updating the error file - added -q option to disable progress output and also disable it when not outputting to a tty

added JS_ToInt64SatF() and fixed String.prototype.repeat with it. Modify Iterator.prototype.drop/take to use it even if it is not strictly compliant as it avoids converting to double when the argument is a short integer value

fixed memory leak in Atomics.store (#537)

 Reject out-of-range limits in Iterator.prototype.take/drop

fixed BigInt.AsUintN() and added corresponding regression tests from quickjs-ng

fixed regexp unicode set parsing (#520)

added JS_NewSymbol()

test262 update

run-test262: when updating errors, sort them so that it gives the same result with several threads

optimized Array.prototype.slice and Array.prototype.splice

fixed typo in commit 445624b

inlined the float case in relational operators

use JSValueConst arguments for js_strict_eq2()

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