avoid freeing an object structure in js_weakref_free() if it is about to be freed in free_zero_refcount()

reworked weak references so that cycles are (hopefully) correctly handled - added Symbol as WeakMap key, WeakRef and FinalizationRegistry

fixed eval with empty argument scope (#249)

removed useless printf() (#257)

ensure that JS_IteratorNext() returns JS_UNDEFINED when done = TRUE (#394)

removed invalid tests

fixed exception handling in AsyncFromSyncIterator and async for of

fixed typed array set operation when obj != receiver

fixed set_date_field()

disable rejection tracker in the repl - repl cleanup

removed memory leak in string padding (issue #274)

exit by default on unhandled promise rejections (issue #305)

update test262_errors.txt

updated to unicode 16.0.0 (bnoordhuis) - updated test262

added missing header

added -Wno-infinite-recursion

more use of js_new_string8 - inlined JS_NewString() (initial patch by Charlie Gordon)

added string ropes for faster concatenation of long strings (issue #67)

more dtoa bench (Charlie Gordon)

enable dtoa tests on win32

reduced memory usage of Map hash table

fixed hash_map_resize() - added Map/WeakMap in microbench

simplified and fixed backtrace_barrier (#306)

protect against printf errors (#319)

added new dtoa library to print and parse float64 numbers. It is necessary to fix corner cases (e.g. radix != 10) and to have correct behavior regardless of the libc implementation.

msan fix (#389)

simplified js_bigint_from_float64()

fixed examples/hello_module compilation (#240)

fixed BigInt hashing - removed -fno-bigint in qjsc and JS_AddIntrinsicBigInt() (BigInt is now considered as a base object)

fixed JS_DumpValue() for BigInt

more bignum cleanup

removed the ability to do simultaneous 64 and 32 bit x86 builds in order to simplify the Makefile

Merge pull request #391 from nickva/try-to-fix-multiplatform-builds

Fix multiarch CI builds

Fix multiarch CI builds

Fix: https://github.com/bellard/quickjs/issues/390

compilation fix

added missing variable

removed bignum support and qjscalc - added optimized BigInt implementation

regexp: allow [\-] in unicode mode (#373)

fixed CONFIG_ALL_UNICODE compilation

simplified the handling of closures

added missing stack overflow check in JSON.stringify()

allow regexp interruption (e.g. with Ctrl-C in the REPL)

fix crash when add_property()  fails on build arguments (penneryu)

microbench: use toFixed()

JS_SetPropertyInternal(): avoid recursing thru the prototypes if the property is found in a prototype

fixed date parsing in case there is more than nine initial digits (initial patch by nickva)

Fix termination in Worker test

Function names are case sensitive, `onMessage` is not the same as
`onmessage`.

Related to #98

Define a fallback PATH_MAX if not available

PATH_MAX is optional in POSIX, and it is not available on GNU/Hurd.
While it could be possible to not rely on PATH_MAX, for now provide a
fallback definition (which should be safe enough) to get quickjs built
on GNU/Hurd.

Use ftello() & fseeko() on any OS based on GNU libc

Strictly speaking, they are available in POSIX.1-2008 [1][2], so they
could be used on more platforms/OSes. To be cautious, enable them when
using GNU libc, since they have been available with that libc for a
very long time.

[1] https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftell.html
[2] https://pubs.opengroup.org/onlinepubs/9699919799/functions/fseek.html

Use malloc_usable_size() on any OS based on GNU libc

malloc_usable_size() is a GNU extension in GNU libc; hence, use it
every time GNU libc is used, rather than only on Linux.

Fix `JS_HasException()` when `null` is thrown (#313)

Use `JS_UNINITIALIZED` instead of `JS_NULL` when no exception is pending, so `null` can be thrown and distinguished from no exception pending.

Fix GC leak in `js_proxy_get()` (#302)

Fixes #277

regexp: fix non greedy quantizers with zero length matches

updated test262.patch

fixed test of test262 directory

Improve `js_os_exec` (#295)

- use $(shell) make command to test if closefrom() is available
- use closefrom() if available in js_os_exec()
- limit the fallback loop to 1024 handles to avoid costly loop on linux alpine.
PR inspired by @nicolas-duteil-nova

Add `js_resolve_proxy` (#293)

- simplify `JS_IsArray` for proxy chains
- remove `js_proxy_isArray`

Add `JS_StrictEq()`, `JS_SameValue()`, and `JS_SameValueZero()` (#264)

* add `JS_StrictEq()`, `JS_SameValue()`, and `JS_SameValueZero()` all accepting `JSValueConst`
* make `js_strict_eq` accept `JSValueConst`, remove uses of this function internally and replace them with
`js_strict_eq2` instead.

Expose `JS_SetUncatchableError()` (#262)

* Expose `JS_SetUncatchableError()`

* Remove unnecessary `JS_SetUncatchableError` declaration

Add the missing fuzz_common.c (#292)

Add `JS_HasException()` (#265)

Add `JS_NewTypedArray()` (#272)

OSS-Fuzz targets improvements (#267)

* Move fuzz target sources from the oss-fuzz repository here

* Add support to build libFuzzer targets
* Simplify the fuzz_eval and fuzz_compile targets

The use of JS_NewContext instead of JS_NewContextRaw spares to call
JS_AddIntrinsic<XYZ> functions from the fuzz target, since the public
JS_NewContext API does exactly the same.

* Simplify the fuzz_regexp target

fuzz_regexp doesn't need to be dependant on libquickjs since the
runtime and the context - that were provided by libquickjs - were
only created to call two simple functions implemented in libquickjs
which could be mimicked by the fuzzer.
The removal of runtime and context objects implicated further
simplifications, like the omission of their one-time creation.
Finally, writing the result of the regexp operations into a file
is also superfluous, since it's not used by anybody.

* Recreate and destroy JS runtime and context in fuzz_eval and fuzz_compile targets

Before this patch, the test executions were not independent,
since all the executed tests used the same JavaScript runtime and
context, causing irreproducible failure reports.

* Enable bignumber support in eval and compile targets

Big numbers are used by the input corpus, but the targets were not
able to interpret them since they were not compiled into them.
This change improved the inital coverage of the fuzz_eval target with
21% and the coverage of the fuzz_compile target with 25% when using
the official corpus.

* Ensure std and os modules are available in the fuzz_eval and fuzz_compile targets
* Add fuzzer dictionary with builtin and variable names. Furthermore, added a JS script that collects all the builtin
names from the executing engine.
* Move common fuzzer code into one place
* Enable to define the LIB_FUZZING_ENGINE variable to ease the oss-fuzz integration
* Add README to fuzzers

Improve class parser (#289)

- accept `class P { async = 1 }}`
- accept `class P { static = 1 }}` etc.
- Fixes #261

fix class method with name get (#258)

Co-authored-by: Richard Davison <ridaviso@amazon.com>

Improve libunicode and libregexp headers (#288)

- move all `lre_xxx` functions to libunicode
- use flags table `lre_ctype_bits` instead of bitmaps
- simplify `lre_is_space`, `lre_js_is_ident_first` and `lre_js_is_ident_next`
- simplify `simple_next_token`, handle UTF-8 correctly
- simplify `is_let`, remove dead code

Improve unicode table handling (#286)

- Document table and index formats
- Add size statistics
- Fix UBSAN issue in `get_le24()`

Fixes #285

Fix endianness handling in `js_dataview_getValue` / `js_dataview_setValue`

Improve error handling

- detect and report invalid duplicate parameter names
- throw RangeError for too many function arguments
- throw RangeError for invalid string length
- prevent `-Wcast-function-type` warnings

Improve `JSON.stringify`

- changed error messages
- clarify `toJSON` method usage
- simplify boxed objects handling
- for ECMA conformity, BigInt objects need a toJSON method in the prototype chain
  including boxed objects

Use more explicit magic values for array methods

Simplify redundant initializers for `JS_NewBool()`

Fix compilation with -DCONFIG_BIGNUM

- disable BigDecimal convertion in `JS_ReadBigNum`
- fix some error messages

Improve Date.parse, small fixes

- add `minimum_length` to enforce array length validation
- add `JS_NewDate()` API
- add `[Symbol.toStringTag]` property in the global object
- simplify `string_get_milliseconds`
- support more timezone abbrevs using `string_get_tzabbr` and array

Add CI targets, fix test_std.js (#247)

This switches the exec test to `SIGTERM` rather than `SIGQUIT` since the
latter didn’t seem to work in QEMU, and the distinction doesn’t really
matter for this test.

This also makes the `isatty()` check smarter by checking whether `STDIN`
is, in fact, a terminal.

Added qemu-alpine targets i386, arm32v6, arm32v7, arm64v8, s390x

Co-authored-by: Felipe Gasper <felipe@felipegasper.com>

Fix build: use LRE_BOOL in libunicode.h (#244)

prevent 0 length allocation in `js_worker_postMessage`

Add github CI tests

- disable `isatty()` test in `test_os()`
- add `.github/workflows/ci.yml` with 8 targets

Prevent UB on memcpy and floating point conversions

- add `memcpy_no_ub` that accepts null pointers for 0 count
- prevent 0 length allocation in `js_worker_postMessage`
- use safer test for `int` value in `JS_NewFloat64`,
  `JS_ToArrayLengthFree` and `js_typed_array_indexOf`

fix microbench when microbench.txt is missing (#246)

Improve Date.parse

- accept many more alternative date/time formats
- add test cases in tests/test_builtin.js
- match month and timezone names case insensitively
- accept AM and PM markers
- recognize US timezone names
- skip parenthesized stuff
- fix almost all v8 test cases

Improve Number.prototype.toString for radix other than 10

- fix the conversions for integers and exact fractions
- approximate approach for other cases.
- bypass floating point conversions for JS_TAG_INT values
- avoid divisions for base 10 integer conversions

Improve repl regexp handling

- handle regexp with flags in repl completion
- group config_jscalc customisations

Improve microbench.js

- ensure handler behavior does not depend on n argument
- load and save reference file in node.js
- add -s filename option to name the output reference file
- add targets in Makefile for tests and bencharks using node.js
- fix incorrect timings when not using high resolution timer
- use performance timer in node.js
- output performance factor instead of percentage
- use smaller threshold by default
- add benchmarks for:
    date_parse(), prop_update(), prop_clone(), array_slice()
    global_func_call(),

Improve Date.parse

- rewrite Date.parse() with separate parsers
- return `NaN` for out of bounds field values as specified
- accept up to 9 decimals for millisecond fraction but truncate at 3
- accept many more alternative date/time formats
- add test cases in tests/test_builtin.js

show readable representation of Date objects in repl

Fix Map hash bug

- `map_hash_key` must generate the same key for JS_INT and JS_FLOAT64
   with the same value
- add test cases in tests/test_builtin.js

Rewrite `set_date_fields` to match the ECMA specification

- use `double` arithmetic where necessary to match the spec
- use `volatile` to ensure correct order of evaluation
  and prevent FMA code generation
- reject some border cases.
- avoid undefined behavior in `double` -> `int64_t` conversions
- improved tests/test_builtin.js `assert` function to compare
  values more reliably.
- added some tests in `test_date()`
- disable some of these tests on win32 and cygwin targets

Add C API function JS_GetClassID()

If you want to extend a built-in class you need it's class ID and there
is no robust way to get that without this accessor.

* add JS_INVALID_CLASS_ID constant for invalid class ID.

Signed-off-by: Tyler Rockwood <rockwood@redpanda.com>

Improve surrogate handling readability

- add inline function to test and convert surrogates
  is_surrogate(c), is_hi_surrogate(c), is_lo_surrogate(c),
  get_hi_surrogate(c), get_lo_surrogate(c), from_surrogate(hi, lo)
- use names for BC header offsets and lengths in libregexp.c
- remove strict aliasing violations in `lre_exec_backtrack()`
- pass all context variables to XXX_CHAR macros in `lre_exec_backtrack()`

Rename regex flag and field utf16 -> unicode

- rename is_utf16 structure member to is_unicode
- rename flag LRE_FLAG_UTF16 as LRE_FLAG_UNICODE

Add benchmarks target

- assuming quickjs-benchmarks is cloned in the parent directory,
- compile quickjs-benchmarks targets and run the benchmarks

Improve run-test262

- add -t to show timings
- add -C to select compact progress meter
- default to compact progress meter if not attached to console
- set agent stack size to 2MB
- compute module filename relative to current path
- ignore `testdir` for -d and -f options
- return non zero status on errors changes

Fix big endian serialization

Big endian serialization was broken because:
- it partially relied on `WORDS_ENDIAN` (unconditionally undef'd in cutils.h)
- endianness was not handled at all in the bc reader.

Modifications:
- remove `WORDS_ENDIAN`
- use `bc_put_u32()` / `bc_put_u64()` in `JS_WriteBigInt()`
- use `bc_get_u32()` / `bc_get_u64()` in `JS_ReadBigInt()`
- handle host endianness in `bc_get_u16()`, `bc_get_u32()`, `bc_get_u64()` and
  `JS_ReadFunctionBytecode()`

- handle optional littleEndian argument as specified in
  `js_dataview_getValue()` and `js_dataview_setValue()`

handle missing test262 gracefully

handle missing test262 gracefully

Improve tests

- split test_bigfloat.js from test_bignum.js
- make test_date() compatible with node
- document Date constructor string argument format:
  should add test cases for invalid strings
- test_argument_scope(): only test this syntax error in strict mode:
  `var f = function(a = eval("var arguments")) {};`

Fix UB signed integer overflow in js_math_imul

- Use uint32_t arithmetics and Standard conformant conversion to
  avoid UB in js_math_imul.
- add builtin tests
- use specific object directories for SAN targets

Fix UB left shift of negative number

Remove unnecessary ssize_t posix-ism

ssize_t is not always available and the cast it was used in wasn't
necessary in the first place, the value already has the right type.

Note that the field malloc_limit is an int64_t in JSMemoryUsage whereas it
is a size_t in JSMallocState.