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

inlined fast path for get_field, get_field2 and put_field

- optimized global variable access

- removed full compliance with the spec for strict mode variable
  assignment so that they are as fast as in non strict mode (V8,
  SpiderMonkey and JavascriptCore do the same, so IMHO the spec should
  be updated).

optimize the create of arrays - optimized the rest and array_from opcodes

Improve error handling in Promise.withResolvers (bnoordhuis)

updated test262

Merge pull request #408 from nickva/run-test262-in-ci

Run test262 tests in CI

Run test262 tests in CI

Run test262 tests for Linux, macOS and Cosmopolitan

Add a Makefile `test2-bootstrap` helper to clone and patch test262 tests at
a particular commit. Running with the latest commit noticed a few tests were
failing and added them to the errors list.

The CI environment, especially for macOS, was a bit more unpredictable and was
failing in atomics tests due to lower timeouts in the `atomicsHelper` so double
the timeouts. The time didn't worsen too much. It still takes about 2-3 min.

simplified math.sumPrecise()

fixed Date parsing: "1997-03-08 11:19:10-0700" is a valid date and "1997-03-08T11:19:10-07" should yield an error

fixed Atomics.pause() in the NaN boxing case (32 bit cpu)

added Math.sumPrecise()

added Map and WeakMap upsert methods (bnoordhuis)

- added Atomics.pause (bnoordhuis)
- use the pause instruction for x86 and ARM64 in Atomics.pause()

- added resizable array buffers (bnoordhuis)
- fixed Atomics.wait, Atomics.notify, TypedArray.prototype.lastIndexOf
- fixed JS_PreventExtensions() with resizable typed arrays

fixed parsing of computed property name

- added ArrayBuffer.prototype.transfer (Divy Srivastava)
- fixed transfer when the ArrayBuffer was allocated with a custom allocator

Iterator functions:

- removed memory leak
- don't close iterator when IteratorStepValue fails
- fixed  Iterator Wrap next() and return() arguments
- fixed Iterator.from()

Iterator is an abstract class (bnoordhuis)

fix Iterator.prototype.constructor (initial patch by bnoordhuis)

added Iterator.prototype.[drop,filter,flatMap,map,take,every,find,forEach,some,reduce,[Symbol.toStringTag]] (saghul)