From cd84c3f68ae292cb3e6f93b68f5a8ea4fcca90b7 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 14 Jul 2019 19:03:15 +0000
Subject: [PATCH 001/185] more types

---
 main.cpp      |   7 +++-
 quickjspp.hpp | 109 ++++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 110 insertions(+), 6 deletions(-)

diff --git a/main.cpp b/main.cpp
index ec2c8f53b8..00e972da85 100644
--- a/main.cpp
+++ b/main.cpp
@@ -18,8 +18,6 @@ class test
 {
     int x;
 public:
-    inline static JSClassID QJSClassId;
-
 
     test(int32_t x) : x{x}
     { printf("ctor %d!\n", x); }
@@ -62,6 +60,11 @@ int main(int argc, char ** argv)
     obj["g"] = detail::fwrapper<&test::g>{"g"};
     obj["fun2"] = detail::fwrapper<&f2>{"f2"};
     obj["f"] = detail::fwrapper<&test::f>{"f"};
+    obj[3u] = detail::js_string{"43!"};
+
+    int testint = obj[3u];
+    std::string teststr = obj[3u];
+    std::cout << testint<< teststr;
 
 
     context.registerClass<test>("test_class", std::move(obj));
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 37bdf28e2c..c8569f5c19 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -56,7 +56,92 @@ namespace qjs {
             }
         };
 
-/*
+        template <>
+        struct js_traits<bool>
+        {
+            static bool unwrap(JSContext * ctx, JSValue v) noexcept
+            {
+                return JS_ToBool(ctx, v);
+            }
+
+            static JSValue wrap(JSContext * ctx, bool i) noexcept
+            {
+                return JS_NewBool(ctx, i);
+            }
+        };
+
+        template <>
+        struct js_traits<double>
+        {
+            static double unwrap(JSContext * ctx, JSValue v)
+            {
+                double r;
+                if(JS_ToFloat64(ctx, &r, v))
+                    throw exception{};
+                return r;
+            }
+
+            static JSValue wrap(JSContext * ctx, double i) noexcept
+            {
+                return JS_NewFloat64(ctx, i);
+            }
+        };
+
+        class js_string : public std::string_view
+        {
+            using Base = std::string_view;
+            JSContext * ctx = nullptr;
+
+            friend struct js_traits<js_string>;
+            js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx) {}
+        public:
+
+            template <typename... Args>
+            js_string(Args&&... args) : Base(std::forward<Args>(args)...), ctx(nullptr) {}
+
+            js_string(const js_string& other) = delete;
+
+            ~js_string()
+            {
+                if(ctx)
+                    JS_FreeCString(ctx, this->data());
+            }
+        };
+
+        template <>
+        struct js_traits<js_string>
+        {
+            static js_string unwrap(JSContext * ctx, JSValue v)
+            {
+                int plen;
+                const char * ptr = JS_ToCStringLen(ctx, &plen, v, 0);
+                if(!ptr)
+                    throw exception{};
+                return js_string{ctx, ptr, (std::size_t)plen};
+            }
+
+            static JSValue wrap(JSContext * ctx, js_string str) noexcept
+            {
+                return JS_NewStringLen(ctx, str.data(), (int)str.size());
+            }
+        };
+
+        template <> // slower
+        struct js_traits<std::string>
+        {
+            static std::string unwrap(JSContext * ctx, JSValue v)
+            {
+                auto str_view = js_traits<js_string>::unwrap(ctx, v);
+                return std::string{str_view.data(), str_view.size()};
+            }
+
+            static JSValue wrap(JSContext * ctx, const std::string& str) noexcept
+            {
+                return JS_NewStringLen(ctx, str.data(), (int) str.size());
+            }
+        };
+
+            /*
         template <typename Arg1, typename... Args>
         std::tuple<Arg1, Args...> to_tuple_impl(JSContext * ctx, JSValue * argv)
         {
@@ -255,7 +340,22 @@ namespace qjs {
             {
                 return JS_GetPropertyStr(ctx, this_obj, name);
             }
+        };
 
+        template <>
+        struct js_property_traits<uint32_t>
+        {
+            static void set_property(JSContext * ctx, JSValue this_obj, uint32_t idx, JSValue value)
+            {
+                int err = JS_SetPropertyUint32(ctx, this_obj, idx, value);
+                if(err < 0)
+                    throw exception{};
+            }
+
+            static JSValue get_property(JSContext * ctx, JSValue this_obj, uint32_t idx) noexcept
+            {
+                return JS_GetPropertyUint32(ctx, this_obj, idx);
+            }
         };
 
         template <typename Key>
@@ -265,9 +365,10 @@ namespace qjs {
             JSValue this_obj;
             Key key;
 
-            operator JSValue() const
+            template <typename Value>
+            operator Value() const
             {
-                return js_property_traits<Key>::get_property(ctx, this_obj, key);
+                return js_traits<Value>::unwrap(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
             }
 
             template <typename Value>
@@ -471,7 +572,7 @@ namespace qjs {
         {
             JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
             //if(JS_IsException(v))
-                //throw detail::exception{};
+            //throw detail::exception{};
             return Value{ctx, v};
         }
 

From f4ce6085e51991ae319c2a6669027460f5106e21 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Jul 2019 15:38:30 +0000
Subject: [PATCH 002/185] more types, function support and some tests

---
 main.cpp      |  99 +++++++++++++------
 quickjspp.hpp | 259 ++++++++++++++++++++++++++++++++++++++------------
 2 files changed, 265 insertions(+), 93 deletions(-)

diff --git a/main.cpp b/main.cpp
index 00e972da85..1924b1316e 100644
--- a/main.cpp
+++ b/main.cpp
@@ -8,38 +8,45 @@
 #include <cstring>
 #include <ctime>
 
-
 int32_t f(int32_t x)
 {
     return x * x;
 };
 
+#define TYPES bool, int32_t, double, std::shared_ptr<test>, const std::shared_ptr<test>&, std::string, const std::string&
+
 class test
 {
-    int x;
+    bool b;
+    int32_t i;
+    double d;
+    std::shared_ptr<test> spt;
+    std::string s;
 public:
 
-    test(int32_t x) : x{x}
-    { printf("ctor %d!\n", x); }
+    test(int32_t i, TYPES) : i(i)
+    { printf("ctor!\n"); }
+
+    test(int32_t i) : i(i)
+    { printf("ctor %d!\n", i); }
 
     test(const test&) = delete;
 
     ~test()
     { printf("dtor!\n"); }
 
-    void f()
-    { printf("f(%p): x=%d\n", this, x); }
+    int32_t fi(TYPES) { i++; return i; }
+    bool fb(TYPES) { i++; return b; }
+    double fd(TYPES) { i++; return d; }
+    const std::shared_ptr<test>& fspt(TYPES) { i++; return spt; }
+    const std::string& fs(TYPES) { i++; return s; }
+    void f(TYPES) { i++; }
 
-    static void g()
-    { printf("g()\n"); }
+    static void fstatic(TYPES) {}
 };
 
 
-int32_t f2(int32_t x, std::shared_ptr<test> ptr)
-{
-    std::cout << ptr.get() << std::endl;
-    return x * x;
-};
+void f(TYPES) {}
 
 
 int main(int argc, char ** argv)
@@ -54,28 +61,31 @@ int main(int argc, char ** argv)
     Context context(runtime);
     ctx = context.ctx;
 
-    auto obj = context.newObject();
-    obj["test"] = 54;
-    obj["test2"] = 56;
-    obj["g"] = detail::fwrapper<&test::g>{"g"};
-    obj["fun2"] = detail::fwrapper<&f2>{"f2"};
-    obj["f"] = detail::fwrapper<&test::f>{"f"};
-    obj[3u] = detail::js_string{"43!"};
-
-    int testint = obj[3u];
-    std::string teststr = obj[3u];
-    std::cout << testint<< teststr;
+    {
+        auto obj = context.newObject();
+        obj["vi"] = 54;
+        obj["vb"] = true;
+        obj["vd"] = 56.0;
+        obj["vs"] = std::string{"test string"};
+        obj.add<int, int>("lambda", [](int x) -> int { return x * x; });
 
+        obj.add<&test::fi>("fi");
+        obj.add<&test::fb>("fb");
+        obj.add<&test::fd>("fd");
+        obj.add<&test::fs>("fs");
+        obj.add<&test::fspt>("fspt");
+        obj.add<&test::f>("f");
+        obj.add<&test::fstatic>("fstatic");
 
-    context.registerClass<test>("test_class", std::move(obj));
+        context.registerClass<test>("test_class", std::move(obj));
+    }
 
 
     context.addModule("test")
-            .add("sqr", detail::fwrapper<&f>{"sqr"})
-            .add("sqr2", detail::fwrapper<&f>{})
-            .add("p", detail::fwrapper<&f2>{"p"})
-            .add("obj", obj)
-            .add("Test", detail::ctor_wrapper<test, int32_t>{"Test"});
+            //.add("obj", obj)
+            .add("Test", detail::ctor_wrapper<test, int32_t, TYPES>{"Test"})
+    .add("TestSimple", detail::ctor_wrapper<test, int32_t>{"TestSimple"});
+
 
 
 
@@ -97,8 +107,37 @@ int main(int argc, char ** argv)
     context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
     const char * filename = argv[1];
 
+    {
+        auto xxx = context.eval("var t = new test.TestSimple(12);"
+                                "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"
+                                "q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
+                                "q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
+                                "q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs);"
+                                "q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
+                                "q.fi(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
+        assert(xxx.cast<int>() == 18);
+        auto yyy = context.eval("q.fi.bind(t)(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
+        assert(yyy.cast<int>() == 13);
+    }
+    try
+    {
+        auto f = context.eval("q.fi.bind(q)").cast<std::function<int32_t(TYPES)>>();
+        int xxx = f(false, 1, 0., context.eval("q").cast<std::shared_ptr<test>>(),
+                    context.eval("t").cast<std::shared_ptr<test>>(), "test string", std::string{"test"});
+        assert(xxx == 19);
+    }
+    catch(detail::exception)
+    {
+        js_std_dump_error(ctx);
+    }
+
+    if(filename)
     context.evalFile(filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_SHEBANG);
 
+    JSMemoryUsage mem;
+    JS_ComputeMemoryUsage(rt, &mem);
+    JS_DumpMemoryUsage(stderr, &mem, rt);
+
     js_std_loop(ctx);
 
     js_std_free_handlers(rt);
diff --git a/quickjspp.hpp b/quickjspp.hpp
index c8569f5c19..fc4c6bd064 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -11,6 +11,7 @@ extern "C" {
 #include <unordered_map>
 #include <cassert>
 #include <memory>
+#include <cstddef>
 
 namespace qjs {
 
@@ -42,7 +43,7 @@ namespace qjs {
         template <>
         struct js_traits<int32_t>
         {
-            static int32_t unwrap(JSContext * ctx, JSValue v)
+            static int32_t unwrap(JSContext * ctx, JSValueConst v)
             {
                 int32_t r;
                 if(JS_ToInt32(ctx, &r, v))
@@ -59,7 +60,7 @@ namespace qjs {
         template <>
         struct js_traits<bool>
         {
-            static bool unwrap(JSContext * ctx, JSValue v) noexcept
+            static bool unwrap(JSContext * ctx, JSValueConst v) noexcept
             {
                 return JS_ToBool(ctx, v);
             }
@@ -70,10 +71,20 @@ namespace qjs {
             }
         };
 
+        template <>
+        struct js_traits<void>
+        {
+            static void unwrap(JSContext * ctx, JSValueConst undefined)
+            {
+                if(!JS_IsUndefined(undefined))
+                    throw exception{};
+            }
+        };
+
         template <>
         struct js_traits<double>
         {
-            static double unwrap(JSContext * ctx, JSValue v)
+            static double unwrap(JSContext * ctx, JSValueConst v)
             {
                 double r;
                 if(JS_ToFloat64(ctx, &r, v))
@@ -111,7 +122,7 @@ namespace qjs {
         template <>
         struct js_traits<js_string>
         {
-            static js_string unwrap(JSContext * ctx, JSValue v)
+            static js_string unwrap(JSContext * ctx, JSValueConst v)
             {
                 int plen;
                 const char * ptr = JS_ToCStringLen(ctx, &plen, v, 0);
@@ -129,7 +140,7 @@ namespace qjs {
         template <> // slower
         struct js_traits<std::string>
         {
-            static std::string unwrap(JSContext * ctx, JSValue v)
+            static std::string unwrap(JSContext * ctx, JSValueConst v)
             {
                 auto str_view = js_traits<js_string>::unwrap(ctx, v);
                 return std::string{str_view.data(), str_view.size()};
@@ -141,29 +152,51 @@ namespace qjs {
             }
         };
 
-            /*
-        template <typename Arg1, typename... Args>
-        std::tuple<Arg1, Args...> to_tuple_impl(JSContext * ctx, JSValue * argv)
-        {
-            if constexpr (sizeof...(Args) == 0)
-                return std::make_tuple<Arg1>(js_traits<std::decay_t<Arg1>>::unwrap(ctx, *argv));
-            else // todo:rewrite
-                return std::tuple_cat(std::make_tuple<Arg1>(js_traits<std::decay_t<Arg1>>::unwrap(ctx, *argv)),
-                                      to_tuple_impl<Args...>(ctx, argv + 1));
-        }
-*/
+
         template <class Tuple, std::size_t... I>
-        Tuple unwrap_args_impl(JSContext * ctx, JSValue * argv, std::index_sequence<I...>)
+        Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
         {
             return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
         }
 
         template <typename... Args>
-        std::tuple<Args...> unwrap_args(JSContext * ctx, JSValue * argv)
+        std::tuple<Args...> unwrap_args(JSContext * ctx, JSValueConst * argv)
         {
             return unwrap_args_impl<std::tuple<Args...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
         }
 
+        template <typename R, typename... Args, typename Callable>
+        JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
+        {
+            try
+            {
+                if constexpr(std::is_same_v<R, void>)
+                {
+                    std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
+                    return JS_UNDEFINED;
+                } else
+                {
+                    return js_traits<std::decay_t<R>>::wrap(ctx, std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv)));
+                }
+            }
+            catch(exception)
+            {
+                return JS_EXCEPTION;
+            }
+        }
+
+
+        template <class Tuple, std::size_t... I>
+        void wrap_args_impl(JSContext * ctx, JSValue * argv, Tuple tuple, std::index_sequence<I...>)
+        {
+            ((argv[I] = js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::wrap(ctx, std::get<I>(tuple))), ...);
+        }
+
+        template <typename... Args>
+        void wrap_args(JSContext * ctx, JSValue * argv, Args&&... args)
+        {
+            wrap_args_impl(ctx, argv, std::make_tuple(std::forward<Args>(args)...), std::make_index_sequence<sizeof...(Args)>());
+        }
         // free function
 
         template <auto F>
@@ -177,24 +210,9 @@ namespace qjs {
         {
             static JSValue wrap(JSContext * ctx, fwrapper<F> fw)
             {
-                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValue this_value, int argc,
-                                               JSValue * argv) noexcept -> JSValue {
-                    //if(argc < sizeof...(Args))
-                    //return JS_EXCEPTION;
-                    try
-                    {
-                        if constexpr (std::is_same_v<R, void>)
-                        {
-                            std::apply(F, detail::unwrap_args<Args...>(ctx, argv));
-                            return JS_UNDEFINED;
-                        } else
-                            return js_traits<R>::wrap(ctx,
-                                                      std::apply(F, detail::unwrap_args<Args...>(ctx, argv))
-                            );
-                    } catch(detail::exception) // todo: inspect exception
-                    {
-                        return JS_EXCEPTION;
-                    }
+                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                               JSValueConst * argv) noexcept -> JSValue {
+                    return wrap_call<R, Args...>(ctx, F, argv);
                 }, fw.name, sizeof...(Args));
 
             }
@@ -207,8 +225,8 @@ namespace qjs {
         {
             static JSValue wrap(JSContext * ctx, fwrapper<F> fw)
             {
-                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValue this_value, int argc,
-                                               JSValue * argv) noexcept -> JSValue {
+                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                               JSValueConst * argv) noexcept -> JSValue {
                     //if(argc < sizeof...(Args))
                     //return JS_EXCEPTION;
                     try
@@ -221,7 +239,7 @@ namespace qjs {
                                                          detail::unwrap_args<Args...>(ctx, argv)));
                             return JS_UNDEFINED;
                         } else
-                            return js_traits<R>::wrap(ctx,
+                            return js_traits<std::decay_t<R>>::wrap(ctx,
                                                       std::apply(F, std::tuple_cat(std::make_tuple(this_sp.get()),
                                                                                    detail::unwrap_args<Args...>(ctx,
                                                                                                                 argv)))
@@ -241,6 +259,7 @@ namespace qjs {
         template <class T, typename... Args>
         struct ctor_wrapper
         {
+            static_assert(std::is_constructible<T, Args...>::value, "no such constructor!");
             const char * name = nullptr;
         };
 
@@ -249,19 +268,9 @@ namespace qjs {
         {
             static JSValue wrap(JSContext * ctx, ctor_wrapper<T, Args...> cw)
             {
-                return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValue this_value, int argc,
-                                                JSValue * argv) noexcept -> JSValue {
-                    try
-                    {
-
-                        return js_traits<std::shared_ptr<T>>::wrap(ctx,
-                                                                   std::apply(std::make_shared<T, Args...>,
-                                                                              detail::unwrap_args<Args...>(ctx, argv))
-                        );
-                    } catch(detail::exception)
-                    {
-                        return JS_EXCEPTION;
-                    }
+                return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                                JSValueConst * argv) noexcept -> JSValue {
+                    return wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
                 }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
 
             }
@@ -289,12 +298,9 @@ namespace qjs {
                             delete pptr;
                         }
                 };
-                if(QJSClassId == 0)
-                {
-                    int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
-                    if(e < 0)
-                        throw exception{};
-                }
+                int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+                if(e < 0)
+                    throw exception{};
                 JS_SetClassProto(ctx, QJSClassId, proto);
             }
 
@@ -302,13 +308,17 @@ namespace qjs {
             {
                 if(QJSClassId == 0) // not registered
                     throw exception{};
-                auto pptr = new std::shared_ptr<T>(std::move(ptr));
                 auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
+                if(JS_IsException(jsobj))
+                {
+                    return jsobj;
+                }
+                auto pptr = new std::shared_ptr<T>(std::move(ptr));
                 JS_SetOpaque(jsobj, pptr);
                 return jsobj;
             }
 
-            static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValue v)
+            static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
             {
                 auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
                 if(!ptr)
@@ -317,6 +327,69 @@ namespace qjs {
             }
         };
 
+
+
+        struct function // std::function replacement
+        {
+            JSValue (*invoker)(function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) = nullptr;
+            void (*destroyer)(function * self) = nullptr;
+            alignas(std::max_align_t) char functor[];
+
+            template <typename Functor>
+            static function * create(Functor&& f)
+            {
+                char * data = new char[sizeof(function) + sizeof(Functor)];
+                auto fptr = reinterpret_cast<function *>(data);
+                auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
+                new(functorptr) Functor(std::forward<Functor>(f));
+                fptr->destroyer = nullptr;
+                if constexpr(!std::is_trivially_destructible_v<Functor>)
+                {
+                    fptr->destroyer = [](function * fptr) {
+                        auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
+                        functorptr->~Functor();
+                    };
+                }
+                return fptr;
+            }
+        };
+
+        template <>
+        struct js_traits<function>
+        {
+            inline static JSClassID QJSClassId;
+            static void register_class(JSContext * ctx, const char * name)
+            {
+                JSClassDef def{
+                        name,
+                        // destructor
+                        [](JSRuntime * rt, JSValue obj) noexcept {
+                            auto pptr = reinterpret_cast<function *>(JS_GetOpaque(obj, QJSClassId));
+                            if(!pptr)
+                            {
+                                assert(false && "bad destructor");
+                            }
+                            if(pptr->destroyer)
+                                pptr->destroyer(pptr);
+                            auto cptr = reinterpret_cast<char *>(pptr);
+                            delete [] cptr;
+                        },
+                        nullptr, // mark
+                        // call
+                        [](JSContext *ctx, JSValueConst func_obj, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
+                            auto ptr = reinterpret_cast<function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
+                            if(!ptr)
+                                return JS_EXCEPTION;
+                            return ptr->invoker(ptr, ctx, this_val, argc, argv);
+                        }
+                };
+                int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+                if(e < 0)
+                    throw exception{};
+            }
+        };
+
+
         //          properties
 
         template <typename Key>
@@ -439,6 +512,21 @@ namespace qjs {
         }
 
 
+        template <auto F>
+        Value& add(const char * name)
+        {
+            (*this)[name] = detail::fwrapper<F>{name};
+            return *this;
+        }
+
+        template <typename R, typename... Args, typename Function>
+        //std::enable_if_t<std::is_invocable_r<R, Function, Args...>::value, Value&>
+                Value& add(const char * name, Function&& f)
+        {
+            (*this)[name] = detail::js_traits<std::function<R (Args...)>>::wrap(ctx, std::forward<Function>(f));
+            return *this;
+        }
+
     };
 
 
@@ -522,6 +610,11 @@ namespace qjs {
 
         std::vector<Module> modules;
     private:
+        void init()
+        {
+            JS_SetContextOpaque(ctx, this);
+            detail::js_traits<detail::function>::register_class(ctx, "");
+        }
     public:
         Context(Runtime& rt) : Context(rt.rt)
         {}
@@ -531,12 +624,12 @@ namespace qjs {
             ctx = JS_NewContext(rt);
             if(!ctx)
                 throw detail::exception{};
-            JS_SetContextOpaque(ctx, this);
+            init();
         }
 
         Context(JSContext * ctx) : ctx{ctx}
         {
-            JS_SetContextOpaque(ctx, this);
+            init();
         }
 
         Context(const Context&) = delete;
@@ -568,7 +661,7 @@ namespace qjs {
             detail::js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
         }
 
-        Value eval(std::string_view buffer, const char * filename, unsigned eval_flags = 0)
+        Value eval(std::string_view buffer, const char * filename = "eval", unsigned eval_flags = 0)
         {
             JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
             //if(JS_IsException(v))
@@ -589,4 +682,44 @@ namespace qjs {
     };
 
 
+    namespace detail {
+
+        template <typename R, typename... Args>
+        struct js_traits<std::function<R (Args...)>>
+        {
+            static std::function<R (Args...)> unwrap(JSContext * ctx, JSValueConst fun_obj)
+            {
+                return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&&... args) -> R {
+                    const int argc = sizeof...(Args);
+                    JSValue argv[argc];
+                    wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
+                    JSValue result;
+                    //if(JS_IsObject(argv[0])) // constexpr?
+                    //   result = JS_Call(ctx, fun_obj, argv[0], argc - 1, const_cast<JSValueConst*>(argv + 1));
+                    //else
+                    result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
+                    for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
+                    return js_traits<R>::unwrap(jsfun_obj.ctx, result);
+                };
+            }
+
+            template <typename Functor>
+            static JSValue wrap(JSContext * ctx, Functor&& functor)
+            {
+                auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
+                if(JS_IsException(obj))
+                    return JS_EXCEPTION;
+                auto fptr = function::create(std::forward<Functor>(functor));
+                fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
+                    assert(self);
+                    auto f = reinterpret_cast<Functor *>(&self->functor);
+                    return wrap_call<R, Args...>(ctx, *f, argv);
+                };
+                JS_SetOpaque(obj, fptr);
+                return obj;
+            }
+        };
+
+    }
+
 }
\ No newline at end of file

From c14b37d2ee8cbf45788217b0c2b802ee81e88c57 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Jul 2019 16:21:15 +0000
Subject: [PATCH 003/185] updated quickjs to 2019-07-21

---
 quickjs/VERSION            |    2 +-
 quickjs/libregexp.c        |    2 +-
 quickjs/libunicode-table.h | 4120 ++++++++++++++++++------------------
 quickjs/quickjs-atom.h     |    2 -
 quickjs/quickjs-libc.c     |   17 +-
 quickjs/quickjs.c          |  594 +++---
 quickjs/quickjs.h          |    9 +
 7 files changed, 2412 insertions(+), 2334 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 0a01e3ef04..51e58f773f 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-07-09
+2019-07-21
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index 65f0d1b6dc..61177efab1 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -2407,7 +2407,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 for(;;) {
                     res = lre_exec_backtrack(s, capture, stack, stack_len,
                                              pc1, cptr, TRUE);
-                    if (res < 0)
+                    if (res == -1)
                         return res;
                     if (!res)
                         break;
diff --git a/quickjs/libunicode-table.h b/quickjs/libunicode-table.h
index 76ec87c4eb..521f2f3190 100644
--- a/quickjs/libunicode-table.h
+++ b/quickjs/libunicode-table.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-static const uint32_t case_conv_table1[352] = {
+static const uint32_t case_conv_table1[359] = {
     0x00209a30, 0x00309a00, 0x005a8173, 0x00601730,
     0x006c0730, 0x006f81b3, 0x00701700, 0x007c0700,
     0x007f8100, 0x00803040, 0x009801c3, 0x00988190,
@@ -29,116 +29,119 @@ static const uint32_t case_conv_table1[352] = {
     0x01308101, 0x01318100, 0x01328101, 0x01330101,
     0x01340100, 0x01348100, 0x01350101, 0x01358101,
     0x01360101, 0x01378100, 0x01388101, 0x01390100,
-    0x013a8100, 0x013e8101, 0x01400100, 0x01418100,
-    0x01438101, 0x01440100, 0x01448100, 0x01450200,
-    0x01460100, 0x01490100, 0x014e8101, 0x014f0101,
-    0x01a28173, 0x01b80440, 0x01bb0240, 0x01bd8300,
-    0x01bf8130, 0x01c30130, 0x01c40330, 0x01c60130,
-    0x01c70230, 0x01c801d0, 0x01c89130, 0x01d18930,
-    0x01d60100, 0x01d68300, 0x01d801d3, 0x01d89100,
-    0x01e10173, 0x01e18900, 0x01e60100, 0x01e68200,
-    0x01e78130, 0x01e80173, 0x01e88173, 0x01ea8173,
-    0x01eb0173, 0x01eb8100, 0x01ec1840, 0x01f80173,
-    0x01f88173, 0x01f90100, 0x01f98100, 0x01fa01a0,
-    0x01fa8173, 0x01fb8240, 0x01fc8130, 0x01fd0240,
-    0x01fe8330, 0x02001030, 0x02082030, 0x02182000,
-    0x02281000, 0x02302240, 0x02453640, 0x02600130,
-    0x02608e40, 0x02678100, 0x02686040, 0x0298a630,
-    0x02b0a600, 0x02c381b5, 0x08502631, 0x08638131,
-    0x08668131, 0x08682b00, 0x087e8300, 0x09d05011,
-    0x09f80610, 0x09fc0620, 0x0e400174, 0x0e408174,
-    0x0e410174, 0x0e418174, 0x0e420174, 0x0e428174,
-    0x0e430174, 0x0e438180, 0x0e440180, 0x0e482b30,
-    0x0e5e8330, 0x0ebc8101, 0x0ebe8101, 0x0f007e40,
-    0x0f3f1840, 0x0f4b01b5, 0x0f4b81b6, 0x0f4c01b6,
-    0x0f4c81b6, 0x0f4d01b7, 0x0f4d8180, 0x0f4f0130,
-    0x0f506040, 0x0f800800, 0x0f840830, 0x0f880600,
-    0x0f8c0630, 0x0f900800, 0x0f940830, 0x0f980800,
-    0x0f9c0830, 0x0fa00600, 0x0fa40630, 0x0fa801b0,
-    0x0fa88100, 0x0fa901d3, 0x0fa98100, 0x0faa01d3,
-    0x0faa8100, 0x0fab01d3, 0x0fab8100, 0x0fac8130,
-    0x0fad8130, 0x0fae8130, 0x0faf8130, 0x0fb00800,
-    0x0fb40830, 0x0fb80200, 0x0fb90400, 0x0fbb0200,
-    0x0fbc0201, 0x0fbd0201, 0x0fbe0201, 0x0fc008b7,
-    0x0fc40867, 0x0fc808b8, 0x0fcc0868, 0x0fd008b8,
-    0x0fd40868, 0x0fd80200, 0x0fd901b9, 0x0fd981b1,
-    0x0fda01b9, 0x0fdb01b1, 0x0fdb81d7, 0x0fdc0230,
-    0x0fdd0230, 0x0fde0161, 0x0fdf0173, 0x0fe101b9,
-    0x0fe181b2, 0x0fe201ba, 0x0fe301b2, 0x0fe381d8,
-    0x0fe40430, 0x0fe60162, 0x0fe80200, 0x0fe901d0,
-    0x0fe981d0, 0x0feb01b0, 0x0feb81d0, 0x0fec0230,
-    0x0fed0230, 0x0ff00201, 0x0ff101d3, 0x0ff181d3,
-    0x0ff201ba, 0x0ff28101, 0x0ff301b0, 0x0ff381d3,
-    0x0ff40230, 0x0ff50230, 0x0ff60131, 0x0ff901ba,
-    0x0ff981b2, 0x0ffa01bb, 0x0ffb01b2, 0x0ffb81d9,
-    0x0ffc0230, 0x0ffd0230, 0x0ffe0162, 0x109301a0,
-    0x109501a0, 0x109581a0, 0x10990131, 0x10a70101,
-    0x10b01031, 0x10b81001, 0x10c18240, 0x125b1a31,
-    0x12681a01, 0x16002f31, 0x16182f01, 0x16300240,
-    0x16310130, 0x16318130, 0x16320130, 0x16328100,
-    0x16330100, 0x16338640, 0x16368130, 0x16370130,
-    0x16378130, 0x16380130, 0x16390240, 0x163a8240,
-    0x163f0230, 0x16406440, 0x16758440, 0x16790240,
-    0x16802600, 0x16938100, 0x16968100, 0x53202e40,
-    0x53401c40, 0x53910e40, 0x53993e40, 0x53bc8440,
-    0x53be8130, 0x53bf0a40, 0x53c58240, 0x53c68130,
-    0x53c80440, 0x53cb1440, 0x53d50130, 0x53d58130,
-    0x53d60130, 0x53d68130, 0x53d70130, 0x53d80130,
-    0x53d88130, 0x53d90130, 0x53d98131, 0x53da0640,
-    0x55a98101, 0x55b85020, 0x7d8001b2, 0x7d8081b2,
-    0x7d8101b2, 0x7d8181da, 0x7d8201da, 0x7d8281b3,
-    0x7d8301b3, 0x7d8981bb, 0x7d8a01bb, 0x7d8a81bb,
-    0x7d8b01bc, 0x7d8b81bb, 0x7f909a31, 0x7fa09a01,
-    0x82002831, 0x82142801, 0x82582431, 0x826c2401,
-    0x86403331, 0x86603301, 0x8c502031, 0x8c602001,
-    0xb7202031, 0xb7302001, 0xf4802231, 0xf4912201,
+    0x013a8100, 0x013e8101, 0x01400100, 0x01410101,
+    0x01418100, 0x01438101, 0x01440100, 0x01448100,
+    0x01450200, 0x01460100, 0x01490100, 0x014e8101,
+    0x014f0101, 0x01a28173, 0x01b80440, 0x01bb0240,
+    0x01bd8300, 0x01bf8130, 0x01c30130, 0x01c40330,
+    0x01c60130, 0x01c70230, 0x01c801d0, 0x01c89130,
+    0x01d18930, 0x01d60100, 0x01d68300, 0x01d801d3,
+    0x01d89100, 0x01e10173, 0x01e18900, 0x01e60100,
+    0x01e68200, 0x01e78130, 0x01e80173, 0x01e88173,
+    0x01ea8173, 0x01eb0173, 0x01eb8100, 0x01ec1840,
+    0x01f80173, 0x01f88173, 0x01f90100, 0x01f98100,
+    0x01fa01a0, 0x01fa8173, 0x01fb8240, 0x01fc8130,
+    0x01fd0240, 0x01fe8330, 0x02001030, 0x02082030,
+    0x02182000, 0x02281000, 0x02302240, 0x02453640,
+    0x02600130, 0x02608e40, 0x02678100, 0x02686040,
+    0x0298a630, 0x02b0a600, 0x02c381b5, 0x08502631,
+    0x08638131, 0x08668131, 0x08682b00, 0x087e8300,
+    0x09d05011, 0x09f80610, 0x09fc0620, 0x0e400174,
+    0x0e408174, 0x0e410174, 0x0e418174, 0x0e420174,
+    0x0e428174, 0x0e430174, 0x0e438180, 0x0e440180,
+    0x0e482b30, 0x0e5e8330, 0x0ebc8101, 0x0ebe8101,
+    0x0ec70101, 0x0f007e40, 0x0f3f1840, 0x0f4b01b5,
+    0x0f4b81b6, 0x0f4c01b6, 0x0f4c81b6, 0x0f4d01b7,
+    0x0f4d8180, 0x0f4f0130, 0x0f506040, 0x0f800800,
+    0x0f840830, 0x0f880600, 0x0f8c0630, 0x0f900800,
+    0x0f940830, 0x0f980800, 0x0f9c0830, 0x0fa00600,
+    0x0fa40630, 0x0fa801b0, 0x0fa88100, 0x0fa901d3,
+    0x0fa98100, 0x0faa01d3, 0x0faa8100, 0x0fab01d3,
+    0x0fab8100, 0x0fac8130, 0x0fad8130, 0x0fae8130,
+    0x0faf8130, 0x0fb00800, 0x0fb40830, 0x0fb80200,
+    0x0fb90400, 0x0fbb0200, 0x0fbc0201, 0x0fbd0201,
+    0x0fbe0201, 0x0fc008b7, 0x0fc40867, 0x0fc808b8,
+    0x0fcc0868, 0x0fd008b8, 0x0fd40868, 0x0fd80200,
+    0x0fd901b9, 0x0fd981b1, 0x0fda01b9, 0x0fdb01b1,
+    0x0fdb81d7, 0x0fdc0230, 0x0fdd0230, 0x0fde0161,
+    0x0fdf0173, 0x0fe101b9, 0x0fe181b2, 0x0fe201ba,
+    0x0fe301b2, 0x0fe381d8, 0x0fe40430, 0x0fe60162,
+    0x0fe80200, 0x0fe901d0, 0x0fe981d0, 0x0feb01b0,
+    0x0feb81d0, 0x0fec0230, 0x0fed0230, 0x0ff00201,
+    0x0ff101d3, 0x0ff181d3, 0x0ff201ba, 0x0ff28101,
+    0x0ff301b0, 0x0ff381d3, 0x0ff40230, 0x0ff50230,
+    0x0ff60131, 0x0ff901ba, 0x0ff981b2, 0x0ffa01bb,
+    0x0ffb01b2, 0x0ffb81d9, 0x0ffc0230, 0x0ffd0230,
+    0x0ffe0162, 0x109301a0, 0x109501a0, 0x109581a0,
+    0x10990131, 0x10a70101, 0x10b01031, 0x10b81001,
+    0x10c18240, 0x125b1a31, 0x12681a01, 0x16002f31,
+    0x16182f01, 0x16300240, 0x16310130, 0x16318130,
+    0x16320130, 0x16328100, 0x16330100, 0x16338640,
+    0x16368130, 0x16370130, 0x16378130, 0x16380130,
+    0x16390240, 0x163a8240, 0x163f0230, 0x16406440,
+    0x16758440, 0x16790240, 0x16802600, 0x16938100,
+    0x16968100, 0x53202e40, 0x53401c40, 0x53910e40,
+    0x53993e40, 0x53bc8440, 0x53be8130, 0x53bf0a40,
+    0x53c58240, 0x53c68130, 0x53c80440, 0x53ca0101,
+    0x53cb1440, 0x53d50130, 0x53d58130, 0x53d60130,
+    0x53d68130, 0x53d70130, 0x53d80130, 0x53d88130,
+    0x53d90130, 0x53d98131, 0x53da0c40, 0x53e10240,
+    0x53e20131, 0x53e28130, 0x53e30130, 0x55a98101,
+    0x55b85020, 0x7d8001b2, 0x7d8081b2, 0x7d8101b2,
+    0x7d8181da, 0x7d8201da, 0x7d8281b3, 0x7d8301b3,
+    0x7d8981bb, 0x7d8a01bb, 0x7d8a81bb, 0x7d8b01bc,
+    0x7d8b81bb, 0x7f909a31, 0x7fa09a01, 0x82002831,
+    0x82142801, 0x82582431, 0x826c2401, 0x86403331,
+    0x86603301, 0x8c502031, 0x8c602001, 0xb7202031,
+    0xb7302001, 0xf4802231, 0xf4912201,
 };
 
-static const uint8_t case_conv_table2[352] = {
+static const uint8_t case_conv_table2[359] = {
     0x01, 0x00, 0x9c, 0x06, 0x07, 0x4d, 0x03, 0x04,
     0x10, 0x00, 0x8f, 0x0b, 0x00, 0x00, 0x11, 0x00,
     0x08, 0x00, 0x53, 0x4a, 0x51, 0x00, 0x52, 0x00,
     0x53, 0x00, 0x3a, 0x54, 0x55, 0x00, 0x57, 0x59,
     0x3f, 0x5d, 0x5c, 0x00, 0x46, 0x61, 0x63, 0x42,
-    0x64, 0x00, 0x66, 0x00, 0x67, 0x00, 0x69, 0x00,
-    0x6b, 0x00, 0x6d, 0x00, 0x00, 0x40, 0x00, 0x00,
+    0x64, 0x00, 0x66, 0x00, 0x68, 0x00, 0x6a, 0x00,
+    0x6c, 0x00, 0x6e, 0x00, 0x00, 0x40, 0x00, 0x00,
     0x00, 0x00, 0x1a, 0x00, 0x93, 0x00, 0x00, 0x20,
-    0x35, 0x00, 0x27, 0x00, 0x1f, 0x00, 0x24, 0x20,
-    0x28, 0x00, 0x13, 0x6a, 0x6c, 0x00, 0x24, 0x22,
-    0x25, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x3b, 0x1e,
-    0x3c, 0x1f, 0x37, 0x3a, 0x22, 0x21, 0x3e, 0x1c,
-    0x3d, 0x25, 0x23, 0x26, 0x28, 0x1e, 0x2a, 0x2c,
-    0x40, 0x2e, 0x4b, 0x30, 0x4c, 0x32, 0x41, 0x3f,
-    0x99, 0x00, 0x00, 0x94, 0x8e, 0x7c, 0x7d, 0x82,
-    0x83, 0x12, 0x7f, 0x81, 0x75, 0x76, 0x12, 0x7a,
-    0xa3, 0x7b, 0x77, 0x78, 0x89, 0x92, 0x98, 0xa6,
-    0xa0, 0x84, 0x00, 0x9a, 0xa1, 0x92, 0x74, 0x33,
-    0x95, 0x00, 0x8d, 0x00, 0x73, 0x98, 0x97, 0x96,
-    0x95, 0x00, 0x00, 0x9d, 0x00, 0x9b, 0x00, 0xa0,
-    0x9f, 0x15, 0x2c, 0x2d, 0x2e, 0xb3, 0xb4, 0x45,
-    0xa9, 0xa8, 0x12, 0x14, 0x1e, 0x21, 0x22, 0x22,
-    0x2a, 0x34, 0x35, 0xa5, 0xa6, 0x34, 0x1d, 0x00,
-    0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d, 0x36, 0x05,
-    0x00, 0xc2, 0xc1, 0xc4, 0xc3, 0xc6, 0xc5, 0xc8,
-    0xc7, 0xca, 0xc9, 0xc4, 0xd3, 0x45, 0xd4, 0x42,
-    0xd5, 0x46, 0xd6, 0xcc, 0xce, 0xd0, 0xd2, 0xd8,
-    0xd7, 0xec, 0xf4, 0xfc, 0x0c, 0x05, 0x0d, 0x80,
-    0x9f, 0x00, 0x21, 0x80, 0xa3, 0xeb, 0x00, 0xc0,
-    0x40, 0xc6, 0x60, 0xe5, 0xd9, 0xe6, 0x99, 0xc0,
-    0x00, 0x00, 0x06, 0x60, 0xda, 0x29, 0xfb, 0x15,
-    0x12, 0x06, 0x16, 0xf6, 0xdb, 0x04, 0x15, 0x12,
-    0x84, 0x06, 0xc6, 0x16, 0xfd, 0xdd, 0x01, 0xc0,
-    0x40, 0x00, 0x46, 0x60, 0xdc, 0xde, 0x6d, 0x37,
-    0x38, 0x39, 0x13, 0x12, 0x15, 0x14, 0x00, 0x18,
-    0x17, 0x1a, 0x19, 0x00, 0x5f, 0xb6, 0x65, 0x44,
-    0x47, 0x00, 0x4f, 0x62, 0x4e, 0x50, 0x00, 0x00,
-    0x48, 0x00, 0x00, 0x00, 0xa2, 0xa3, 0xa4, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x5a,
-    0x00, 0x00, 0x5b, 0x56, 0x58, 0x60, 0x5e, 0x6f,
-    0x68, 0x6e, 0x44, 0x00, 0x42, 0xa7, 0x8a, 0x8b,
-    0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf, 0x94, 0xb0,
-    0x6f, 0xb2, 0x53, 0x52, 0x55, 0x54, 0x57, 0x56,
-    0x59, 0x58, 0x5b, 0x5a, 0x5d, 0x5c, 0x5f, 0x5e,
+    0x35, 0x00, 0x27, 0x00, 0x21, 0x00, 0x24, 0x22,
+    0x2a, 0x00, 0x13, 0x6b, 0x6d, 0x00, 0x26, 0x24,
+    0x27, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x3e, 0x1e,
+    0x3f, 0x1f, 0x39, 0x3d, 0x22, 0x21, 0x41, 0x1e,
+    0x40, 0x25, 0x25, 0x26, 0x28, 0x20, 0x2a, 0x49,
+    0x2c, 0x43, 0x2e, 0x4b, 0x30, 0x4c, 0x32, 0x44,
+    0x42, 0x99, 0x00, 0x00, 0x95, 0x8f, 0x7d, 0x7e,
+    0x83, 0x84, 0x12, 0x80, 0x82, 0x76, 0x77, 0x12,
+    0x7b, 0xa3, 0x7c, 0x78, 0x79, 0x8a, 0x92, 0x98,
+    0xa6, 0xa0, 0x85, 0x00, 0x9a, 0xa1, 0x93, 0x75,
+    0x33, 0x95, 0x00, 0x8e, 0x00, 0x74, 0x99, 0x98,
+    0x97, 0x96, 0x00, 0x00, 0x9e, 0x00, 0x9c, 0x00,
+    0xa1, 0xa0, 0x15, 0x2e, 0x2f, 0x30, 0xb4, 0xb5,
+    0x4c, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
+    0x22, 0x2a, 0x34, 0x35, 0xa6, 0xa7, 0x36, 0x1f,
+    0x4a, 0x00, 0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d,
+    0x36, 0x05, 0x00, 0xc4, 0xc3, 0xc6, 0xc5, 0xc8,
+    0xc7, 0xca, 0xc9, 0xcc, 0xcb, 0xc4, 0xd5, 0x45,
+    0xd6, 0x42, 0xd7, 0x46, 0xd8, 0xce, 0xd0, 0xd2,
+    0xd4, 0xda, 0xd9, 0xee, 0xf6, 0xfe, 0x0e, 0x07,
+    0x0f, 0x80, 0x9f, 0x00, 0x21, 0x80, 0xa3, 0xed,
+    0x00, 0xc0, 0x40, 0xc6, 0x60, 0xe7, 0xdb, 0xe6,
+    0x99, 0xc0, 0x00, 0x00, 0x06, 0x60, 0xdc, 0x29,
+    0xfd, 0x15, 0x12, 0x06, 0x16, 0xf8, 0xdd, 0x06,
+    0x15, 0x12, 0x84, 0x08, 0xc6, 0x16, 0xff, 0xdf,
+    0x03, 0xc0, 0x40, 0x00, 0x46, 0x60, 0xde, 0xe0,
+    0x6d, 0x37, 0x38, 0x39, 0x15, 0x14, 0x17, 0x16,
+    0x00, 0x1a, 0x19, 0x1c, 0x1b, 0x00, 0x5f, 0xb7,
+    0x65, 0x44, 0x47, 0x00, 0x4f, 0x62, 0x4e, 0x50,
+    0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0xa3, 0xa4,
+    0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0x00,
+    0x00, 0x5a, 0x00, 0x48, 0x00, 0x5b, 0x56, 0x58,
+    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4b, 0x00, 0x00,
+    0x3b, 0x67, 0xb8, 0x45, 0xa8, 0x8a, 0x8b, 0x8c,
+    0xab, 0xac, 0x58, 0x58, 0xaf, 0x94, 0xb0, 0x6f,
+    0xb2, 0x5a, 0x59, 0x5c, 0x5b, 0x5e, 0x5d, 0x60,
+    0x5f, 0x62, 0x61, 0x64, 0x63, 0x66, 0x65,
 };
 
 static const uint16_t case_conv_ext[58] = {
@@ -152,38 +155,38 @@ static const uint16_t case_conv_ext[58] = {
     0x006b, 0x00e5,
 };
 
-static const uint8_t unicode_prop_Cased1_table[170] = {
+static const uint8_t unicode_prop_Cased1_table[172] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0xfc, 0x80, 0xd3,
     0x80, 0x8c, 0x80, 0x8d, 0x81, 0x8d, 0x02, 0x80,
     0xe1, 0x80, 0x91, 0x85, 0x9a, 0x01, 0x00, 0x01,
     0x11, 0x00, 0x01, 0x04, 0x08, 0x01, 0x08, 0x30,
-    0x08, 0x08, 0x15, 0x20, 0x00, 0x39, 0x99, 0x31,
+    0x08, 0x01, 0x15, 0x20, 0x00, 0x39, 0x99, 0x31,
     0x9d, 0x84, 0x40, 0x94, 0x80, 0xd6, 0x82, 0xa6,
     0x80, 0x41, 0x62, 0x80, 0xa6, 0x80, 0x57, 0x76,
-    0xf8, 0x02, 0x80, 0xc1, 0x40, 0xdb, 0x08, 0x80,
-    0x41, 0xd0, 0x80, 0x8c, 0x80, 0x8f, 0x8c, 0xe4,
-    0x03, 0x01, 0x89, 0x00, 0x14, 0x28, 0x10, 0x11,
-    0x02, 0x01, 0x18, 0x0b, 0x24, 0x4b, 0x26, 0x01,
-    0x01, 0x86, 0xe5, 0x80, 0x60, 0x79, 0xb6, 0x81,
-    0x40, 0x91, 0x81, 0xbd, 0x88, 0x94, 0x04, 0x81,
-    0x98, 0x80, 0xc7, 0x82, 0x43, 0x34, 0xa2, 0x06,
-    0x80, 0x89, 0x61, 0x28, 0x99, 0xd4, 0x80, 0xc6,
-    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
-    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
-    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x98,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x07, 0x59, 0x63, 0x99, 0x85, 0x99,
-    0x85, 0x99,
+    0xf8, 0x02, 0x80, 0x8f, 0x80, 0xb0, 0x40, 0xdb,
+    0x08, 0x80, 0x41, 0xd0, 0x80, 0x8c, 0x80, 0x8f,
+    0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x14, 0x28,
+    0x10, 0x11, 0x02, 0x01, 0x18, 0x0b, 0x24, 0x4b,
+    0x26, 0x01, 0x01, 0x86, 0xe5, 0x80, 0x60, 0x79,
+    0xb6, 0x81, 0x40, 0x91, 0x81, 0xbd, 0x88, 0x94,
+    0x05, 0x80, 0x98, 0x80, 0xc7, 0x82, 0x43, 0x34,
+    0xa2, 0x06, 0x80, 0x8b, 0x61, 0x28, 0x97, 0xd4,
+    0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b,
+    0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80,
+    0x9b, 0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53,
+    0x81, 0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x07, 0x59, 0x63, 0x99,
+    0x85, 0x99, 0x85, 0x99,
 };
 
 static const uint8_t unicode_prop_Cased1_index[18] = {
-    0xb9, 0x02, 0xe0, 0xa0, 0x1e, 0x00, 0x9e, 0xa6,
-    0x00, 0xc4, 0xd4, 0x01, 0xa9, 0xd7, 0x01, 0x8a,
+    0xb9, 0x02, 0xe0, 0xa0, 0x1e, 0x40, 0x9e, 0xa6,
+    0x40, 0xba, 0xd4, 0x01, 0x89, 0xd7, 0x01, 0x8a,
     0xf1, 0x01,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_table[663] = {
+static const uint8_t unicode_prop_Case_Ignorable_table[678] = {
     0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80,
     0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
     0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40,
@@ -204,83 +207,86 @@ static const uint8_t unicode_prop_Case_Ignorable_table[663] = {
     0x80, 0xb9, 0x01, 0x05, 0x04, 0x81, 0x93, 0x81,
     0x9b, 0x81, 0xb8, 0x0b, 0x1f, 0x80, 0x93, 0x81,
     0xe5, 0x06, 0x10, 0x80, 0xd9, 0x01, 0x86, 0x8a,
-    0x88, 0xe1, 0x01, 0x28, 0x81, 0x88, 0x00, 0x85,
-    0xc9, 0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d,
-    0x04, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80,
-    0xe5, 0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82,
-    0x8f, 0x83, 0x8c, 0x01, 0x0d, 0x80, 0x8e, 0x80,
-    0xdd, 0x80, 0x42, 0x5f, 0x82, 0x43, 0xb1, 0x82,
-    0x9c, 0x82, 0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x08,
-    0x37, 0x01, 0x8a, 0x10, 0x20, 0xac, 0x83, 0xb3,
-    0x80, 0xc0, 0x81, 0xa1, 0x80, 0xf5, 0x13, 0x81,
-    0x88, 0x05, 0x82, 0x40, 0xda, 0x09, 0x80, 0xb9,
-    0x00, 0x30, 0x00, 0x01, 0x3d, 0x89, 0x08, 0xa6,
-    0x07, 0x8e, 0xc0, 0x83, 0xaf, 0x00, 0x20, 0x04,
-    0x80, 0xa7, 0x88, 0x8b, 0x81, 0x9f, 0x19, 0x08,
-    0x82, 0xb7, 0x00, 0x0a, 0x00, 0x82, 0xb9, 0x39,
-    0x81, 0xbf, 0x85, 0xd1, 0x10, 0x8c, 0x06, 0x18,
-    0x28, 0x11, 0xb1, 0xbe, 0x8c, 0x80, 0xa1, 0xde,
-    0x04, 0x41, 0xbc, 0x00, 0x82, 0x8a, 0x82, 0x8c,
-    0x82, 0x8c, 0x82, 0x8c, 0x81, 0x8b, 0x27, 0x81,
-    0x89, 0x01, 0x01, 0x84, 0xb0, 0x20, 0x89, 0x00,
-    0x8c, 0x80, 0x8f, 0x8c, 0xb2, 0xa0, 0x4b, 0x8a,
-    0x81, 0xf0, 0x82, 0xfc, 0x80, 0x8e, 0x80, 0xdf,
-    0x9f, 0xae, 0x80, 0x41, 0xd4, 0x80, 0xa3, 0x1a,
-    0x24, 0x80, 0xdc, 0x85, 0xdc, 0x82, 0x60, 0x6f,
-    0x15, 0x80, 0x44, 0xe1, 0x85, 0x41, 0x0d, 0x80,
-    0xe1, 0x18, 0x89, 0x00, 0x9b, 0x83, 0xcf, 0x81,
-    0x8d, 0xa1, 0xcd, 0x80, 0x96, 0x82, 0xec, 0x0f,
-    0x02, 0x03, 0x80, 0x98, 0x81, 0x40, 0x9c, 0x81,
-    0x99, 0x91, 0x8c, 0x80, 0xa5, 0x87, 0x98, 0x8a,
-    0xad, 0x82, 0xaf, 0x01, 0x19, 0x80, 0x91, 0x80,
-    0x94, 0x81, 0xc1, 0x29, 0x09, 0x81, 0x8b, 0x07,
-    0x80, 0xa2, 0x80, 0x8a, 0x80, 0xb2, 0x00, 0x11,
-    0x0c, 0x08, 0x80, 0x9a, 0x80, 0x8d, 0x0c, 0x08,
-    0x80, 0xe3, 0x84, 0x40, 0x84, 0x01, 0x03, 0x80,
-    0x60, 0x4f, 0x2f, 0x80, 0x40, 0x92, 0x8f, 0x42,
-    0x3d, 0x8f, 0x10, 0x8b, 0x8f, 0xa1, 0x01, 0x80,
-    0x40, 0xa8, 0x06, 0x05, 0x80, 0x8a, 0x80, 0xa2,
-    0x00, 0x80, 0xae, 0x80, 0xac, 0x81, 0xc2, 0x80,
-    0x94, 0x82, 0x42, 0x00, 0x80, 0x40, 0xe1, 0x80,
-    0x40, 0x94, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83,
-    0xa7, 0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c,
-    0x83, 0x42, 0x1d, 0x8a, 0x40, 0xaf, 0x80, 0xb5,
-    0x8e, 0xb7, 0x82, 0xb0, 0x19, 0x09, 0x80, 0x8e,
-    0x80, 0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80,
-    0x8b, 0x81, 0xb3, 0x88, 0x89, 0x83, 0xe1, 0x11,
-    0x00, 0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94,
-    0x81, 0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0x40,
-    0xc2, 0x39, 0x10, 0x80, 0x96, 0x80, 0xd3, 0x28,
-    0x03, 0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81,
-    0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00,
-    0x01, 0x28, 0x80, 0xe4, 0x11, 0x18, 0x84, 0x41,
-    0x02, 0x88, 0x01, 0x41, 0xc5, 0x89, 0xa7, 0x29,
-    0x1f, 0x80, 0x88, 0x29, 0x82, 0xad, 0x8c, 0x01,
-    0x41, 0x95, 0x30, 0x28, 0x80, 0xd1, 0x95, 0x0e,
-    0x01, 0x01, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x80,
-    0xc7, 0x0a, 0x00, 0x80, 0x41, 0x5a, 0x81, 0x60,
-    0x4b, 0xfa, 0x84, 0xba, 0x86, 0x88, 0x83, 0x44,
-    0x4a, 0x90, 0xbf, 0x81, 0x60, 0x4c, 0xba, 0x08,
-    0x83, 0x54, 0xc2, 0x82, 0x88, 0x8f, 0x0e, 0x9d,
-    0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6, 0x83,
-    0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45,
-    0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x48, 0xa4,
-    0x86, 0xec, 0x86, 0x4a, 0xaf, 0x84, 0x6c, 0x0c,
-    0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40, 0xef,
+    0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x85, 0xc9,
+    0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d, 0x04,
+    0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe5,
+    0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82, 0x8f,
+    0x83, 0x8c, 0x01, 0x0d, 0x80, 0x8e, 0x80, 0xdd,
+    0x80, 0x42, 0x5f, 0x82, 0x43, 0xb1, 0x82, 0x9c,
+    0x82, 0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x08, 0x37,
+    0x01, 0x8a, 0x10, 0x20, 0xac, 0x83, 0xb3, 0x80,
+    0xc0, 0x81, 0xa1, 0x80, 0xf5, 0x13, 0x81, 0x88,
+    0x05, 0x82, 0x40, 0xda, 0x09, 0x80, 0xb9, 0x00,
+    0x30, 0x00, 0x01, 0x3d, 0x89, 0x08, 0xa6, 0x07,
+    0x8e, 0xc0, 0x83, 0xaf, 0x00, 0x20, 0x04, 0x80,
+    0xa7, 0x88, 0x8b, 0x81, 0x9f, 0x19, 0x08, 0x82,
+    0xb7, 0x00, 0x0a, 0x00, 0x82, 0xb9, 0x39, 0x81,
+    0xbf, 0x85, 0xd1, 0x10, 0x8c, 0x06, 0x18, 0x28,
+    0x11, 0xb1, 0xbe, 0x8c, 0x80, 0xa1, 0xde, 0x04,
+    0x41, 0xbc, 0x00, 0x82, 0x8a, 0x82, 0x8c, 0x82,
+    0x8c, 0x82, 0x8c, 0x81, 0x8b, 0x27, 0x81, 0x89,
+    0x01, 0x01, 0x84, 0xb0, 0x20, 0x89, 0x00, 0x8c,
+    0x80, 0x8f, 0x8c, 0xb2, 0xa0, 0x4b, 0x8a, 0x81,
+    0xf0, 0x82, 0xfc, 0x80, 0x8e, 0x80, 0xdf, 0x9f,
+    0xae, 0x80, 0x41, 0xd4, 0x80, 0xa3, 0x1a, 0x24,
+    0x80, 0xdc, 0x85, 0xdc, 0x82, 0x60, 0x6f, 0x15,
+    0x80, 0x44, 0xe1, 0x85, 0x41, 0x0d, 0x80, 0xe1,
+    0x18, 0x89, 0x00, 0x9b, 0x83, 0xcf, 0x81, 0x8d,
+    0xa1, 0xcd, 0x80, 0x96, 0x82, 0xec, 0x0f, 0x02,
+    0x03, 0x80, 0x98, 0x81, 0x40, 0x9c, 0x81, 0x99,
+    0x91, 0x8c, 0x80, 0xa5, 0x87, 0x98, 0x8a, 0xad,
+    0x82, 0xaf, 0x01, 0x19, 0x81, 0x90, 0x80, 0x94,
+    0x81, 0xc1, 0x29, 0x09, 0x81, 0x8b, 0x07, 0x80,
+    0xa2, 0x80, 0x8a, 0x80, 0xb2, 0x00, 0x11, 0x0c,
+    0x08, 0x80, 0x9a, 0x80, 0x8d, 0x0c, 0x08, 0x80,
+    0xe3, 0x84, 0x40, 0x84, 0x01, 0x03, 0x80, 0x60,
+    0x4f, 0x2f, 0x80, 0x40, 0x92, 0x8f, 0x42, 0x3d,
+    0x8f, 0x10, 0x8b, 0x8f, 0xa1, 0x01, 0x80, 0x40,
+    0xa8, 0x06, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00,
+    0x80, 0xae, 0x80, 0xac, 0x81, 0xc2, 0x80, 0x94,
+    0x82, 0x42, 0x00, 0x80, 0x40, 0xe1, 0x80, 0x40,
+    0x94, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0xa7,
+    0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x83,
+    0x42, 0x1d, 0x8a, 0x40, 0xaf, 0x80, 0xb5, 0x8e,
+    0xb7, 0x82, 0xb0, 0x19, 0x09, 0x80, 0x8e, 0x80,
+    0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b,
+    0x81, 0xb3, 0x88, 0x89, 0x83, 0xe1, 0x11, 0x00,
+    0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94, 0x81,
+    0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0x40, 0xc2,
+    0x39, 0x10, 0x80, 0x96, 0x80, 0xd3, 0x28, 0x03,
+    0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81, 0x9a,
+    0x81, 0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00, 0x01,
+    0x28, 0x80, 0xe4, 0x11, 0x18, 0x84, 0x41, 0x02,
+    0x88, 0x01, 0x41, 0x98, 0x19, 0x0b, 0x80, 0x9f,
+    0x89, 0xa7, 0x29, 0x1f, 0x80, 0x88, 0x29, 0x82,
+    0xad, 0x8c, 0x01, 0x41, 0x95, 0x30, 0x28, 0x80,
+    0xd1, 0x95, 0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00,
+    0x08, 0x30, 0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41,
+    0x5a, 0x81, 0x55, 0x3a, 0x88, 0x60, 0x36, 0xb6,
+    0x84, 0xba, 0x86, 0x88, 0x83, 0x44, 0x0a, 0x80,
+    0xbe, 0x90, 0xbf, 0x08, 0x80, 0x60, 0x4c, 0xb8,
+    0x08, 0x83, 0x54, 0xc2, 0x82, 0x88, 0x8f, 0x0e,
+    0x9d, 0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6,
+    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
+    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x41,
+    0x04, 0x8d, 0x41, 0xad, 0x83, 0x45, 0xdf, 0x86,
+    0xec, 0x87, 0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00,
+    0x80, 0x9d, 0xdf, 0xff, 0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_index[63] = {
+static const uint8_t unicode_prop_Case_Ignorable_index[66] = {
     0xc0, 0x05, 0x00, 0x2e, 0x08, 0x20, 0x52, 0x0a,
-    0x00, 0x05, 0x0c, 0x00, 0x4f, 0x0e, 0x20, 0x61,
-    0x10, 0x00, 0x44, 0x18, 0x20, 0x43, 0x1b, 0x20,
-    0xfa, 0x1d, 0x00, 0x7e, 0x2c, 0x20, 0x0d, 0xa6,
-    0x00, 0x52, 0xa9, 0x00, 0xf7, 0xaa, 0x20, 0x41,
-    0xff, 0x40, 0x28, 0x0d, 0x21, 0x3f, 0x12, 0x61,
-    0xc1, 0x15, 0x01, 0x9a, 0x1a, 0x01, 0xa0, 0x6f,
-    0x41, 0x19, 0xe0, 0x61, 0xf0, 0x01, 0x0e,
+    0x00, 0x05, 0x0c, 0x00, 0x4f, 0x0e, 0x20, 0x75,
+    0x10, 0x20, 0x44, 0x18, 0x00, 0x43, 0x1b, 0x00,
+    0x00, 0x1e, 0x00, 0x7e, 0x2c, 0x00, 0x7e, 0xa6,
+    0x40, 0x83, 0xa9, 0x20, 0xf7, 0xaa, 0x00, 0x41,
+    0xff, 0x20, 0x28, 0x0d, 0x01, 0x3f, 0x12, 0x41,
+    0xde, 0x15, 0x21, 0x5c, 0x1a, 0x01, 0xf5, 0x6a,
+    0x21, 0x37, 0xda, 0x01, 0x02, 0x00, 0x2e, 0xf0,
+    0x01, 0x0e,
 };
 
-static const uint8_t unicode_prop_ID_Start_table[1003] = {
+static const uint8_t unicode_prop_ID_Start_table[1024] = {
     0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03,
     0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
     0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20,
@@ -307,124 +313,126 @@ static const uint8_t unicode_prop_ID_Start_table[1003] = {
     0x81, 0x91, 0x38, 0x10, 0xa8, 0x08, 0x8f, 0x04,
     0x17, 0x82, 0x97, 0x2c, 0x91, 0x82, 0x97, 0x80,
     0x88, 0x00, 0x0e, 0xb9, 0xaf, 0x01, 0x8b, 0x86,
-    0xb9, 0x08, 0x01, 0x08, 0x01, 0x05, 0x18, 0x30,
-    0x10, 0x00, 0x01, 0x08, 0x18, 0x81, 0x88, 0x01,
-    0x20, 0x80, 0x94, 0x83, 0x9f, 0x80, 0xbe, 0x38,
-    0xa3, 0x9a, 0x84, 0xf2, 0xaa, 0x93, 0x80, 0x8f,
-    0x2b, 0x1a, 0x02, 0x0e, 0x13, 0x8c, 0x8b, 0x80,
-    0x90, 0xa5, 0x00, 0x20, 0x81, 0xaa, 0x80, 0x41,
-    0x4c, 0x03, 0x0e, 0x00, 0x03, 0x81, 0xa8, 0x03,
-    0x81, 0xa0, 0x03, 0x0e, 0x00, 0x03, 0x81, 0x8e,
-    0x80, 0xb8, 0x03, 0x81, 0xc2, 0xa4, 0x8f, 0x8f,
-    0xd5, 0x0d, 0x82, 0x42, 0x6b, 0x81, 0x90, 0x80,
-    0x99, 0x84, 0xca, 0x82, 0x8a, 0x86, 0x8c, 0x03,
-    0x8d, 0x91, 0x8d, 0x91, 0x8d, 0x8c, 0x02, 0x8e,
-    0xb3, 0xa2, 0x03, 0x80, 0xc2, 0xd8, 0x86, 0xa8,
-    0x00, 0x84, 0xc5, 0x89, 0x9e, 0xb0, 0x9d, 0x0c,
-    0x8a, 0xab, 0x83, 0x99, 0xb5, 0x96, 0x88, 0xb4,
-    0xd1, 0x80, 0xdc, 0xae, 0x90, 0x86, 0xb6, 0x9d,
-    0x8c, 0x81, 0x89, 0xab, 0x99, 0xa3, 0xa8, 0x82,
-    0x89, 0xa3, 0x81, 0x88, 0x86, 0xaa, 0x0a, 0xa8,
-    0x18, 0x1a, 0x81, 0x88, 0x40, 0xbf, 0xbf, 0x41,
-    0x15, 0x0d, 0x81, 0xa5, 0x0d, 0x0f, 0x00, 0x00,
-    0x00, 0x80, 0x9e, 0x81, 0xb4, 0x06, 0x00, 0x12,
-    0x06, 0x13, 0x0d, 0x83, 0x8c, 0x22, 0x06, 0xf3,
-    0x80, 0x8c, 0x80, 0x8f, 0x8c, 0xe4, 0x03, 0x01,
-    0x89, 0x00, 0x0d, 0x28, 0x00, 0x00, 0x80, 0x8f,
-    0x0b, 0x24, 0x18, 0x90, 0xa8, 0x4a, 0x76, 0xae,
-    0x80, 0xae, 0x80, 0x40, 0x84, 0x2b, 0x11, 0x8b,
-    0xa5, 0x00, 0x20, 0x81, 0xb7, 0x30, 0x8f, 0x96,
-    0x88, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-    0x86, 0x42, 0x25, 0x82, 0x98, 0x88, 0x34, 0x0c,
-    0x83, 0xd5, 0x1c, 0x80, 0xd9, 0x03, 0x84, 0xaa,
-    0x80, 0xdd, 0x90, 0x9a, 0xb4, 0x8f, 0x41, 0xff,
-    0x59, 0xb5, 0xc9, 0x60, 0x51, 0xef, 0x8f, 0x44,
-    0x8c, 0xc2, 0xad, 0x81, 0x41, 0x0c, 0x82, 0x8f,
-    0x89, 0x81, 0x93, 0xae, 0x8f, 0x9e, 0x81, 0xcf,
-    0xa6, 0x88, 0x81, 0xe6, 0x81, 0xae, 0xbc, 0x8a,
-    0x02, 0x03, 0x80, 0x96, 0x9c, 0xb3, 0x8d, 0xb1,
-    0xbd, 0x2a, 0x00, 0x81, 0x8a, 0x9b, 0x89, 0x96,
-    0x98, 0x9c, 0x86, 0xae, 0x9b, 0x80, 0x8f, 0x20,
-    0x89, 0x89, 0x20, 0xa8, 0x96, 0x10, 0x87, 0x93,
-    0x96, 0x10, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08,
-    0x00, 0x97, 0x11, 0x8a, 0x32, 0x8b, 0x29, 0x29,
-    0x85, 0x88, 0x30, 0x30, 0xaa, 0x80, 0x89, 0x89,
-    0xf2, 0x9c, 0x60, 0x2b, 0xa3, 0x8b, 0x96, 0x83,
-    0xb0, 0x60, 0x21, 0x03, 0x41, 0x6d, 0x81, 0xe9,
-    0xa5, 0x86, 0x8b, 0x24, 0x00, 0x89, 0x80, 0x8c,
-    0x04, 0x00, 0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41,
-    0x6a, 0x91, 0xbf, 0x81, 0xb5, 0xa7, 0x8b, 0xf3,
-    0x20, 0x40, 0x86, 0xa3, 0x99, 0x85, 0x99, 0x8a,
-    0xd8, 0x15, 0x0d, 0x0d, 0x0a, 0xa2, 0x8b, 0x80,
-    0x99, 0x80, 0x92, 0x01, 0x80, 0x8e, 0x81, 0x8d,
-    0xa1, 0xfa, 0xc4, 0xb4, 0x41, 0x0a, 0x9c, 0x82,
-    0xb0, 0xae, 0x9f, 0x8c, 0x9d, 0x84, 0xa5, 0x89,
-    0x9d, 0x81, 0xa3, 0x1f, 0x04, 0xa9, 0x40, 0x9d,
-    0x91, 0xa3, 0x83, 0xa3, 0x83, 0xa7, 0x87, 0xb3,
-    0x40, 0x9b, 0x41, 0x36, 0x88, 0x95, 0x89, 0x87,
-    0x40, 0x97, 0x29, 0x00, 0xab, 0x01, 0x10, 0x81,
-    0x96, 0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92, 0x01,
-    0x89, 0x95, 0x89, 0x99, 0xc5, 0xb7, 0x29, 0xbf,
-    0x80, 0x8e, 0x18, 0x10, 0x9c, 0xa9, 0x9c, 0x82,
-    0x9c, 0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89, 0x95,
-    0x89, 0x92, 0x8c, 0x91, 0xed, 0xc8, 0xb6, 0xb2,
-    0x8c, 0xb2, 0x8c, 0xa3, 0x41, 0xdb, 0x9c, 0x89,
-    0x07, 0x95, 0x40, 0xbc, 0xb4, 0xca, 0xac, 0x9f,
-    0x98, 0x99, 0xa3, 0x9c, 0x80, 0x8a, 0xa2, 0x10,
-    0x8b, 0xaf, 0x8d, 0x83, 0x94, 0x00, 0x80, 0xa2,
-    0x91, 0x80, 0x98, 0xd3, 0x30, 0x00, 0x18, 0x8e,
-    0x80, 0x89, 0x86, 0xae, 0xa5, 0x39, 0x09, 0x95,
-    0x06, 0x01, 0x04, 0x10, 0x91, 0x80, 0x8b, 0x84,
-    0x40, 0x9d, 0xb4, 0x91, 0x83, 0xb4, 0xaf, 0x93,
+    0xb9, 0x08, 0x00, 0x20, 0x97, 0x00, 0x80, 0x89,
+    0x01, 0x88, 0x01, 0x20, 0x80, 0x94, 0x83, 0x9f,
+    0x80, 0xbe, 0x38, 0xa3, 0x9a, 0x84, 0xf2, 0xaa,
+    0x93, 0x80, 0x8f, 0x2b, 0x1a, 0x02, 0x0e, 0x13,
+    0x8c, 0x8b, 0x80, 0x90, 0xa5, 0x00, 0x20, 0x81,
+    0xaa, 0x80, 0x41, 0x4c, 0x03, 0x0e, 0x00, 0x03,
+    0x81, 0xa8, 0x03, 0x81, 0xa0, 0x03, 0x0e, 0x00,
+    0x03, 0x81, 0x8e, 0x80, 0xb8, 0x03, 0x81, 0xc2,
+    0xa4, 0x8f, 0x8f, 0xd5, 0x0d, 0x82, 0x42, 0x6b,
+    0x81, 0x90, 0x80, 0x99, 0x84, 0xca, 0x82, 0x8a,
+    0x86, 0x8c, 0x03, 0x8d, 0x91, 0x8d, 0x91, 0x8d,
+    0x8c, 0x02, 0x8e, 0xb3, 0xa2, 0x03, 0x80, 0xc2,
+    0xd8, 0x86, 0xa8, 0x00, 0x84, 0xc5, 0x89, 0x9e,
+    0xb0, 0x9d, 0x0c, 0x8a, 0xab, 0x83, 0x99, 0xb5,
+    0x96, 0x88, 0xb4, 0xd1, 0x80, 0xdc, 0xae, 0x90,
+    0x86, 0xb6, 0x9d, 0x8c, 0x81, 0x89, 0xab, 0x99,
+    0xa3, 0xa8, 0x82, 0x89, 0xa3, 0x81, 0x88, 0x86,
+    0xaa, 0x0a, 0xa8, 0x18, 0x28, 0x0a, 0x04, 0x40,
+    0xbf, 0xbf, 0x41, 0x15, 0x0d, 0x81, 0xa5, 0x0d,
+    0x0f, 0x00, 0x00, 0x00, 0x80, 0x9e, 0x81, 0xb4,
+    0x06, 0x00, 0x12, 0x06, 0x13, 0x0d, 0x83, 0x8c,
+    0x22, 0x06, 0xf3, 0x80, 0x8c, 0x80, 0x8f, 0x8c,
+    0xe4, 0x03, 0x01, 0x89, 0x00, 0x0d, 0x28, 0x00,
+    0x00, 0x80, 0x8f, 0x0b, 0x24, 0x18, 0x90, 0xa8,
+    0x4a, 0x76, 0xae, 0x80, 0xae, 0x80, 0x40, 0x84,
+    0x2b, 0x11, 0x8b, 0xa5, 0x00, 0x20, 0x81, 0xb7,
+    0x30, 0x8f, 0x96, 0x88, 0x30, 0x30, 0x30, 0x30,
+    0x30, 0x30, 0x30, 0x86, 0x42, 0x25, 0x82, 0x98,
+    0x88, 0x34, 0x0c, 0x83, 0xd5, 0x1c, 0x80, 0xd9,
+    0x03, 0x84, 0xaa, 0x80, 0xdd, 0x90, 0x9a, 0xb4,
+    0x8f, 0x41, 0xff, 0x59, 0xb5, 0xc9, 0x60, 0x51,
+    0xef, 0x8f, 0x44, 0x8c, 0xc2, 0xad, 0x81, 0x41,
+    0x0c, 0x82, 0x8f, 0x89, 0x81, 0x93, 0xae, 0x8f,
+    0x9e, 0x81, 0xcf, 0xa6, 0x88, 0x81, 0xe6, 0x81,
+    0xb4, 0x0c, 0xaf, 0x8a, 0x02, 0x03, 0x80, 0x96,
+    0x9c, 0xb3, 0x8d, 0xb1, 0xbd, 0x2a, 0x00, 0x81,
+    0x8a, 0x9b, 0x89, 0x96, 0x98, 0x9c, 0x86, 0xae,
+    0x9b, 0x80, 0x8f, 0x20, 0x89, 0x89, 0x20, 0xa8,
+    0x96, 0x10, 0x87, 0x93, 0x96, 0x10, 0x82, 0xb1,
+    0x00, 0x11, 0x0c, 0x08, 0x00, 0x97, 0x11, 0x8a,
+    0x32, 0x8b, 0x29, 0x29, 0x85, 0x88, 0x30, 0x30,
+    0xaa, 0x80, 0x8b, 0x87, 0xf2, 0x9c, 0x60, 0x2b,
+    0xa3, 0x8b, 0x96, 0x83, 0xb0, 0x60, 0x21, 0x03,
+    0x41, 0x6d, 0x81, 0xe9, 0xa5, 0x86, 0x8b, 0x24,
+    0x00, 0x89, 0x80, 0x8c, 0x04, 0x00, 0x01, 0x01,
+    0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81,
+    0xb5, 0xa7, 0x8b, 0xf3, 0x20, 0x40, 0x86, 0xa3,
+    0x99, 0x85, 0x99, 0x8a, 0xd8, 0x15, 0x0d, 0x0d,
+    0x0a, 0xa2, 0x8b, 0x80, 0x99, 0x80, 0x92, 0x01,
+    0x80, 0x8e, 0x81, 0x8d, 0xa1, 0xfa, 0xc4, 0xb4,
+    0x41, 0x0a, 0x9c, 0x82, 0xb0, 0xae, 0x9f, 0x8c,
+    0x9d, 0x84, 0xa5, 0x89, 0x9d, 0x81, 0xa3, 0x1f,
+    0x04, 0xa9, 0x40, 0x9d, 0x91, 0xa3, 0x83, 0xa3,
+    0x83, 0xa7, 0x87, 0xb3, 0x40, 0x9b, 0x41, 0x36,
+    0x88, 0x95, 0x89, 0x87, 0x40, 0x97, 0x29, 0x00,
+    0xab, 0x01, 0x10, 0x81, 0x96, 0x89, 0x96, 0x88,
+    0x9e, 0xc0, 0x92, 0x01, 0x89, 0x95, 0x89, 0x99,
+    0xc5, 0xb7, 0x29, 0xbf, 0x80, 0x8e, 0x18, 0x10,
+    0x9c, 0xa9, 0x9c, 0x82, 0x9c, 0xa2, 0x38, 0x9b,
+    0x9a, 0xb5, 0x89, 0x95, 0x89, 0x92, 0x8c, 0x91,
+    0xed, 0xc8, 0xb6, 0xb2, 0x8c, 0xb2, 0x8c, 0xa3,
+    0x41, 0xdb, 0x9c, 0x89, 0x07, 0x95, 0x40, 0x99,
+    0x96, 0x8b, 0xb4, 0xca, 0xac, 0x9f, 0x98, 0x99,
+    0xa3, 0x9c, 0x80, 0x8a, 0xa2, 0x10, 0x8b, 0xaf,
+    0x8d, 0x83, 0x94, 0x00, 0x80, 0xa2, 0x91, 0x80,
+    0x98, 0xd3, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89,
+    0x86, 0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01,
+    0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d,
+    0xb4, 0x91, 0x83, 0x93, 0x80, 0x9f, 0xaf, 0x93,
     0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3,
-    0xaf, 0x93, 0x80, 0xba, 0xaa, 0xd4, 0x9a, 0x40,
-    0xe4, 0xab, 0xf3, 0xbf, 0x9e, 0x80, 0x40, 0xff,
-    0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xa7,
-    0x0b, 0x92, 0x80, 0xa1, 0xb8, 0x41, 0x06, 0x88,
-    0x80, 0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef, 0x30,
-    0x08, 0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f,
-    0x8d, 0x80, 0x41, 0x46, 0x92, 0x41, 0x0c, 0x43,
-    0x99, 0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0xbb,
-    0x44, 0x2e, 0x4f, 0xd0, 0x42, 0x46, 0x60, 0x21,
-    0xb8, 0x42, 0x38, 0x86, 0x9e, 0xf0, 0x9d, 0x91,
-    0xaf, 0x8f, 0x83, 0x9e, 0x94, 0x84, 0x92, 0x42,
-    0xaf, 0xbf, 0xff, 0xc4, 0x8a, 0x80, 0xc1, 0x8c,
-    0xbf, 0x81, 0x9d, 0x57, 0xf1, 0x8d, 0x42, 0xf2,
-    0x60, 0x25, 0x0c, 0x41, 0x1e, 0xd0, 0x41, 0x8b,
-    0x49, 0x03, 0xea, 0x84, 0x8c, 0x82, 0x88, 0x86,
-    0x89, 0x57, 0x65, 0xd4, 0x80, 0xc6, 0x01, 0x08,
-    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
-    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
-    0x16, 0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98,
-    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
-    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
-    0x07, 0x50, 0x33, 0x40, 0xc4, 0xba, 0xc3, 0x44,
-    0xbb, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89,
-    0x03, 0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02,
-    0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
-    0x00, 0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89,
-    0x80, 0x90, 0x22, 0x04, 0x80, 0x90, 0x51, 0x43,
-    0x60, 0xa6, 0xd6, 0xa8, 0x50, 0x34, 0x8a, 0x40,
-    0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c,
-    0x1e, 0x42, 0x1d,
+    0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6,
+    0x9a, 0x40, 0xe4, 0xab, 0xf3, 0xbf, 0x9e, 0x80,
+    0x40, 0x9f, 0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b,
+    0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad,
+    0x92, 0x80, 0xa1, 0xb8, 0x41, 0x06, 0x88, 0x80,
+    0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08,
+    0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d,
+    0x80, 0x41, 0x46, 0x92, 0x41, 0x0c, 0x43, 0x99,
+    0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0xbb, 0x44,
+    0x2e, 0x4f, 0xd0, 0x42, 0x46, 0x60, 0x21, 0xb8,
+    0x42, 0x38, 0x86, 0x9e, 0xf0, 0x9d, 0x91, 0xaf,
+    0x8f, 0x83, 0x9e, 0x94, 0x84, 0x92, 0x42, 0xaf,
+    0xbf, 0xff, 0xca, 0x20, 0xc1, 0x8c, 0xbf, 0x08,
+    0x80, 0x9b, 0x57, 0xf7, 0x87, 0x42, 0xf2, 0x60,
+    0x25, 0x0c, 0x41, 0x1e, 0xb0, 0x82, 0x90, 0x1f,
+    0x41, 0x8b, 0x49, 0x03, 0xea, 0x84, 0x8c, 0x82,
+    0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80, 0xc6,
+    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
+    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
+    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x98,
+    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
+    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
+    0x80, 0x98, 0x07, 0x49, 0x33, 0xac, 0x89, 0x86,
+    0x8f, 0x80, 0x41, 0x70, 0xab, 0x45, 0x13, 0x40,
+    0xc4, 0xba, 0xc3, 0x30, 0x44, 0xb3, 0x18, 0x9a,
+    0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00,
+    0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06,
+    0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22,
+    0x04, 0x80, 0x90, 0x51, 0x43, 0x60, 0xa6, 0xd6,
+    0xa8, 0x50, 0x34, 0x8a, 0x40, 0xdd, 0x81, 0x56,
+    0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d,
 };
 
 static const uint8_t unicode_prop_ID_Start_index[96] = {
     0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xb1, 0x09,
     0x00, 0xba, 0x0a, 0x00, 0xd1, 0x0b, 0x20, 0x62,
-    0x0d, 0x40, 0xc7, 0x0e, 0x40, 0x49, 0x12, 0x20,
-    0x9b, 0x16, 0x20, 0x75, 0x19, 0x00, 0xf7, 0x1c,
-    0x60, 0x72, 0x20, 0x20, 0x26, 0x2d, 0x20, 0x30,
-    0x31, 0x00, 0xf0, 0xa6, 0x00, 0xf0, 0xa9, 0x20,
-    0xe3, 0xab, 0x20, 0x3e, 0xfd, 0x20, 0x5e, 0x00,
-    0x01, 0x64, 0x05, 0x01, 0x01, 0x0a, 0x21, 0x46,
-    0x0f, 0x41, 0x9e, 0x12, 0x01, 0x30, 0x16, 0x21,
-    0x09, 0x1c, 0x01, 0x2f, 0x34, 0x41, 0xa0, 0x6f,
-    0x01, 0xa3, 0xd4, 0x01, 0x4f, 0xd7, 0x01, 0x50,
-    0xee, 0x01, 0x1e, 0xb8, 0x22, 0x1e, 0xfa, 0x02,
+    0x0d, 0x40, 0x01, 0x0f, 0x20, 0x5e, 0x12, 0x00,
+    0xf9, 0x16, 0x00, 0x17, 0x1a, 0x20, 0xc0, 0x1d,
+    0x20, 0x9d, 0x20, 0x00, 0x68, 0x2d, 0x00, 0x00,
+    0x32, 0x20, 0xc0, 0xa7, 0x20, 0x29, 0xaa, 0x00,
+    0xa4, 0xd7, 0x20, 0xc8, 0xfd, 0x20, 0x75, 0x01,
+    0x01, 0x37, 0x07, 0x01, 0x36, 0x0a, 0x21, 0xf7,
+    0x0f, 0x21, 0xa9, 0x12, 0x01, 0x30, 0x16, 0x21,
+    0x8a, 0x1a, 0x01, 0x9a, 0x23, 0x01, 0x80, 0x6e,
+    0x21, 0x89, 0xbc, 0x21, 0xc1, 0xd6, 0x01, 0xc5,
+    0xe8, 0x21, 0x73, 0xee, 0x01, 0x1e, 0xfa, 0x02,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_table[596] = {
+static const uint8_t unicode_prop_ID_Continue1_table[607] = {
     0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47,
     0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
     0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf,
@@ -446,76 +454,77 @@ static const uint8_t unicode_prop_ID_Continue1_table[596] = {
     0x10, 0x83, 0x88, 0x80, 0x89, 0x09, 0x89, 0x91,
     0x81, 0xc5, 0x03, 0x28, 0x00, 0x3d, 0x89, 0x09,
     0xbc, 0x01, 0x86, 0x8b, 0x38, 0x89, 0xd6, 0x01,
-    0x28, 0x81, 0x8a, 0x29, 0x89, 0xbd, 0x0d, 0x89,
-    0x8a, 0x00, 0x00, 0x03, 0x81, 0xb0, 0x93, 0x01,
-    0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe3, 0x93,
-    0x80, 0x89, 0x8b, 0x1b, 0x10, 0x11, 0x32, 0x83,
-    0x8c, 0x8b, 0x80, 0x8e, 0x42, 0xbe, 0x82, 0x88,
-    0x88, 0x43, 0x9f, 0x82, 0x9c, 0x82, 0x9c, 0x81,
-    0x9d, 0x81, 0xbf, 0x9f, 0x88, 0x01, 0x89, 0xa0,
-    0x11, 0x89, 0x40, 0x8e, 0x80, 0xf5, 0x8b, 0x83,
-    0x8b, 0x89, 0x89, 0xff, 0x8a, 0xbb, 0x84, 0xb8,
-    0x89, 0x80, 0x9c, 0x81, 0x8a, 0x85, 0x89, 0x95,
-    0x8d, 0xc1, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90,
-    0x88, 0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab,
-    0x8d, 0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5,
-    0x10, 0x94, 0x18, 0x1a, 0x0a, 0x40, 0xc5, 0xb9,
-    0x04, 0x42, 0x3e, 0x81, 0x92, 0x80, 0xfa, 0x8c,
-    0x18, 0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c,
-    0x80, 0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81,
-    0x60, 0x75, 0x84, 0x89, 0xc4, 0x03, 0x89, 0x9f,
-    0x81, 0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80,
-    0x96, 0x84, 0xd7, 0x81, 0xb1, 0x91, 0x89, 0x89,
-    0x85, 0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98, 0x8c,
-    0xab, 0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a, 0x80,
-    0x89, 0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09, 0x89,
-    0xa0, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x80,
-    0xa8, 0x24, 0x81, 0x40, 0xeb, 0x38, 0x09, 0x89,
-    0x60, 0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f, 0x8f,
-    0x8f, 0x11, 0x97, 0x82, 0x40, 0xbf, 0x89, 0xa4,
-    0x80, 0x42, 0xbc, 0x80, 0x40, 0xe1, 0x80, 0x40,
-    0x94, 0x84, 0x41, 0x24, 0x89, 0x45, 0x56, 0x10,
-    0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4, 0x81,
-    0x42, 0x3c, 0x1f, 0x89, 0x42, 0x0b, 0x8a, 0x40,
-    0xae, 0x82, 0xb4, 0x8e, 0x9e, 0x89, 0x8e, 0x83,
-    0xac, 0x8a, 0xb4, 0x89, 0x2a, 0xa3, 0x8d, 0x80,
-    0x89, 0x21, 0xab, 0x80, 0x8b, 0x82, 0xaf, 0x8d,
-    0x3b, 0x82, 0x89, 0xd1, 0x8b, 0x28, 0x40, 0x9f,
-    0x8b, 0x84, 0x89, 0x2b, 0xb6, 0x08, 0x31, 0x09,
-    0x82, 0x88, 0x80, 0x89, 0x09, 0x32, 0x84, 0x40,
-    0xbf, 0x91, 0x88, 0x89, 0x18, 0xd0, 0x93, 0x8b,
-    0x89, 0x40, 0xd4, 0x31, 0x88, 0x9a, 0x81, 0xd1,
-    0x90, 0x8e, 0x89, 0xd0, 0x8c, 0x87, 0x89, 0xd2,
-    0x8e, 0x83, 0x89, 0x40, 0xf1, 0x8e, 0x40, 0xa4,
-    0x89, 0x41, 0x16, 0x89, 0xa7, 0x30, 0x1f, 0x80,
-    0x88, 0x8a, 0xad, 0x8f, 0x41, 0x94, 0x38, 0x87,
-    0x8f, 0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a,
-    0x00, 0x08, 0x30, 0x07, 0x89, 0xaf, 0x20, 0x08,
-    0x27, 0x89, 0x41, 0x48, 0x83, 0x60, 0x4b, 0x68,
-    0x89, 0x40, 0x85, 0x84, 0xba, 0x86, 0x98, 0x89,
-    0x43, 0xf6, 0xad, 0x8f, 0x83, 0x60, 0x4d, 0x09,
-    0x81, 0x54, 0xc5, 0x22, 0x2f, 0x39, 0x86, 0x9d,
-    0x83, 0x40, 0x93, 0x82, 0x45, 0x88, 0xb1, 0x41,
-    0xff, 0xb6, 0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95,
-    0x20, 0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01,
-    0x04, 0x48, 0xa4, 0x86, 0xec, 0x34, 0x89, 0x6c,
-    0x17, 0xa5, 0x40, 0xef,
+    0x88, 0x8a, 0x29, 0x89, 0xbd, 0x0d, 0x89, 0x8a,
+    0x00, 0x00, 0x03, 0x81, 0xb0, 0x93, 0x01, 0x84,
+    0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe3, 0x93, 0x80,
+    0x89, 0x8b, 0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c,
+    0x8b, 0x80, 0x8e, 0x42, 0xbe, 0x82, 0x88, 0x88,
+    0x43, 0x9f, 0x82, 0x9c, 0x82, 0x9c, 0x81, 0x9d,
+    0x81, 0xbf, 0x9f, 0x88, 0x01, 0x89, 0xa0, 0x11,
+    0x89, 0x40, 0x8e, 0x80, 0xf5, 0x8b, 0x83, 0x8b,
+    0x89, 0x89, 0xff, 0x8a, 0xbb, 0x84, 0xb8, 0x89,
+    0x80, 0x9c, 0x81, 0x8a, 0x85, 0x89, 0x95, 0x8d,
+    0xc1, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90, 0x88,
+    0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab, 0x8d,
+    0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5, 0x10,
+    0x94, 0x18, 0x28, 0x0a, 0x40, 0xc5, 0xb9, 0x04,
+    0x42, 0x3e, 0x81, 0x92, 0x80, 0xfa, 0x8c, 0x18,
+    0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c, 0x80,
+    0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81, 0x60,
+    0x75, 0x84, 0x89, 0xc4, 0x03, 0x89, 0x9f, 0x81,
+    0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80, 0x96,
+    0x84, 0xd7, 0x81, 0xb1, 0x91, 0x89, 0x89, 0x85,
+    0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98, 0x8c, 0xab,
+    0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a, 0x80, 0x89,
+    0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09, 0x89, 0xa0,
+    0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x80, 0xa8,
+    0x24, 0x81, 0x40, 0xeb, 0x38, 0x09, 0x89, 0x60,
+    0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f, 0x8f, 0x8f,
+    0x11, 0x97, 0x82, 0x40, 0xbf, 0x89, 0xa4, 0x80,
+    0x42, 0xbc, 0x80, 0x40, 0xe1, 0x80, 0x40, 0x94,
+    0x84, 0x41, 0x24, 0x89, 0x45, 0x56, 0x10, 0x0c,
+    0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4, 0x81, 0x42,
+    0x3c, 0x1f, 0x89, 0x42, 0x0b, 0x8a, 0x40, 0xae,
+    0x82, 0xb4, 0x8e, 0x9e, 0x89, 0x8e, 0x83, 0xac,
+    0x8a, 0xb4, 0x89, 0x2a, 0xa3, 0x8d, 0x80, 0x89,
+    0x21, 0xab, 0x80, 0x8b, 0x82, 0xaf, 0x8d, 0x3b,
+    0x82, 0x89, 0xd1, 0x8b, 0x28, 0x40, 0x9f, 0x8b,
+    0x84, 0x89, 0x2b, 0xb6, 0x08, 0x31, 0x09, 0x82,
+    0x88, 0x80, 0x89, 0x09, 0x32, 0x84, 0x40, 0xbf,
+    0x91, 0x88, 0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89,
+    0x40, 0xd4, 0x31, 0x88, 0x9a, 0x81, 0xd1, 0x90,
+    0x8e, 0x89, 0xd0, 0x8c, 0x87, 0x89, 0xd2, 0x8e,
+    0x83, 0x89, 0x40, 0xf1, 0x8e, 0x40, 0xa4, 0x89,
+    0x40, 0xe6, 0x31, 0x32, 0x80, 0x9b, 0x89, 0xa7,
+    0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad, 0x8f, 0x41,
+    0x94, 0x38, 0x87, 0x8f, 0x89, 0xb7, 0x95, 0x80,
+    0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x07, 0x89,
+    0xaf, 0x20, 0x08, 0x27, 0x89, 0x41, 0x48, 0x83,
+    0x60, 0x4b, 0x68, 0x89, 0x40, 0x85, 0x84, 0xba,
+    0x86, 0x98, 0x89, 0x43, 0xf4, 0x00, 0xb6, 0x33,
+    0x60, 0x4d, 0x09, 0x81, 0x54, 0xc5, 0x22, 0x2f,
+    0x39, 0x86, 0x9d, 0x83, 0x40, 0x93, 0x82, 0x45,
+    0x88, 0xb1, 0x41, 0xff, 0xb6, 0x83, 0xb1, 0x38,
+    0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f, 0x30,
+    0x90, 0x0e, 0x01, 0x04, 0x41, 0x04, 0x86, 0x88,
+    0x89, 0x41, 0xa1, 0x8d, 0x45, 0xd5, 0x86, 0xec,
+    0x34, 0x89, 0x6c, 0x17, 0xa5, 0x40, 0xef,
 };
 
 static const uint8_t unicode_prop_ID_Continue1_index[57] = {
     0xfa, 0x06, 0x00, 0x84, 0x09, 0x00, 0xf0, 0x0a,
-    0x00, 0x70, 0x0c, 0x00, 0xf4, 0x0d, 0x00, 0x3f,
-    0x10, 0x00, 0x1a, 0x18, 0x40, 0x74, 0x1b, 0x20,
-    0xdd, 0x20, 0x00, 0x0c, 0xa8, 0x00, 0x5a, 0xaa,
-    0x00, 0x40, 0xff, 0x20, 0x03, 0x10, 0x41, 0xeb,
-    0x12, 0x21, 0x41, 0x16, 0x21, 0x40, 0x1c, 0x01,
-    0x5a, 0x6b, 0x01, 0xb0, 0xda, 0x41, 0xf0, 0x01,
+    0x00, 0x70, 0x0c, 0x00, 0xf4, 0x0d, 0x00, 0x4a,
+    0x10, 0x20, 0x1a, 0x18, 0x20, 0x74, 0x1b, 0x00,
+    0xe2, 0x20, 0x00, 0x28, 0xa8, 0x20, 0x7e, 0xaa,
+    0x20, 0x40, 0xff, 0x00, 0x03, 0x10, 0x21, 0xeb,
+    0x12, 0x01, 0x41, 0x16, 0x01, 0x40, 0x1c, 0x61,
+    0x37, 0x6b, 0x21, 0x76, 0xda, 0x01, 0xf0, 0x01,
     0x0e,
 };
 
 #ifdef CONFIG_ALL_UNICODE
 
-static const uint8_t unicode_cc_table[820] = {
+static const uint8_t unicode_cc_table[831] = {
     0xb2, 0xcf, 0xd4, 0x00, 0xe8, 0x03, 0xdc, 0x00,
     0xe8, 0x00, 0xd8, 0x04, 0xdc, 0x01, 0xca, 0x03,
     0xdc, 0x01, 0xca, 0x0a, 0xdc, 0x04, 0x01, 0x03,
@@ -553,88 +562,89 @@ static const uint8_t unicode_cc_table[820] = {
     0x8f, 0x00, 0x09, 0xb0, 0x3c, 0x01, 0x09, 0x8f,
     0x00, 0x09, 0xb0, 0x4b, 0x00, 0x09, 0xb0, 0x3c,
     0x01, 0x67, 0x00, 0x09, 0x8c, 0x03, 0x6b, 0xb0,
-    0x3b, 0x01, 0x76, 0x8d, 0x03, 0x7a, 0xb0, 0x1b,
-    0x01, 0xdc, 0x9a, 0x00, 0xdc, 0x80, 0x00, 0xdc,
-    0x80, 0x00, 0xd8, 0xb0, 0x06, 0x41, 0x81, 0x80,
-    0x00, 0x84, 0x84, 0x03, 0x82, 0x81, 0x00, 0x82,
-    0x80, 0xc1, 0x00, 0x09, 0x80, 0xc1, 0xb0, 0x0d,
-    0x00, 0xdc, 0xb0, 0x3f, 0x00, 0x07, 0x80, 0x01,
-    0x09, 0xb0, 0x21, 0x00, 0xdc, 0xb2, 0x9e, 0xc2,
-    0xb3, 0x83, 0x00, 0x09, 0x9e, 0x00, 0x09, 0xb0,
-    0x6c, 0x00, 0x09, 0x89, 0xc0, 0xb0, 0x9a, 0x00,
-    0xe4, 0xb0, 0x5e, 0x00, 0xde, 0xc0, 0x00, 0xdc,
-    0xb0, 0xaa, 0xc0, 0x00, 0xdc, 0xb0, 0x16, 0x00,
-    0x09, 0x93, 0xc7, 0x81, 0x00, 0xdc, 0xaf, 0xc4,
-    0x05, 0xdc, 0xc1, 0x00, 0xdc, 0xb0, 0x45, 0x00,
-    0x07, 0x8e, 0x00, 0x09, 0xa5, 0xc0, 0x00, 0xdc,
-    0xc6, 0xb0, 0x05, 0x01, 0x09, 0xb0, 0x09, 0x00,
-    0x07, 0x8a, 0x01, 0x09, 0xb0, 0x12, 0x00, 0x07,
-    0xb0, 0x67, 0xc2, 0x41, 0x00, 0x04, 0xdc, 0xc1,
-    0x03, 0xdc, 0xc0, 0x41, 0x00, 0x05, 0x01, 0x83,
-    0x00, 0xdc, 0x85, 0xc0, 0x82, 0xc1, 0xb0, 0x95,
-    0xc1, 0x00, 0xdc, 0xc6, 0x00, 0xdc, 0xc1, 0x00,
-    0xea, 0x00, 0xd6, 0x00, 0xdc, 0x00, 0xca, 0xe4,
-    0x00, 0xe8, 0x01, 0xe4, 0x00, 0xdc, 0x80, 0xc0,
-    0x00, 0xe9, 0x00, 0xdc, 0xc0, 0x00, 0xdc, 0xb2,
-    0x9f, 0xc1, 0x01, 0x01, 0xc3, 0x02, 0x01, 0xc1,
-    0x83, 0xc0, 0x82, 0x01, 0x01, 0xc0, 0x00, 0xdc,
-    0xc0, 0x01, 0x01, 0x03, 0xdc, 0xc0, 0xb8, 0x03,
-    0xcd, 0xc2, 0xb0, 0x5c, 0x00, 0x09, 0xb0, 0x2f,
-    0xdf, 0xb1, 0xf9, 0x00, 0xda, 0x00, 0xe4, 0x00,
-    0xe8, 0x00, 0xde, 0x01, 0xe0, 0xb0, 0x38, 0x01,
-    0x08, 0xb8, 0x6d, 0xa3, 0xc0, 0x83, 0xc9, 0x9f,
-    0xc1, 0xb0, 0x1f, 0xc1, 0xb0, 0xe3, 0x00, 0x09,
-    0xb0, 0x8c, 0x00, 0x09, 0x9a, 0xd1, 0xb0, 0x08,
-    0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0, 0x2e, 0x00,
-    0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe, 0xc0, 0x80,
-    0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84, 0xc1, 0x80,
-    0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0, 0xc5, 0x00,
-    0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a, 0xb2, 0xd0,
-    0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c, 0x00, 0xdc,
-    0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64, 0xc4, 0xb6,
-    0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0, 0x00,
-    0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0, 0x74,
-    0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1, 0xed,
-    0x01, 0xdc, 0xc2, 0x00, 0xdc, 0xc0, 0x03, 0xdc,
-    0xb0, 0xc4, 0x00, 0x09, 0xb0, 0x07, 0x00, 0x09,
-    0xb0, 0x08, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x14,
-    0xc2, 0xaf, 0x01, 0x09, 0xb0, 0x0d, 0x00, 0x07,
-    0xb0, 0x1b, 0x00, 0x09, 0x88, 0x00, 0x07, 0xb0,
-    0x39, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x81, 0x00,
-    0x07, 0x00, 0x09, 0xb0, 0x1f, 0x01, 0x07, 0x8f,
-    0x00, 0x09, 0x97, 0xc6, 0x82, 0xc4, 0xb0, 0x9c,
-    0x00, 0x09, 0x82, 0x00, 0x07, 0x96, 0xc0, 0xb0,
-    0x32, 0x00, 0x09, 0x00, 0x07, 0xb0, 0xca, 0x00,
-    0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00, 0x09, 0xb0,
-    0x45, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x42, 0x00,
-    0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00, 0x07, 0xb1,
-    0xc8, 0x00, 0x09, 0x91, 0x00, 0x09, 0xb0, 0x20,
-    0x00, 0x09, 0xb1, 0x74, 0x00, 0x09, 0xb0, 0xd1,
-    0x00, 0x07, 0x80, 0x01, 0x09, 0xb0, 0x20, 0x00,
-    0x09, 0xb8, 0x45, 0x27, 0x04, 0x01, 0xb0, 0x0a,
-    0xc6, 0xb8, 0x49, 0x36, 0x00, 0x01, 0xb8, 0x0c,
-    0x95, 0x01, 0xd8, 0x02, 0x01, 0x82, 0x00, 0xe2,
-    0x04, 0xd8, 0x87, 0x07, 0xdc, 0x81, 0xc4, 0x01,
-    0xdc, 0x9d, 0xc3, 0xb0, 0x63, 0xc2, 0xb8, 0x05,
-    0x8a, 0xc6, 0x80, 0xd0, 0x81, 0xc6, 0x80, 0xc1,
-    0x80, 0xc4, 0xb8, 0x00, 0x74, 0x06, 0xdc, 0xb0,
-    0x3c, 0xc5, 0x00, 0x07,
+    0x3b, 0x01, 0x76, 0x00, 0x09, 0x8c, 0x03, 0x7a,
+    0xb0, 0x1b, 0x01, 0xdc, 0x9a, 0x00, 0xdc, 0x80,
+    0x00, 0xdc, 0x80, 0x00, 0xd8, 0xb0, 0x06, 0x41,
+    0x81, 0x80, 0x00, 0x84, 0x84, 0x03, 0x82, 0x81,
+    0x00, 0x82, 0x80, 0xc1, 0x00, 0x09, 0x80, 0xc1,
+    0xb0, 0x0d, 0x00, 0xdc, 0xb0, 0x3f, 0x00, 0x07,
+    0x80, 0x01, 0x09, 0xb0, 0x21, 0x00, 0xdc, 0xb2,
+    0x9e, 0xc2, 0xb3, 0x83, 0x00, 0x09, 0x9e, 0x00,
+    0x09, 0xb0, 0x6c, 0x00, 0x09, 0x89, 0xc0, 0xb0,
+    0x9a, 0x00, 0xe4, 0xb0, 0x5e, 0x00, 0xde, 0xc0,
+    0x00, 0xdc, 0xb0, 0xaa, 0xc0, 0x00, 0xdc, 0xb0,
+    0x16, 0x00, 0x09, 0x93, 0xc7, 0x81, 0x00, 0xdc,
+    0xaf, 0xc4, 0x05, 0xdc, 0xc1, 0x00, 0xdc, 0xb0,
+    0x45, 0x00, 0x07, 0x8e, 0x00, 0x09, 0xa5, 0xc0,
+    0x00, 0xdc, 0xc6, 0xb0, 0x05, 0x01, 0x09, 0xb0,
+    0x09, 0x00, 0x07, 0x8a, 0x01, 0x09, 0xb0, 0x12,
+    0x00, 0x07, 0xb0, 0x67, 0xc2, 0x41, 0x00, 0x04,
+    0xdc, 0xc1, 0x03, 0xdc, 0xc0, 0x41, 0x00, 0x05,
+    0x01, 0x83, 0x00, 0xdc, 0x85, 0xc0, 0x82, 0xc1,
+    0xb0, 0x95, 0xc1, 0x00, 0xdc, 0xc6, 0x00, 0xdc,
+    0xc1, 0x00, 0xea, 0x00, 0xd6, 0x00, 0xdc, 0x00,
+    0xca, 0xe4, 0x00, 0xe8, 0x01, 0xe4, 0x00, 0xdc,
+    0x80, 0xc0, 0x00, 0xe9, 0x00, 0xdc, 0xc0, 0x00,
+    0xdc, 0xb2, 0x9f, 0xc1, 0x01, 0x01, 0xc3, 0x02,
+    0x01, 0xc1, 0x83, 0xc0, 0x82, 0x01, 0x01, 0xc0,
+    0x00, 0xdc, 0xc0, 0x01, 0x01, 0x03, 0xdc, 0xc0,
+    0xb8, 0x03, 0xcd, 0xc2, 0xb0, 0x5c, 0x00, 0x09,
+    0xb0, 0x2f, 0xdf, 0xb1, 0xf9, 0x00, 0xda, 0x00,
+    0xe4, 0x00, 0xe8, 0x00, 0xde, 0x01, 0xe0, 0xb0,
+    0x38, 0x01, 0x08, 0xb8, 0x6d, 0xa3, 0xc0, 0x83,
+    0xc9, 0x9f, 0xc1, 0xb0, 0x1f, 0xc1, 0xb0, 0xe3,
+    0x00, 0x09, 0xb0, 0x8c, 0x00, 0x09, 0x9a, 0xd1,
+    0xb0, 0x08, 0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0,
+    0x2e, 0x00, 0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe,
+    0xc0, 0x80, 0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84,
+    0xc1, 0x80, 0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0,
+    0xc5, 0x00, 0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a,
+    0xb2, 0xd0, 0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c,
+    0x00, 0xdc, 0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64,
+    0xc4, 0xb6, 0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7,
+    0xc0, 0x00, 0x01, 0x00, 0xdc, 0x83, 0x00, 0x09,
+    0xb0, 0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3,
+    0xb1, 0xed, 0x01, 0xdc, 0xc2, 0x00, 0xdc, 0xc0,
+    0x03, 0xdc, 0xb0, 0xc4, 0x00, 0x09, 0xb0, 0x07,
+    0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0, 0x0d,
+    0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88, 0x00,
+    0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f, 0x01,
+    0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82, 0xc4,
+    0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07, 0x96,
+    0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00,
+    0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00,
+    0x07, 0xb1, 0x74, 0x00, 0x09, 0xb0, 0x22, 0x00,
+    0x09, 0x91, 0x00, 0x09, 0xb0, 0x20, 0x00, 0x09,
+    0xb1, 0x74, 0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07,
+    0x80, 0x01, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb8,
+    0x45, 0x27, 0x04, 0x01, 0xb0, 0x0a, 0xc6, 0xb8,
+    0x49, 0x36, 0x00, 0x01, 0xb8, 0x0c, 0x95, 0x01,
+    0xd8, 0x02, 0x01, 0x82, 0x00, 0xe2, 0x04, 0xd8,
+    0x87, 0x07, 0xdc, 0x81, 0xc4, 0x01, 0xdc, 0x9d,
+    0xc3, 0xb0, 0x63, 0xc2, 0xb8, 0x05, 0x8a, 0xc6,
+    0x80, 0xd0, 0x81, 0xc6, 0x80, 0xc1, 0x80, 0xc4,
+    0xb0, 0xd4, 0xc6, 0xb1, 0x84, 0xc3, 0xb5, 0xaf,
+    0x06, 0xdc, 0xb0, 0x3c, 0xc5, 0x00, 0x07,
 };
 
 static const uint8_t unicode_cc_index[78] = {
     0x4d, 0x03, 0x00, 0x97, 0x05, 0x20, 0xc6, 0x05,
     0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0xe2,
     0x08, 0x00, 0x53, 0x09, 0x00, 0xcd, 0x0b, 0x20,
-    0x38, 0x0e, 0x00, 0x74, 0x0f, 0x00, 0x60, 0x13,
-    0x00, 0x61, 0x1a, 0x20, 0xe7, 0x1b, 0x20, 0xc0,
-    0x1d, 0x00, 0xd0, 0x20, 0x20, 0xe0, 0x2d, 0x00,
-    0x07, 0xa8, 0x00, 0xc1, 0xaa, 0x00, 0x0d, 0x0a,
-    0x21, 0x51, 0x0f, 0x01, 0x35, 0x12, 0x21, 0xc2,
-    0x14, 0x21, 0x34, 0x1a, 0x21, 0x30, 0x6b, 0x01,
-    0x00, 0xe0, 0x21, 0x4b, 0xe9, 0x01,
+    0x38, 0x0e, 0x00, 0x73, 0x0f, 0x20, 0x5d, 0x13,
+    0x20, 0x60, 0x1a, 0x20, 0xe6, 0x1b, 0x20, 0xfa,
+    0x1c, 0x00, 0x00, 0x1e, 0x20, 0x80, 0x2d, 0x00,
+    0x06, 0xa8, 0x00, 0xbe, 0xaa, 0x00, 0x76, 0x03,
+    0x01, 0x4d, 0x0f, 0x01, 0xcb, 0x11, 0x21, 0x5e,
+    0x14, 0x01, 0x3b, 0x18, 0x21, 0xf0, 0x6a, 0x41,
+    0xaa, 0xd1, 0x01, 0x4b, 0xe9, 0x01,
 };
 
-static const uint32_t unicode_decomp_table1[686] = {
+static const uint32_t unicode_decomp_table1[687] = {
     0x00280081, 0x002a0097, 0x002a8081, 0x002bc097,
     0x002c8115, 0x002d0097, 0x002d4081, 0x002e0097,
     0x002e4115, 0x002f0199, 0x00302016, 0x00400842,
@@ -734,82 +744,82 @@ static const uint32_t unicode_decomp_table1[686] = {
     0x0c9f8085, 0x0ca01883, 0x0cac4223, 0x0cad4523,
     0x0cafc097, 0x0cb004a1, 0x0cb241a5, 0x0cb30097,
     0x0cb34099, 0x0cb38097, 0x0cb3c099, 0x0cb417ad,
-    0x0cc001b3, 0x0cc0c0b1, 0x0cc100b3, 0x0cc14131,
-    0x0cc1c0b5, 0x0cc200b3, 0x0cc241b1, 0x0cc30133,
-    0x0cc38131, 0x0cc40085, 0x0cc440b1, 0x0cc48133,
-    0x0cc50085, 0x0cc540b5, 0x0cc580b7, 0x0cc5c0b5,
-    0x0cc600b1, 0x0cc64135, 0x0cc6c0b3, 0x0cc701b1,
-    0x0cc7c0b3, 0x0cc800b5, 0x0cc840b3, 0x0cc881b1,
-    0x0cc9422f, 0x0cca4131, 0x0ccac0b5, 0x0ccb00b1,
-    0x0ccb40b3, 0x0ccb80b5, 0x0ccbc0b1, 0x0ccc012f,
-    0x0ccc80b5, 0x0cccc0b3, 0x0ccd00b5, 0x0ccd40b1,
-    0x0ccd80b5, 0x0ccdc085, 0x0cce02b1, 0x0ccf40b3,
-    0x0ccf80b1, 0x0ccfc085, 0x0cd001b1, 0x0cd0c0b3,
-    0x0cd101b1, 0x0cd1c0b5, 0x0cd200b3, 0x0cd24085,
-    0x0cd280b5, 0x0cd2c085, 0x0cd30133, 0x0cd381b1,
-    0x0cd440b3, 0x0cd48085, 0x0cd4c0b1, 0x0cd500b3,
-    0x0cd54085, 0x0cd580b5, 0x0cd5c0b1, 0x0cd60521,
-    0x0cd88525, 0x0cdb02a5, 0x0cdc4099, 0x0cdc8117,
-    0x0cdd0099, 0x0cdd4197, 0x0cde0127, 0x0cde8285,
-    0x0cdfc089, 0x0ce0043f, 0x0ce20099, 0x0ce2409b,
-    0x0ce283bf, 0x0ce44219, 0x0ce54205, 0x0ce6433f,
-    0x0ce7c131, 0x0ce84085, 0x0ce881b1, 0x0ce94085,
-    0x0ce98107, 0x0cea0089, 0x0cea4097, 0x0cea8219,
-    0x0ceb809d, 0x0cebc08d, 0x0cec083f, 0x0cf00105,
-    0x0cf0809b, 0x0cf0c197, 0x0cf1809b, 0x0cf1c099,
-    0x0cf20517, 0x0cf48099, 0x0cf4c117, 0x0cf54119,
-    0x0cf5c097, 0x0cf6009b, 0x0cf64099, 0x0cf68217,
-    0x0cf78119, 0x0cf804a1, 0x0cfa4525, 0x0cfcc525,
-    0x0cff4125, 0x0cffc099, 0x29a70103, 0x29dc0081,
-    0x29fe0103, 0x2ad70203, 0x3e401482, 0x3e4a7f82,
-    0x3e6a3f82, 0x3e8aa102, 0x3e9b0110, 0x3e9c2f82,
-    0x3eb3c590, 0x3ec00197, 0x3ec0c119, 0x3ec1413f,
-    0x3ec4c2af, 0x3ec74184, 0x3ec804ad, 0x3eca4081,
-    0x3eca8304, 0x3ecc03a0, 0x3ece02a0, 0x3ecf8084,
-    0x3ed00120, 0x3ed0c120, 0x3ed184ae, 0x3ed3c085,
-    0x3ed4312d, 0x3ef4cbad, 0x3efa892f, 0x3eff022d,
-    0x3f002f2f, 0x3f1782a5, 0x3f18c0b1, 0x3f1907af,
-    0x3f1cffaf, 0x3f3c81a5, 0x3f3d64af, 0x3f542031,
-    0x3f649b31, 0x3f7c0131, 0x3f7c83b3, 0x3f7e40b1,
-    0x3f7e80bd, 0x3f7ec0bb, 0x3f7f00b3, 0x3f840503,
-    0x3f8c01ad, 0x3f8cc315, 0x3f8e462d, 0x3f91cc03,
-    0x3f97c695, 0x3f9c01af, 0x3f9d0085, 0x3f9d852f,
-    0x3fa03aad, 0x3fbd442f, 0x3fc06f1f, 0x3fd7c11f,
-    0x3fd85fad, 0x3fe80081, 0x3fe84f1f, 0x3ff0831f,
-    0x3ff2831f, 0x3ff4831f, 0x3ff6819f, 0x3ff80783,
-    0x44268192, 0x442ac092, 0x444b8112, 0x44d2c112,
-    0x452ec212, 0x456e8112, 0x74578392, 0x746ec312,
-    0x75000d1f, 0x75068d1f, 0x750d0d1f, 0x7513839f,
-    0x7515891f, 0x751a0d1f, 0x75208d1f, 0x75271015,
-    0x752f439f, 0x7531459f, 0x75340d1f, 0x753a8d1f,
-    0x75410395, 0x7543441f, 0x7545839f, 0x75478d1f,
-    0x754e0795, 0x7552839f, 0x75548d1f, 0x755b0d1f,
-    0x75618d1f, 0x75680d1f, 0x756e8d1f, 0x75750d1f,
-    0x757b8d1f, 0x75820d1f, 0x75888d1f, 0x758f0d1f,
-    0x75958d1f, 0x759c0d1f, 0x75a28d1f, 0x75a90103,
-    0x75aa089f, 0x75ae4081, 0x75ae839f, 0x75b04081,
-    0x75b08c9f, 0x75b6c081, 0x75b7032d, 0x75b8889f,
-    0x75bcc081, 0x75bd039f, 0x75bec081, 0x75bf0c9f,
-    0x75c54081, 0x75c5832d, 0x75c7089f, 0x75cb4081,
-    0x75cb839f, 0x75cd4081, 0x75cd8c9f, 0x75d3c081,
-    0x75d4032d, 0x75d5889f, 0x75d9c081, 0x75da039f,
-    0x75dbc081, 0x75dc0c9f, 0x75e24081, 0x75e2832d,
-    0x75e4089f, 0x75e84081, 0x75e8839f, 0x75ea4081,
-    0x75ea8c9f, 0x75f0c081, 0x75f1042d, 0x75f3851f,
-    0x75f6051f, 0x75f8851f, 0x75fb051f, 0x75fd851f,
-    0x7b80022d, 0x7b814dad, 0x7b884203, 0x7b89c081,
-    0x7b8a452d, 0x7b8d0403, 0x7b908081, 0x7b91dc03,
-    0x7ba0052d, 0x7ba2c8ad, 0x7ba84483, 0x7baac8ad,
-    0x7c400097, 0x7c404521, 0x7c440d25, 0x7c4a8087,
-    0x7c4ac115, 0x7c4b4117, 0x7c4c0d1f, 0x7c528217,
-    0x7c538099, 0x7c53c097, 0x7c5a8117, 0x7c640097,
-    0x7c80012f, 0x7c808081, 0x7c841603, 0x7c9004c1,
-    0x7c940103, 0xbe0001ac, 0xbe00d110, 0xbe0947ac,
-    0xbe0d3910, 0xbe29872c, 0xbe2d022c, 0xbe2e3790,
-    0xbe49ff90, 0xbe69bc10,
+    0x0cbfc085, 0x0cc001b3, 0x0cc0c0b1, 0x0cc100b3,
+    0x0cc14131, 0x0cc1c0b5, 0x0cc200b3, 0x0cc241b1,
+    0x0cc30133, 0x0cc38131, 0x0cc40085, 0x0cc440b1,
+    0x0cc48133, 0x0cc50085, 0x0cc540b5, 0x0cc580b7,
+    0x0cc5c0b5, 0x0cc600b1, 0x0cc64135, 0x0cc6c0b3,
+    0x0cc701b1, 0x0cc7c0b3, 0x0cc800b5, 0x0cc840b3,
+    0x0cc881b1, 0x0cc9422f, 0x0cca4131, 0x0ccac0b5,
+    0x0ccb00b1, 0x0ccb40b3, 0x0ccb80b5, 0x0ccbc0b1,
+    0x0ccc012f, 0x0ccc80b5, 0x0cccc0b3, 0x0ccd00b5,
+    0x0ccd40b1, 0x0ccd80b5, 0x0ccdc085, 0x0cce02b1,
+    0x0ccf40b3, 0x0ccf80b1, 0x0ccfc085, 0x0cd001b1,
+    0x0cd0c0b3, 0x0cd101b1, 0x0cd1c0b5, 0x0cd200b3,
+    0x0cd24085, 0x0cd280b5, 0x0cd2c085, 0x0cd30133,
+    0x0cd381b1, 0x0cd440b3, 0x0cd48085, 0x0cd4c0b1,
+    0x0cd500b3, 0x0cd54085, 0x0cd580b5, 0x0cd5c0b1,
+    0x0cd60521, 0x0cd88525, 0x0cdb02a5, 0x0cdc4099,
+    0x0cdc8117, 0x0cdd0099, 0x0cdd4197, 0x0cde0127,
+    0x0cde8285, 0x0cdfc089, 0x0ce0043f, 0x0ce20099,
+    0x0ce2409b, 0x0ce283bf, 0x0ce44219, 0x0ce54205,
+    0x0ce6433f, 0x0ce7c131, 0x0ce84085, 0x0ce881b1,
+    0x0ce94085, 0x0ce98107, 0x0cea0089, 0x0cea4097,
+    0x0cea8219, 0x0ceb809d, 0x0cebc08d, 0x0cec083f,
+    0x0cf00105, 0x0cf0809b, 0x0cf0c197, 0x0cf1809b,
+    0x0cf1c099, 0x0cf20517, 0x0cf48099, 0x0cf4c117,
+    0x0cf54119, 0x0cf5c097, 0x0cf6009b, 0x0cf64099,
+    0x0cf68217, 0x0cf78119, 0x0cf804a1, 0x0cfa4525,
+    0x0cfcc525, 0x0cff4125, 0x0cffc099, 0x29a70103,
+    0x29dc0081, 0x29fe0103, 0x2ad70203, 0x3e401482,
+    0x3e4a7f82, 0x3e6a3f82, 0x3e8aa102, 0x3e9b0110,
+    0x3e9c2f82, 0x3eb3c590, 0x3ec00197, 0x3ec0c119,
+    0x3ec1413f, 0x3ec4c2af, 0x3ec74184, 0x3ec804ad,
+    0x3eca4081, 0x3eca8304, 0x3ecc03a0, 0x3ece02a0,
+    0x3ecf8084, 0x3ed00120, 0x3ed0c120, 0x3ed184ae,
+    0x3ed3c085, 0x3ed4312d, 0x3ef4cbad, 0x3efa892f,
+    0x3eff022d, 0x3f002f2f, 0x3f1782a5, 0x3f18c0b1,
+    0x3f1907af, 0x3f1cffaf, 0x3f3c81a5, 0x3f3d64af,
+    0x3f542031, 0x3f649b31, 0x3f7c0131, 0x3f7c83b3,
+    0x3f7e40b1, 0x3f7e80bd, 0x3f7ec0bb, 0x3f7f00b3,
+    0x3f840503, 0x3f8c01ad, 0x3f8cc315, 0x3f8e462d,
+    0x3f91cc03, 0x3f97c695, 0x3f9c01af, 0x3f9d0085,
+    0x3f9d852f, 0x3fa03aad, 0x3fbd442f, 0x3fc06f1f,
+    0x3fd7c11f, 0x3fd85fad, 0x3fe80081, 0x3fe84f1f,
+    0x3ff0831f, 0x3ff2831f, 0x3ff4831f, 0x3ff6819f,
+    0x3ff80783, 0x44268192, 0x442ac092, 0x444b8112,
+    0x44d2c112, 0x452ec212, 0x456e8112, 0x74578392,
+    0x746ec312, 0x75000d1f, 0x75068d1f, 0x750d0d1f,
+    0x7513839f, 0x7515891f, 0x751a0d1f, 0x75208d1f,
+    0x75271015, 0x752f439f, 0x7531459f, 0x75340d1f,
+    0x753a8d1f, 0x75410395, 0x7543441f, 0x7545839f,
+    0x75478d1f, 0x754e0795, 0x7552839f, 0x75548d1f,
+    0x755b0d1f, 0x75618d1f, 0x75680d1f, 0x756e8d1f,
+    0x75750d1f, 0x757b8d1f, 0x75820d1f, 0x75888d1f,
+    0x758f0d1f, 0x75958d1f, 0x759c0d1f, 0x75a28d1f,
+    0x75a90103, 0x75aa089f, 0x75ae4081, 0x75ae839f,
+    0x75b04081, 0x75b08c9f, 0x75b6c081, 0x75b7032d,
+    0x75b8889f, 0x75bcc081, 0x75bd039f, 0x75bec081,
+    0x75bf0c9f, 0x75c54081, 0x75c5832d, 0x75c7089f,
+    0x75cb4081, 0x75cb839f, 0x75cd4081, 0x75cd8c9f,
+    0x75d3c081, 0x75d4032d, 0x75d5889f, 0x75d9c081,
+    0x75da039f, 0x75dbc081, 0x75dc0c9f, 0x75e24081,
+    0x75e2832d, 0x75e4089f, 0x75e84081, 0x75e8839f,
+    0x75ea4081, 0x75ea8c9f, 0x75f0c081, 0x75f1042d,
+    0x75f3851f, 0x75f6051f, 0x75f8851f, 0x75fb051f,
+    0x75fd851f, 0x7b80022d, 0x7b814dad, 0x7b884203,
+    0x7b89c081, 0x7b8a452d, 0x7b8d0403, 0x7b908081,
+    0x7b91dc03, 0x7ba0052d, 0x7ba2c8ad, 0x7ba84483,
+    0x7baac8ad, 0x7c400097, 0x7c404521, 0x7c440d25,
+    0x7c4a8087, 0x7c4ac115, 0x7c4b4117, 0x7c4c0d1f,
+    0x7c528217, 0x7c538099, 0x7c53c097, 0x7c5a8197,
+    0x7c640097, 0x7c80012f, 0x7c808081, 0x7c841603,
+    0x7c9004c1, 0x7c940103, 0xbe0001ac, 0xbe00d110,
+    0xbe0947ac, 0xbe0d3910, 0xbe29872c, 0xbe2d022c,
+    0xbe2e3790, 0xbe49ff90, 0xbe69bc10,
 };
 
-static const uint16_t unicode_decomp_table2[686] = {
+static const uint16_t unicode_decomp_table2[687] = {
     0x0020, 0x0000, 0x0061, 0x0002, 0x0004, 0x0006, 0x03bc, 0x0008,
     0x000a, 0x000c, 0x0015, 0x0095, 0x00a5, 0x00b9, 0x00c1, 0x00c3,
     0x00c7, 0x00cb, 0x00d1, 0x00d7, 0x00dd, 0x00e0, 0x00e6, 0x00f8,
@@ -859,46 +869,46 @@ static const uint16_t unicode_decomp_table2[686] = {
     0x0cf4, 0x0cfc, 0x0d04, 0x0d0c, 0x0d14, 0x0d22, 0x0d2e, 0x0d7a,
     0x0d82, 0x0d85, 0x0d89, 0x0d8d, 0x0d9d, 0x0db1, 0x0db5, 0x0dbc,
     0x0dc2, 0x0dc6, 0x0e28, 0x0e2c, 0x0e30, 0x0e32, 0x0e36, 0x0e3c,
-    0x0e3e, 0x0e41, 0x0e43, 0x0e46, 0x0e77, 0x0e85, 0x0e8a, 0x0e90,
-    0x0e98, 0x0e9f, 0x0ea5, 0x0eb0, 0x0eba, 0x0ec2, 0x0ec6, 0x0ecb,
-    0x0ed5, 0x0ed9, 0x0ee0, 0x0ee8, 0x0eef, 0x0ef4, 0x0f00, 0x0f06,
-    0x0f11, 0x0f17, 0x0f1e, 0x0f24, 0x0f2f, 0x0f39, 0x0f41, 0x0f48,
-    0x0f4d, 0x0f53, 0x0f5a, 0x0f5f, 0x0f65, 0x0f6c, 0x0f72, 0x0f79,
-    0x0f7e, 0x0f85, 0x0f89, 0x0f9a, 0x0fa0, 0x0fa5, 0x0fa9, 0x0fb4,
-    0x0fba, 0x0fc5, 0x0fcc, 0x0fd2, 0x0fd6, 0x0fdd, 0x0fe1, 0x0feb,
-    0x0ff6, 0x0ffc, 0x1000, 0x1005, 0x100b, 0x100f, 0x1016, 0x101b,
-    0x101f, 0x1025, 0x102b, 0x102e, 0x1032, 0x1035, 0x103b, 0x1041,
-    0x1055, 0x105d, 0x1075, 0x1078, 0x107c, 0x1091, 0x109d, 0x10ad,
-    0x10bf, 0x10c7, 0x10cb, 0x10d6, 0x10da, 0x10e6, 0x10ee, 0x10f0,
-    0x10fc, 0x1101, 0x110d, 0x113d, 0x1145, 0x1149, 0x114f, 0x1153,
-    0x1156, 0x116a, 0x116d, 0x1171, 0x1177, 0x1179, 0x117d, 0x1180,
-    0x1188, 0x118e, 0x1192, 0x1198, 0x119e, 0x11a4, 0x11a7, 0xa76f,
-    0x11ab, 0x11af, 0x11b7, 0x1209, 0x1307, 0x1405, 0x1489, 0x148e,
-    0x154c, 0x1565, 0x156b, 0x1571, 0x1577, 0x1583, 0x158f, 0x002b,
-    0x159a, 0x15b2, 0x15b6, 0x15ba, 0x15be, 0x15c2, 0x15c6, 0x15da,
-    0x15de, 0x1642, 0x165b, 0x1681, 0x1687, 0x1745, 0x174b, 0x1750,
-    0x1770, 0x1870, 0x1876, 0x190a, 0x19cc, 0x1a70, 0x1a78, 0x1a96,
-    0x1a9b, 0x1aaf, 0x1ab9, 0x1abf, 0x1ad3, 0x1ad8, 0x1ade, 0x1aec,
-    0x1b1c, 0x1b29, 0x1b31, 0x1b35, 0x1b4b, 0x1bc2, 0x1bd4, 0x1bd6,
-    0x1bd8, 0x3164, 0x1c19, 0x1c1b, 0x1c1d, 0x1c1f, 0x1c21, 0x1c23,
-    0x1c41, 0x1c4f, 0x1c54, 0x1c5d, 0x1c66, 0x1c78, 0x1c81, 0x1ca1,
-    0x1cbc, 0x1cbe, 0x1cc0, 0x1cc2, 0x1cc4, 0x1cc6, 0x1cc8, 0x1cca,
-    0x1cea, 0x1cec, 0x1cee, 0x1cf0, 0x1cf2, 0x1cf9, 0x1cfb, 0x1cfd,
-    0x1cff, 0x1d0e, 0x1d10, 0x1d12, 0x1d14, 0x1d16, 0x1d18, 0x1d1a,
-    0x1d1c, 0x1d1e, 0x1d20, 0x1d22, 0x1d24, 0x1d26, 0x1d28, 0x1d2a,
-    0x1d2e, 0x03f4, 0x1d30, 0x2207, 0x1d32, 0x2202, 0x1d34, 0x1d3c,
-    0x03f4, 0x1d3e, 0x2207, 0x1d40, 0x2202, 0x1d42, 0x1d4a, 0x03f4,
-    0x1d4c, 0x2207, 0x1d4e, 0x2202, 0x1d50, 0x1d58, 0x03f4, 0x1d5a,
-    0x2207, 0x1d5c, 0x2202, 0x1d5e, 0x1d66, 0x03f4, 0x1d68, 0x2207,
-    0x1d6a, 0x2202, 0x1d6c, 0x1d76, 0x1d78, 0x1d7a, 0x1d7c, 0x1d7e,
-    0x1d80, 0x1d86, 0x1da3, 0x062d, 0x1dab, 0x1db7, 0x062c, 0x1dc7,
-    0x1e37, 0x1e43, 0x1e56, 0x1e68, 0x1e7b, 0x1e7d, 0x1e81, 0x1e87,
-    0x1e8d, 0x1e8f, 0x1e93, 0x1e95, 0x1e9d, 0x1ea0, 0x1ea2, 0x1ea6,
-    0x1ea8, 0x30b5, 0x1eae, 0x1f06, 0x1f1c, 0x1f20, 0x1f25, 0x1f72,
-    0x1f83, 0x2084, 0x2094, 0x209a, 0x2194, 0x22b2,
+    0x0e3e, 0x0e41, 0x0e43, 0x0e46, 0x0e77, 0x0e7b, 0x0e89, 0x0e8e,
+    0x0e94, 0x0e9c, 0x0ea3, 0x0ea9, 0x0eb4, 0x0ebe, 0x0ec6, 0x0eca,
+    0x0ecf, 0x0ed9, 0x0edd, 0x0ee4, 0x0eec, 0x0ef3, 0x0ef8, 0x0f04,
+    0x0f0a, 0x0f15, 0x0f1b, 0x0f22, 0x0f28, 0x0f33, 0x0f3d, 0x0f45,
+    0x0f4c, 0x0f51, 0x0f57, 0x0f5e, 0x0f63, 0x0f69, 0x0f70, 0x0f76,
+    0x0f7d, 0x0f82, 0x0f89, 0x0f8d, 0x0f9e, 0x0fa4, 0x0fa9, 0x0fad,
+    0x0fb8, 0x0fbe, 0x0fc9, 0x0fd0, 0x0fd6, 0x0fda, 0x0fe1, 0x0fe5,
+    0x0fef, 0x0ffa, 0x1000, 0x1004, 0x1009, 0x100f, 0x1013, 0x101a,
+    0x101f, 0x1023, 0x1029, 0x102f, 0x1032, 0x1036, 0x1039, 0x103f,
+    0x1045, 0x1059, 0x1061, 0x1079, 0x107c, 0x1080, 0x1095, 0x10a1,
+    0x10b1, 0x10c3, 0x10cb, 0x10cf, 0x10da, 0x10de, 0x10ea, 0x10f2,
+    0x10f4, 0x1100, 0x1105, 0x1111, 0x1141, 0x1149, 0x114d, 0x1153,
+    0x1157, 0x115a, 0x116e, 0x1171, 0x1175, 0x117b, 0x117d, 0x1181,
+    0x1184, 0x118c, 0x1192, 0x1196, 0x119c, 0x11a2, 0x11a8, 0x11ab,
+    0xa76f, 0x11af, 0x11b3, 0x11bb, 0x120d, 0x130b, 0x1409, 0x148d,
+    0x1492, 0x1550, 0x1569, 0x156f, 0x1575, 0x157b, 0x1587, 0x1593,
+    0x002b, 0x159e, 0x15b6, 0x15ba, 0x15be, 0x15c2, 0x15c6, 0x15ca,
+    0x15de, 0x15e2, 0x1646, 0x165f, 0x1685, 0x168b, 0x1749, 0x174f,
+    0x1754, 0x1774, 0x1874, 0x187a, 0x190e, 0x19d0, 0x1a74, 0x1a7c,
+    0x1a9a, 0x1a9f, 0x1ab3, 0x1abd, 0x1ac3, 0x1ad7, 0x1adc, 0x1ae2,
+    0x1af0, 0x1b20, 0x1b2d, 0x1b35, 0x1b39, 0x1b4f, 0x1bc6, 0x1bd8,
+    0x1bda, 0x1bdc, 0x3164, 0x1c1d, 0x1c1f, 0x1c21, 0x1c23, 0x1c25,
+    0x1c27, 0x1c45, 0x1c53, 0x1c58, 0x1c61, 0x1c6a, 0x1c7c, 0x1c85,
+    0x1ca5, 0x1cc0, 0x1cc2, 0x1cc4, 0x1cc6, 0x1cc8, 0x1cca, 0x1ccc,
+    0x1cce, 0x1cee, 0x1cf0, 0x1cf2, 0x1cf4, 0x1cf6, 0x1cfd, 0x1cff,
+    0x1d01, 0x1d03, 0x1d12, 0x1d14, 0x1d16, 0x1d18, 0x1d1a, 0x1d1c,
+    0x1d1e, 0x1d20, 0x1d22, 0x1d24, 0x1d26, 0x1d28, 0x1d2a, 0x1d2c,
+    0x1d2e, 0x1d32, 0x03f4, 0x1d34, 0x2207, 0x1d36, 0x2202, 0x1d38,
+    0x1d40, 0x03f4, 0x1d42, 0x2207, 0x1d44, 0x2202, 0x1d46, 0x1d4e,
+    0x03f4, 0x1d50, 0x2207, 0x1d52, 0x2202, 0x1d54, 0x1d5c, 0x03f4,
+    0x1d5e, 0x2207, 0x1d60, 0x2202, 0x1d62, 0x1d6a, 0x03f4, 0x1d6c,
+    0x2207, 0x1d6e, 0x2202, 0x1d70, 0x1d7a, 0x1d7c, 0x1d7e, 0x1d80,
+    0x1d82, 0x1d84, 0x1d8a, 0x1da7, 0x062d, 0x1daf, 0x1dbb, 0x062c,
+    0x1dcb, 0x1e3b, 0x1e47, 0x1e5a, 0x1e6c, 0x1e7f, 0x1e81, 0x1e85,
+    0x1e8b, 0x1e91, 0x1e93, 0x1e97, 0x1e99, 0x1ea1, 0x1ea4, 0x1ea6,
+    0x1eac, 0x1eae, 0x30b5, 0x1eb4, 0x1f0c, 0x1f22, 0x1f26, 0x1f2b,
+    0x1f78, 0x1f89, 0x208a, 0x209a, 0x20a0, 0x219a, 0x22b8,
 };
 
-static const uint8_t unicode_decomp_data[9152] = {
+static const uint8_t unicode_decomp_data[9158] = {
     0x20, 0x88, 0x20, 0x84, 0x32, 0x33, 0x20, 0x81,
     0x20, 0xa7, 0x31, 0x6f, 0x31, 0xd0, 0x34, 0x31,
     0xd0, 0x32, 0x33, 0xd0, 0x34, 0x41, 0x80, 0x41,
@@ -1361,688 +1371,689 @@ static const uint8_t unicode_decomp_data[9152] = {
     0x1f, 0x22, 0x24, 0x26, 0x28, 0x29, 0x2a, 0x2b,
     0x2c, 0x2d, 0x30, 0x33, 0x36, 0x39, 0x3c, 0x3d,
     0x3e, 0x3f, 0x40, 0x42, 0x44, 0x46, 0x47, 0x48,
-    0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0xa1,
-    0x30, 0x01, 0x30, 0x5b, 0x27, 0x01, 0x4a, 0x34,
-    0x00, 0x01, 0x52, 0x39, 0x01, 0xa2, 0x30, 0x00,
-    0x5a, 0x49, 0xa4, 0x30, 0x00, 0x27, 0x4f, 0x0c,
-    0xa4, 0x30, 0x00, 0x4f, 0x1d, 0x02, 0x05, 0x4f,
-    0xa8, 0x30, 0x00, 0x11, 0x07, 0x54, 0x21, 0xa8,
-    0x30, 0x00, 0x54, 0x03, 0x54, 0xa4, 0x30, 0x06,
-    0x4f, 0x15, 0x06, 0x58, 0x3c, 0x07, 0x00, 0x46,
-    0xab, 0x30, 0x00, 0x3e, 0x18, 0x1d, 0x00, 0x42,
-    0x3f, 0x51, 0xac, 0x30, 0x00, 0x41, 0x47, 0x00,
-    0x47, 0x32, 0xae, 0x30, 0xac, 0x30, 0xae, 0x30,
-    0x00, 0x1d, 0x4e, 0xad, 0x30, 0x00, 0x38, 0x3d,
-    0x4f, 0x01, 0x3e, 0x13, 0x4f, 0xad, 0x30, 0xed,
-    0x30, 0xad, 0x30, 0x00, 0x40, 0x03, 0x3c, 0x33,
-    0xad, 0x30, 0x00, 0x40, 0x34, 0x4f, 0x1b, 0x3e,
-    0xad, 0x30, 0x00, 0x40, 0x42, 0x16, 0x1b, 0xb0,
-    0x30, 0x00, 0x39, 0x30, 0xa4, 0x30, 0x0c, 0x45,
-    0x3c, 0x24, 0x4f, 0x0b, 0x47, 0x18, 0x00, 0x49,
-    0xaf, 0x30, 0x00, 0x3e, 0x4d, 0x1e, 0xb1, 0x30,
-    0x00, 0x4b, 0x08, 0x02, 0x3a, 0x19, 0x02, 0x4b,
-    0x2c, 0xa4, 0x30, 0x11, 0x00, 0x0b, 0x47, 0xb5,
-    0x30, 0x00, 0x3e, 0x0c, 0x47, 0x2b, 0xb0, 0x30,
-    0x07, 0x3a, 0x43, 0x00, 0xb9, 0x30, 0x02, 0x3a,
-    0x08, 0x02, 0x3a, 0x0f, 0x07, 0x43, 0x00, 0xb7,
-    0x30, 0x10, 0x00, 0x12, 0x34, 0x11, 0x3c, 0x13,
-    0x17, 0xa4, 0x30, 0x2a, 0x1f, 0x24, 0x2b, 0x00,
-    0x20, 0xbb, 0x30, 0x16, 0x41, 0x00, 0x38, 0x0d,
-    0xc4, 0x30, 0x0d, 0x38, 0x00, 0xd0, 0x30, 0x00,
-    0x2c, 0x1c, 0x1b, 0xa2, 0x30, 0x32, 0x00, 0x17,
-    0x26, 0x49, 0xaf, 0x30, 0x25, 0x00, 0x3c, 0xb3,
-    0x30, 0x21, 0x00, 0x20, 0x38, 0xa1, 0x30, 0x34,
-    0x00, 0x48, 0x22, 0x28, 0xa3, 0x30, 0x32, 0x00,
-    0x59, 0x25, 0xa7, 0x30, 0x2f, 0x1c, 0x10, 0x00,
-    0x44, 0xd5, 0x30, 0x00, 0x14, 0x1e, 0xaf, 0x30,
-    0x29, 0x00, 0x10, 0x4d, 0x3c, 0xda, 0x30, 0xbd,
-    0x30, 0xb8, 0x30, 0x22, 0x13, 0x1a, 0x20, 0x33,
-    0x0c, 0x22, 0x3b, 0x01, 0x22, 0x44, 0x00, 0x21,
-    0x44, 0x07, 0xa4, 0x30, 0x39, 0x00, 0x4f, 0x24,
-    0xc8, 0x30, 0x14, 0x23, 0x00, 0xdb, 0x30, 0xf3,
-    0x30, 0xc9, 0x30, 0x14, 0x2a, 0x00, 0x12, 0x33,
-    0x22, 0x12, 0x33, 0x2a, 0xa4, 0x30, 0x3a, 0x00,
-    0x0b, 0x49, 0xa4, 0x30, 0x3a, 0x00, 0x47, 0x3a,
-    0x1f, 0x2b, 0x3a, 0x47, 0x0b, 0xb7, 0x30, 0x27,
-    0x3c, 0x00, 0x30, 0x3c, 0xaf, 0x30, 0x30, 0x00,
-    0x3e, 0x44, 0xdf, 0x30, 0xea, 0x30, 0xd0, 0x30,
-    0x0f, 0x1a, 0x00, 0x2c, 0x1b, 0xe1, 0x30, 0xac,
-    0x30, 0xac, 0x30, 0x35, 0x00, 0x1c, 0x47, 0x35,
-    0x50, 0x1c, 0x3f, 0xa2, 0x30, 0x42, 0x5a, 0x27,
-    0x42, 0x5a, 0x49, 0x44, 0x00, 0x51, 0xc3, 0x30,
-    0x27, 0x00, 0x05, 0x28, 0xea, 0x30, 0xe9, 0x30,
-    0xd4, 0x30, 0x17, 0x00, 0x28, 0xd6, 0x30, 0x15,
-    0x26, 0x00, 0x15, 0xec, 0x30, 0xe0, 0x30, 0xb2,
-    0x30, 0x3a, 0x41, 0x16, 0x00, 0x41, 0xc3, 0x30,
-    0x2c, 0x00, 0x05, 0x30, 0x00, 0xb9, 0x70, 0x31,
-    0x00, 0x30, 0x00, 0xb9, 0x70, 0x32, 0x00, 0x30,
-    0x00, 0xb9, 0x70, 0x68, 0x50, 0x61, 0x64, 0x61,
-    0x41, 0x55, 0x62, 0x61, 0x72, 0x6f, 0x56, 0x70,
-    0x63, 0x64, 0x6d, 0x64, 0x00, 0x6d, 0x00, 0xb2,
-    0x00, 0x49, 0x00, 0x55, 0x00, 0x73, 0x5e, 0x10,
-    0x62, 0x2d, 0x66, 0x8c, 0x54, 0x27, 0x59, 0x63,
-    0x6b, 0x0e, 0x66, 0xbb, 0x6c, 0x2a, 0x68, 0x0f,
-    0x5f, 0x1a, 0x4f, 0x3e, 0x79, 0x70, 0x00, 0x41,
-    0x6e, 0x00, 0x41, 0xbc, 0x03, 0x41, 0x6d, 0x00,
-    0x41, 0x6b, 0x00, 0x41, 0x4b, 0x00, 0x42, 0x4d,
-    0x00, 0x42, 0x47, 0x00, 0x42, 0x63, 0x61, 0x6c,
-    0x6b, 0x63, 0x61, 0x6c, 0x70, 0x00, 0x46, 0x6e,
-    0x00, 0x46, 0xbc, 0x03, 0x46, 0xbc, 0x03, 0x67,
-    0x6d, 0x00, 0x67, 0x6b, 0x00, 0x67, 0x48, 0x00,
-    0x7a, 0x6b, 0x48, 0x7a, 0x4d, 0x48, 0x7a, 0x47,
-    0x48, 0x7a, 0x54, 0x48, 0x7a, 0xbc, 0x03, 0x13,
-    0x21, 0x6d, 0x00, 0x13, 0x21, 0x64, 0x00, 0x13,
-    0x21, 0x6b, 0x00, 0x13, 0x21, 0x66, 0x00, 0x6d,
-    0x6e, 0x00, 0x6d, 0xbc, 0x03, 0x6d, 0x6d, 0x00,
-    0x6d, 0x63, 0x00, 0x6d, 0x6b, 0x00, 0x6d, 0x63,
-    0x00, 0x0a, 0x0a, 0x4f, 0x00, 0x0a, 0x4f, 0x6d,
-    0x00, 0xb2, 0x00, 0x63, 0x00, 0x08, 0x0a, 0x4f,
-    0x0a, 0x0a, 0x50, 0x00, 0x0a, 0x50, 0x6d, 0x00,
-    0xb3, 0x00, 0x6b, 0x00, 0x6d, 0x00, 0xb3, 0x00,
-    0x6d, 0x00, 0x15, 0x22, 0x73, 0x00, 0x6d, 0x00,
-    0x15, 0x22, 0x73, 0x00, 0xb2, 0x00, 0x50, 0x61,
-    0x6b, 0x50, 0x61, 0x4d, 0x50, 0x61, 0x47, 0x50,
-    0x61, 0x72, 0x61, 0x64, 0x72, 0x61, 0x64, 0xd1,
-    0x73, 0x72, 0x00, 0x61, 0x00, 0x64, 0x00, 0x15,
-    0x22, 0x73, 0x00, 0xb2, 0x00, 0x70, 0x00, 0x73,
-    0x6e, 0x00, 0x73, 0xbc, 0x03, 0x73, 0x6d, 0x00,
-    0x73, 0x70, 0x00, 0x56, 0x6e, 0x00, 0x56, 0xbc,
-    0x03, 0x56, 0x6d, 0x00, 0x56, 0x6b, 0x00, 0x56,
-    0x4d, 0x00, 0x56, 0x70, 0x00, 0x57, 0x6e, 0x00,
-    0x57, 0xbc, 0x03, 0x57, 0x6d, 0x00, 0x57, 0x6b,
-    0x00, 0x57, 0x4d, 0x00, 0x57, 0x6b, 0x00, 0xa9,
-    0x03, 0x4d, 0x00, 0xa9, 0x03, 0x61, 0x2e, 0x6d,
-    0x2e, 0x42, 0x71, 0x63, 0x63, 0x63, 0x64, 0x43,
-    0xd1, 0x6b, 0x67, 0x43, 0x6f, 0x2e, 0x64, 0x42,
-    0x47, 0x79, 0x68, 0x61, 0x48, 0x50, 0x69, 0x6e,
-    0x4b, 0x4b, 0x4b, 0x4d, 0x6b, 0x74, 0x6c, 0x6d,
-    0x6c, 0x6e, 0x6c, 0x6f, 0x67, 0x6c, 0x78, 0x6d,
-    0x62, 0x6d, 0x69, 0x6c, 0x6d, 0x6f, 0x6c, 0x50,
-    0x48, 0x70, 0x2e, 0x6d, 0x2e, 0x50, 0x50, 0x4d,
-    0x50, 0x52, 0x73, 0x72, 0x53, 0x76, 0x57, 0x62,
-    0x56, 0xd1, 0x6d, 0x41, 0xd1, 0x6d, 0x31, 0x00,
-    0xe5, 0x65, 0x31, 0x00, 0x30, 0x00, 0xe5, 0x65,
-    0x32, 0x00, 0x30, 0x00, 0xe5, 0x65, 0x33, 0x00,
-    0x30, 0x00, 0xe5, 0x65, 0x67, 0x61, 0x6c, 0x4a,
-    0x04, 0x4c, 0x04, 0x26, 0x01, 0x53, 0x01, 0x27,
-    0xa7, 0x37, 0xab, 0x6b, 0x02, 0x52, 0xab, 0x48,
-    0x8c, 0xf4, 0x66, 0xca, 0x8e, 0xc8, 0x8c, 0xd1,
-    0x6e, 0x32, 0x4e, 0xe5, 0x53, 0x9c, 0x9f, 0x9c,
-    0x9f, 0x51, 0x59, 0xd1, 0x91, 0x87, 0x55, 0x48,
-    0x59, 0xf6, 0x61, 0x69, 0x76, 0x85, 0x7f, 0x3f,
-    0x86, 0xba, 0x87, 0xf8, 0x88, 0x8f, 0x90, 0x02,
-    0x6a, 0x1b, 0x6d, 0xd9, 0x70, 0xde, 0x73, 0x3d,
-    0x84, 0x6a, 0x91, 0xf1, 0x99, 0x82, 0x4e, 0x75,
-    0x53, 0x04, 0x6b, 0x1b, 0x72, 0x2d, 0x86, 0x1e,
-    0x9e, 0x50, 0x5d, 0xeb, 0x6f, 0xcd, 0x85, 0x64,
-    0x89, 0xc9, 0x62, 0xd8, 0x81, 0x1f, 0x88, 0xca,
-    0x5e, 0x17, 0x67, 0x6a, 0x6d, 0xfc, 0x72, 0xce,
-    0x90, 0x86, 0x4f, 0xb7, 0x51, 0xde, 0x52, 0xc4,
-    0x64, 0xd3, 0x6a, 0x10, 0x72, 0xe7, 0x76, 0x01,
-    0x80, 0x06, 0x86, 0x5c, 0x86, 0xef, 0x8d, 0x32,
-    0x97, 0x6f, 0x9b, 0xfa, 0x9d, 0x8c, 0x78, 0x7f,
-    0x79, 0xa0, 0x7d, 0xc9, 0x83, 0x04, 0x93, 0x7f,
-    0x9e, 0xd6, 0x8a, 0xdf, 0x58, 0x04, 0x5f, 0x60,
-    0x7c, 0x7e, 0x80, 0x62, 0x72, 0xca, 0x78, 0xc2,
-    0x8c, 0xf7, 0x96, 0xd8, 0x58, 0x62, 0x5c, 0x13,
-    0x6a, 0xda, 0x6d, 0x0f, 0x6f, 0x2f, 0x7d, 0x37,
-    0x7e, 0x4b, 0x96, 0xd2, 0x52, 0x8b, 0x80, 0xdc,
-    0x51, 0xcc, 0x51, 0x1c, 0x7a, 0xbe, 0x7d, 0xf1,
-    0x83, 0x75, 0x96, 0x80, 0x8b, 0xcf, 0x62, 0x02,
-    0x6a, 0xfe, 0x8a, 0x39, 0x4e, 0xe7, 0x5b, 0x12,
-    0x60, 0x87, 0x73, 0x70, 0x75, 0x17, 0x53, 0xfb,
-    0x78, 0xbf, 0x4f, 0xa9, 0x5f, 0x0d, 0x4e, 0xcc,
-    0x6c, 0x78, 0x65, 0x22, 0x7d, 0xc3, 0x53, 0x5e,
-    0x58, 0x01, 0x77, 0x49, 0x84, 0xaa, 0x8a, 0xba,
-    0x6b, 0xb0, 0x8f, 0x88, 0x6c, 0xfe, 0x62, 0xe5,
-    0x82, 0xa0, 0x63, 0x65, 0x75, 0xae, 0x4e, 0x69,
-    0x51, 0xc9, 0x51, 0x81, 0x68, 0xe7, 0x7c, 0x6f,
-    0x82, 0xd2, 0x8a, 0xcf, 0x91, 0xf5, 0x52, 0x42,
-    0x54, 0x73, 0x59, 0xec, 0x5e, 0xc5, 0x65, 0xfe,
-    0x6f, 0x2a, 0x79, 0xad, 0x95, 0x6a, 0x9a, 0x97,
-    0x9e, 0xce, 0x9e, 0x9b, 0x52, 0xc6, 0x66, 0x77,
-    0x6b, 0x62, 0x8f, 0x74, 0x5e, 0x90, 0x61, 0x00,
-    0x62, 0x9a, 0x64, 0x23, 0x6f, 0x49, 0x71, 0x89,
-    0x74, 0xca, 0x79, 0xf4, 0x7d, 0x6f, 0x80, 0x26,
-    0x8f, 0xee, 0x84, 0x23, 0x90, 0x4a, 0x93, 0x17,
-    0x52, 0xa3, 0x52, 0xbd, 0x54, 0xc8, 0x70, 0xc2,
-    0x88, 0xaa, 0x8a, 0xc9, 0x5e, 0xf5, 0x5f, 0x7b,
-    0x63, 0xae, 0x6b, 0x3e, 0x7c, 0x75, 0x73, 0xe4,
-    0x4e, 0xf9, 0x56, 0xe7, 0x5b, 0xba, 0x5d, 0x1c,
-    0x60, 0xb2, 0x73, 0x69, 0x74, 0x9a, 0x7f, 0x46,
-    0x80, 0x34, 0x92, 0xf6, 0x96, 0x48, 0x97, 0x18,
-    0x98, 0x8b, 0x4f, 0xae, 0x79, 0xb4, 0x91, 0xb8,
-    0x96, 0xe1, 0x60, 0x86, 0x4e, 0xda, 0x50, 0xee,
-    0x5b, 0x3f, 0x5c, 0x99, 0x65, 0x02, 0x6a, 0xce,
-    0x71, 0x42, 0x76, 0xfc, 0x84, 0x7c, 0x90, 0x8d,
-    0x9f, 0x88, 0x66, 0x2e, 0x96, 0x89, 0x52, 0x7b,
-    0x67, 0xf3, 0x67, 0x41, 0x6d, 0x9c, 0x6e, 0x09,
-    0x74, 0x59, 0x75, 0x6b, 0x78, 0x10, 0x7d, 0x5e,
-    0x98, 0x6d, 0x51, 0x2e, 0x62, 0x78, 0x96, 0x2b,
-    0x50, 0x19, 0x5d, 0xea, 0x6d, 0x2a, 0x8f, 0x8b,
-    0x5f, 0x44, 0x61, 0x17, 0x68, 0x87, 0x73, 0x86,
-    0x96, 0x29, 0x52, 0x0f, 0x54, 0x65, 0x5c, 0x13,
-    0x66, 0x4e, 0x67, 0xa8, 0x68, 0xe5, 0x6c, 0x06,
-    0x74, 0xe2, 0x75, 0x79, 0x7f, 0xcf, 0x88, 0xe1,
-    0x88, 0xcc, 0x91, 0xe2, 0x96, 0x3f, 0x53, 0xba,
-    0x6e, 0x1d, 0x54, 0xd0, 0x71, 0x98, 0x74, 0xfa,
-    0x85, 0xa3, 0x96, 0x57, 0x9c, 0x9f, 0x9e, 0x97,
-    0x67, 0xcb, 0x6d, 0xe8, 0x81, 0xcb, 0x7a, 0x20,
-    0x7b, 0x92, 0x7c, 0xc0, 0x72, 0x99, 0x70, 0x58,
-    0x8b, 0xc0, 0x4e, 0x36, 0x83, 0x3a, 0x52, 0x07,
-    0x52, 0xa6, 0x5e, 0xd3, 0x62, 0xd6, 0x7c, 0x85,
-    0x5b, 0x1e, 0x6d, 0xb4, 0x66, 0x3b, 0x8f, 0x4c,
-    0x88, 0x4d, 0x96, 0x8b, 0x89, 0xd3, 0x5e, 0x40,
-    0x51, 0xc0, 0x55, 0x00, 0x00, 0x00, 0x00, 0x5a,
-    0x58, 0x00, 0x00, 0x74, 0x66, 0x00, 0x00, 0x00,
-    0x00, 0xde, 0x51, 0x2a, 0x73, 0xca, 0x76, 0x3c,
-    0x79, 0x5e, 0x79, 0x65, 0x79, 0x8f, 0x79, 0x56,
-    0x97, 0xbe, 0x7c, 0xbd, 0x7f, 0x00, 0x00, 0x12,
-    0x86, 0x00, 0x00, 0xf8, 0x8a, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x90, 0xfd, 0x90, 0xef, 0x98, 0xfc,
-    0x98, 0x28, 0x99, 0xb4, 0x9d, 0xde, 0x90, 0xb7,
-    0x96, 0xae, 0x4f, 0xe7, 0x50, 0x4d, 0x51, 0xc9,
-    0x52, 0xe4, 0x52, 0x51, 0x53, 0x9d, 0x55, 0x06,
-    0x56, 0x68, 0x56, 0x40, 0x58, 0xa8, 0x58, 0x64,
-    0x5c, 0x6e, 0x5c, 0x94, 0x60, 0x68, 0x61, 0x8e,
-    0x61, 0xf2, 0x61, 0x4f, 0x65, 0xe2, 0x65, 0x91,
-    0x66, 0x85, 0x68, 0x77, 0x6d, 0x1a, 0x6e, 0x22,
-    0x6f, 0x6e, 0x71, 0x2b, 0x72, 0x22, 0x74, 0x91,
-    0x78, 0x3e, 0x79, 0x49, 0x79, 0x48, 0x79, 0x50,
-    0x79, 0x56, 0x79, 0x5d, 0x79, 0x8d, 0x79, 0x8e,
-    0x79, 0x40, 0x7a, 0x81, 0x7a, 0xc0, 0x7b, 0xf4,
-    0x7d, 0x09, 0x7e, 0x41, 0x7e, 0x72, 0x7f, 0x05,
-    0x80, 0xed, 0x81, 0x79, 0x82, 0x79, 0x82, 0x57,
-    0x84, 0x10, 0x89, 0x96, 0x89, 0x01, 0x8b, 0x39,
-    0x8b, 0xd3, 0x8c, 0x08, 0x8d, 0xb6, 0x8f, 0x38,
-    0x90, 0xe3, 0x96, 0xff, 0x97, 0x3b, 0x98, 0x75,
-    0x60, 0xee, 0x42, 0x18, 0x82, 0x02, 0x26, 0x4e,
-    0xb5, 0x51, 0x68, 0x51, 0x80, 0x4f, 0x45, 0x51,
-    0x80, 0x51, 0xc7, 0x52, 0xfa, 0x52, 0x9d, 0x55,
-    0x55, 0x55, 0x99, 0x55, 0xe2, 0x55, 0x5a, 0x58,
-    0xb3, 0x58, 0x44, 0x59, 0x54, 0x59, 0x62, 0x5a,
-    0x28, 0x5b, 0xd2, 0x5e, 0xd9, 0x5e, 0x69, 0x5f,
-    0xad, 0x5f, 0xd8, 0x60, 0x4e, 0x61, 0x08, 0x61,
-    0x8e, 0x61, 0x60, 0x61, 0xf2, 0x61, 0x34, 0x62,
-    0xc4, 0x63, 0x1c, 0x64, 0x52, 0x64, 0x56, 0x65,
-    0x74, 0x66, 0x17, 0x67, 0x1b, 0x67, 0x56, 0x67,
-    0x79, 0x6b, 0xba, 0x6b, 0x41, 0x6d, 0xdb, 0x6e,
-    0xcb, 0x6e, 0x22, 0x6f, 0x1e, 0x70, 0x6e, 0x71,
-    0xa7, 0x77, 0x35, 0x72, 0xaf, 0x72, 0x2a, 0x73,
-    0x71, 0x74, 0x06, 0x75, 0x3b, 0x75, 0x1d, 0x76,
-    0x1f, 0x76, 0xca, 0x76, 0xdb, 0x76, 0xf4, 0x76,
-    0x4a, 0x77, 0x40, 0x77, 0xcc, 0x78, 0xb1, 0x7a,
-    0xc0, 0x7b, 0x7b, 0x7c, 0x5b, 0x7d, 0xf4, 0x7d,
-    0x3e, 0x7f, 0x05, 0x80, 0x52, 0x83, 0xef, 0x83,
-    0x79, 0x87, 0x41, 0x89, 0x86, 0x89, 0x96, 0x89,
-    0xbf, 0x8a, 0xf8, 0x8a, 0xcb, 0x8a, 0x01, 0x8b,
-    0xfe, 0x8a, 0xed, 0x8a, 0x39, 0x8b, 0x8a, 0x8b,
-    0x08, 0x8d, 0x38, 0x8f, 0x72, 0x90, 0x99, 0x91,
-    0x76, 0x92, 0x7c, 0x96, 0xe3, 0x96, 0x56, 0x97,
-    0xdb, 0x97, 0xff, 0x97, 0x0b, 0x98, 0x3b, 0x98,
-    0x12, 0x9b, 0x9c, 0x9f, 0x4a, 0x28, 0x44, 0x28,
-    0xd5, 0x33, 0x9d, 0x3b, 0x18, 0x40, 0x39, 0x40,
-    0x49, 0x52, 0xd0, 0x5c, 0xd3, 0x7e, 0x43, 0x9f,
-    0x8e, 0x9f, 0x2a, 0xa0, 0x02, 0x66, 0x66, 0x66,
-    0x69, 0x66, 0x6c, 0x66, 0x66, 0x69, 0x66, 0x66,
-    0x6c, 0x7f, 0x01, 0x74, 0x73, 0x00, 0x74, 0x65,
-    0x05, 0x0f, 0x11, 0x0f, 0x00, 0x0f, 0x06, 0x19,
-    0x11, 0x0f, 0x08, 0xd9, 0x05, 0xb4, 0x05, 0x00,
-    0x00, 0x00, 0x00, 0xf2, 0x05, 0xb7, 0x05, 0xd0,
-    0x05, 0x12, 0x00, 0x03, 0x04, 0x0b, 0x0c, 0x0d,
-    0x18, 0x1a, 0xe9, 0x05, 0xc1, 0x05, 0xe9, 0x05,
-    0xc2, 0x05, 0x49, 0xfb, 0xc1, 0x05, 0x49, 0xfb,
-    0xc2, 0x05, 0xd0, 0x05, 0xb7, 0x05, 0xd0, 0x05,
-    0xb8, 0x05, 0xd0, 0x05, 0xbc, 0x05, 0xd8, 0x05,
-    0xbc, 0x05, 0xde, 0x05, 0xbc, 0x05, 0xe0, 0x05,
-    0xbc, 0x05, 0xe3, 0x05, 0xbc, 0x05, 0xb9, 0x05,
-    0x2d, 0x03, 0x2e, 0x03, 0x2f, 0x03, 0x30, 0x03,
-    0x31, 0x03, 0x1c, 0x00, 0x18, 0x06, 0x22, 0x06,
-    0x2b, 0x06, 0xd0, 0x05, 0xdc, 0x05, 0x71, 0x06,
-    0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0d, 0x0d,
-    0x0d, 0x0d, 0x0f, 0x0f, 0x0f, 0x0f, 0x09, 0x09,
-    0x09, 0x09, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x08,
-    0x08, 0x08, 0x33, 0x33, 0x33, 0x33, 0x35, 0x35,
-    0x35, 0x35, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12,
-    0x12, 0x12, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16,
-    0x16, 0x16, 0x1c, 0x1c, 0x1b, 0x1b, 0x1d, 0x1d,
-    0x17, 0x17, 0x27, 0x27, 0x20, 0x20, 0x38, 0x38,
-    0x38, 0x38, 0x3e, 0x3e, 0x3e, 0x3e, 0x42, 0x42,
-    0x42, 0x42, 0x40, 0x40, 0x40, 0x40, 0x49, 0x49,
-    0x4a, 0x4a, 0x4a, 0x4a, 0x4f, 0x4f, 0x50, 0x50,
-    0x50, 0x50, 0x4d, 0x4d, 0x4d, 0x4d, 0x61, 0x61,
-    0x62, 0x62, 0x49, 0x06, 0x64, 0x64, 0x64, 0x64,
-    0x7e, 0x7e, 0x7d, 0x7d, 0x7f, 0x7f, 0x2e, 0x82,
-    0x82, 0x7c, 0x7c, 0x80, 0x80, 0x87, 0x87, 0x87,
-    0x87, 0x00, 0x00, 0x26, 0x06, 0x00, 0x01, 0x00,
-    0x01, 0x00, 0xaf, 0x00, 0xaf, 0x00, 0x22, 0x00,
-    0x22, 0x00, 0xa1, 0x00, 0xa1, 0x00, 0xa0, 0x00,
-    0xa0, 0x00, 0xa2, 0x00, 0xa2, 0x00, 0xaa, 0x00,
-    0xaa, 0x00, 0xaa, 0x00, 0x23, 0x00, 0x23, 0x00,
-    0x23, 0xcc, 0x06, 0x00, 0x00, 0x00, 0x00, 0x26,
-    0x06, 0x00, 0x06, 0x00, 0x07, 0x00, 0x1f, 0x00,
-    0x23, 0x00, 0x24, 0x02, 0x06, 0x02, 0x07, 0x02,
-    0x08, 0x02, 0x1f, 0x02, 0x23, 0x02, 0x24, 0x04,
-    0x06, 0x04, 0x07, 0x04, 0x08, 0x04, 0x1f, 0x04,
-    0x23, 0x04, 0x24, 0x05, 0x06, 0x05, 0x1f, 0x05,
-    0x23, 0x05, 0x24, 0x06, 0x07, 0x06, 0x1f, 0x07,
-    0x06, 0x07, 0x1f, 0x08, 0x06, 0x08, 0x07, 0x08,
-    0x1f, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x08, 0x0d,
-    0x1f, 0x0f, 0x07, 0x0f, 0x1f, 0x10, 0x06, 0x10,
-    0x07, 0x10, 0x08, 0x10, 0x1f, 0x11, 0x07, 0x11,
-    0x1f, 0x12, 0x1f, 0x13, 0x06, 0x13, 0x1f, 0x14,
-    0x06, 0x14, 0x1f, 0x1b, 0x06, 0x1b, 0x07, 0x1b,
-    0x08, 0x1b, 0x1f, 0x1b, 0x23, 0x1b, 0x24, 0x1c,
-    0x07, 0x1c, 0x1f, 0x1c, 0x23, 0x1c, 0x24, 0x1d,
-    0x01, 0x1d, 0x06, 0x1d, 0x07, 0x1d, 0x08, 0x1d,
-    0x1e, 0x1d, 0x1f, 0x1d, 0x23, 0x1d, 0x24, 0x1e,
-    0x06, 0x1e, 0x07, 0x1e, 0x08, 0x1e, 0x1f, 0x1e,
-    0x23, 0x1e, 0x24, 0x1f, 0x06, 0x1f, 0x07, 0x1f,
-    0x08, 0x1f, 0x1f, 0x1f, 0x23, 0x1f, 0x24, 0x20,
-    0x06, 0x20, 0x07, 0x20, 0x08, 0x20, 0x1f, 0x20,
-    0x23, 0x20, 0x24, 0x21, 0x06, 0x21, 0x1f, 0x21,
-    0x23, 0x21, 0x24, 0x24, 0x06, 0x24, 0x07, 0x24,
-    0x08, 0x24, 0x1f, 0x24, 0x23, 0x24, 0x24, 0x0a,
-    0x4a, 0x0b, 0x4a, 0x23, 0x4a, 0x20, 0x00, 0x4c,
-    0x06, 0x51, 0x06, 0x51, 0x06, 0xff, 0x00, 0x1f,
-    0x26, 0x06, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x1f,
-    0x00, 0x20, 0x00, 0x23, 0x00, 0x24, 0x02, 0x0b,
-    0x02, 0x0c, 0x02, 0x1f, 0x02, 0x20, 0x02, 0x23,
-    0x02, 0x24, 0x04, 0x0b, 0x04, 0x0c, 0x04, 0x1f,
-    0x26, 0x06, 0x04, 0x20, 0x04, 0x23, 0x04, 0x24,
-    0x05, 0x0b, 0x05, 0x0c, 0x05, 0x1f, 0x05, 0x20,
-    0x05, 0x23, 0x05, 0x24, 0x1b, 0x23, 0x1b, 0x24,
-    0x1c, 0x23, 0x1c, 0x24, 0x1d, 0x01, 0x1d, 0x1e,
-    0x1d, 0x1f, 0x1d, 0x23, 0x1d, 0x24, 0x1e, 0x1f,
-    0x1e, 0x23, 0x1e, 0x24, 0x1f, 0x01, 0x1f, 0x1f,
-    0x20, 0x0b, 0x20, 0x0c, 0x20, 0x1f, 0x20, 0x20,
-    0x20, 0x23, 0x20, 0x24, 0x23, 0x4a, 0x24, 0x0b,
-    0x24, 0x0c, 0x24, 0x1f, 0x24, 0x20, 0x24, 0x23,
-    0x24, 0x24, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08,
-    0x00, 0x1f, 0x00, 0x21, 0x02, 0x06, 0x02, 0x07,
-    0x02, 0x08, 0x02, 0x1f, 0x02, 0x21, 0x04, 0x06,
-    0x04, 0x07, 0x04, 0x08, 0x04, 0x1f, 0x04, 0x21,
-    0x05, 0x1f, 0x06, 0x07, 0x06, 0x1f, 0x07, 0x06,
-    0x07, 0x1f, 0x08, 0x06, 0x08, 0x1f, 0x0d, 0x06,
-    0x0d, 0x07, 0x0d, 0x08, 0x0d, 0x1f, 0x0f, 0x07,
-    0x0f, 0x08, 0x0f, 0x1f, 0x10, 0x06, 0x10, 0x07,
-    0x10, 0x08, 0x10, 0x1f, 0x11, 0x07, 0x12, 0x1f,
-    0x13, 0x06, 0x13, 0x1f, 0x14, 0x06, 0x14, 0x1f,
-    0x1b, 0x06, 0x1b, 0x07, 0x1b, 0x08, 0x1b, 0x1f,
-    0x1c, 0x07, 0x1c, 0x1f, 0x1d, 0x06, 0x1d, 0x07,
-    0x1d, 0x08, 0x1d, 0x1e, 0x1d, 0x1f, 0x1e, 0x06,
-    0x1e, 0x07, 0x1e, 0x08, 0x1e, 0x1f, 0x1e, 0x21,
-    0x1f, 0x06, 0x1f, 0x07, 0x1f, 0x08, 0x1f, 0x1f,
-    0x20, 0x06, 0x20, 0x07, 0x20, 0x08, 0x20, 0x1f,
-    0x20, 0x21, 0x21, 0x06, 0x21, 0x1f, 0x21, 0x4a,
-    0x24, 0x06, 0x24, 0x07, 0x24, 0x08, 0x24, 0x1f,
-    0x24, 0x21, 0x00, 0x1f, 0x00, 0x21, 0x02, 0x1f,
-    0x02, 0x21, 0x04, 0x1f, 0x04, 0x21, 0x05, 0x1f,
-    0x05, 0x21, 0x0d, 0x1f, 0x0d, 0x21, 0x0e, 0x1f,
-    0x0e, 0x21, 0x1d, 0x1e, 0x1d, 0x1f, 0x1e, 0x1f,
-    0x20, 0x1f, 0x20, 0x21, 0x24, 0x1f, 0x24, 0x21,
-    0x40, 0x06, 0x4e, 0x06, 0x51, 0x06, 0x27, 0x06,
-    0x10, 0x22, 0x10, 0x23, 0x12, 0x22, 0x12, 0x23,
-    0x13, 0x22, 0x13, 0x23, 0x0c, 0x22, 0x0c, 0x23,
-    0x0d, 0x22, 0x0d, 0x23, 0x06, 0x22, 0x06, 0x23,
-    0x05, 0x22, 0x05, 0x23, 0x07, 0x22, 0x07, 0x23,
-    0x0e, 0x22, 0x0e, 0x23, 0x0f, 0x22, 0x0f, 0x23,
-    0x0d, 0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e,
-    0x0d, 0x0a, 0x0c, 0x0a, 0x0e, 0x0a, 0x0f, 0x0a,
-    0x10, 0x22, 0x10, 0x23, 0x12, 0x22, 0x12, 0x23,
-    0x13, 0x22, 0x13, 0x23, 0x0c, 0x22, 0x0c, 0x23,
-    0x0d, 0x22, 0x0d, 0x23, 0x06, 0x22, 0x06, 0x23,
-    0x05, 0x22, 0x05, 0x23, 0x07, 0x22, 0x07, 0x23,
-    0x0e, 0x22, 0x0e, 0x23, 0x0f, 0x22, 0x0f, 0x23,
-    0x0d, 0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e,
-    0x0d, 0x0a, 0x0c, 0x0a, 0x0e, 0x0a, 0x0f, 0x0a,
-    0x0d, 0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e,
-    0x0c, 0x20, 0x0d, 0x20, 0x10, 0x1e, 0x0c, 0x05,
-    0x0c, 0x06, 0x0c, 0x07, 0x0d, 0x05, 0x0d, 0x06,
-    0x0d, 0x07, 0x10, 0x1e, 0x11, 0x1e, 0x00, 0x24,
-    0x00, 0x24, 0x2a, 0x06, 0x00, 0x02, 0x1b, 0x00,
-    0x03, 0x02, 0x00, 0x03, 0x02, 0x00, 0x03, 0x1b,
-    0x00, 0x04, 0x1b, 0x00, 0x1b, 0x02, 0x00, 0x1b,
-    0x03, 0x00, 0x1b, 0x04, 0x02, 0x1b, 0x03, 0x02,
-    0x1b, 0x03, 0x03, 0x1b, 0x20, 0x03, 0x1b, 0x1f,
-    0x09, 0x03, 0x02, 0x09, 0x02, 0x03, 0x09, 0x02,
-    0x1f, 0x09, 0x1b, 0x03, 0x09, 0x1b, 0x03, 0x09,
-    0x1b, 0x02, 0x09, 0x1b, 0x1b, 0x09, 0x1b, 0x1b,
-    0x0b, 0x03, 0x03, 0x0b, 0x03, 0x03, 0x0b, 0x1b,
-    0x1b, 0x0a, 0x03, 0x1b, 0x0a, 0x03, 0x1b, 0x0a,
-    0x02, 0x20, 0x0a, 0x1b, 0x04, 0x0a, 0x1b, 0x04,
-    0x0a, 0x1b, 0x1b, 0x0a, 0x1b, 0x1b, 0x0c, 0x03,
-    0x1f, 0x0c, 0x04, 0x1b, 0x0c, 0x04, 0x1b, 0x0d,
-    0x1b, 0x03, 0x0d, 0x1b, 0x03, 0x0d, 0x1b, 0x1b,
-    0x0d, 0x1b, 0x20, 0x0f, 0x02, 0x1b, 0x0f, 0x1b,
-    0x1b, 0x0f, 0x1b, 0x1b, 0x0f, 0x1b, 0x1f, 0x10,
-    0x1b, 0x1b, 0x10, 0x1b, 0x20, 0x10, 0x1b, 0x1f,
-    0x17, 0x04, 0x1b, 0x17, 0x04, 0x1b, 0x18, 0x1b,
-    0x03, 0x18, 0x1b, 0x1b, 0x1a, 0x03, 0x1b, 0x1a,
-    0x03, 0x20, 0x1a, 0x03, 0x1f, 0x1a, 0x02, 0x02,
-    0x1a, 0x02, 0x02, 0x1a, 0x04, 0x1b, 0x1a, 0x04,
-    0x1b, 0x1a, 0x1b, 0x03, 0x1a, 0x1b, 0x03, 0x1b,
-    0x03, 0x02, 0x1b, 0x03, 0x1b, 0x1b, 0x03, 0x20,
-    0x1b, 0x02, 0x03, 0x1b, 0x02, 0x1b, 0x1b, 0x04,
-    0x02, 0x1b, 0x04, 0x1b, 0x28, 0x06, 0x1d, 0x04,
-    0x06, 0x1f, 0x1d, 0x04, 0x1f, 0x1d, 0x1d, 0x1e,
-    0x05, 0x1d, 0x1e, 0x05, 0x21, 0x1e, 0x04, 0x1d,
-    0x1e, 0x04, 0x1d, 0x1e, 0x04, 0x21, 0x1e, 0x1d,
-    0x22, 0x1e, 0x1d, 0x21, 0x22, 0x1d, 0x1d, 0x22,
-    0x1d, 0x1d, 0x00, 0x06, 0x22, 0x02, 0x04, 0x22,
-    0x02, 0x04, 0x21, 0x02, 0x06, 0x22, 0x02, 0x06,
-    0x21, 0x02, 0x1d, 0x22, 0x02, 0x1d, 0x21, 0x04,
-    0x1d, 0x22, 0x04, 0x05, 0x21, 0x04, 0x1d, 0x21,
-    0x0b, 0x06, 0x21, 0x0d, 0x05, 0x22, 0x0c, 0x05,
-    0x22, 0x0e, 0x05, 0x22, 0x1c, 0x04, 0x22, 0x1c,
-    0x1d, 0x22, 0x22, 0x05, 0x22, 0x22, 0x04, 0x22,
-    0x22, 0x1d, 0x22, 0x1d, 0x1d, 0x22, 0x1a, 0x1d,
-    0x22, 0x1e, 0x05, 0x22, 0x1a, 0x1d, 0x05, 0x1c,
-    0x05, 0x1d, 0x11, 0x1d, 0x22, 0x1b, 0x1d, 0x22,
-    0x1e, 0x04, 0x05, 0x1d, 0x06, 0x22, 0x1c, 0x04,
-    0x1d, 0x1b, 0x1d, 0x1d, 0x1c, 0x04, 0x1d, 0x1e,
-    0x04, 0x05, 0x04, 0x05, 0x22, 0x05, 0x04, 0x22,
-    0x1d, 0x04, 0x22, 0x19, 0x1d, 0x22, 0x00, 0x05,
-    0x22, 0x1b, 0x1d, 0x1d, 0x11, 0x04, 0x1d, 0x0d,
-    0x1d, 0x1d, 0x0b, 0x06, 0x22, 0x1e, 0x04, 0x22,
-    0x35, 0x06, 0x00, 0x0f, 0x9d, 0x0d, 0x0f, 0x9d,
-    0x27, 0x06, 0x00, 0x1d, 0x1d, 0x20, 0x00, 0x1c,
-    0x01, 0x0a, 0x1e, 0x06, 0x1e, 0x08, 0x0e, 0x1d,
-    0x12, 0x1e, 0x0a, 0x0c, 0x21, 0x1d, 0x12, 0x1d,
-    0x23, 0x20, 0x21, 0x0c, 0x1d, 0x1e, 0x35, 0x06,
-    0x00, 0x0f, 0x14, 0x27, 0x06, 0x0e, 0x1d, 0x22,
-    0xff, 0x00, 0x1d, 0x1d, 0x20, 0xff, 0x12, 0x1d,
-    0x23, 0x20, 0xff, 0x21, 0x0c, 0x1d, 0x1e, 0x27,
-    0x06, 0x05, 0x1d, 0xff, 0x05, 0x1d, 0x00, 0x1d,
-    0x20, 0x27, 0x06, 0x0a, 0xa5, 0x00, 0x1d, 0x2c,
-    0x00, 0x01, 0x30, 0x02, 0x30, 0x3a, 0x00, 0x3b,
-    0x00, 0x21, 0x00, 0x3f, 0x00, 0x16, 0x30, 0x17,
-    0x30, 0x26, 0x20, 0x13, 0x20, 0x12, 0x01, 0x00,
-    0x5f, 0x5f, 0x28, 0x29, 0x7b, 0x7d, 0x08, 0x30,
-    0x0c, 0x0d, 0x08, 0x09, 0x02, 0x03, 0x00, 0x01,
-    0x04, 0x05, 0x06, 0x07, 0x5b, 0x00, 0x5d, 0x00,
-    0x3e, 0x20, 0x3e, 0x20, 0x3e, 0x20, 0x3e, 0x20,
-    0x5f, 0x00, 0x5f, 0x00, 0x5f, 0x00, 0x2c, 0x00,
-    0x01, 0x30, 0x2e, 0x00, 0x00, 0x00, 0x3b, 0x00,
-    0x3a, 0x00, 0x3f, 0x00, 0x21, 0x00, 0x14, 0x20,
-    0x28, 0x00, 0x29, 0x00, 0x7b, 0x00, 0x7d, 0x00,
-    0x14, 0x30, 0x15, 0x30, 0x23, 0x26, 0x2a, 0x2b,
-    0x2d, 0x3c, 0x3e, 0x3d, 0x00, 0x5c, 0x24, 0x25,
-    0x40, 0x40, 0x06, 0xff, 0x0b, 0x00, 0x0b, 0xff,
-    0x0c, 0x20, 0x00, 0x4d, 0x06, 0x40, 0x06, 0xff,
-    0x0e, 0x00, 0x0e, 0xff, 0x0f, 0x00, 0x0f, 0xff,
-    0x10, 0x00, 0x10, 0xff, 0x11, 0x00, 0x11, 0xff,
-    0x12, 0x00, 0x12, 0x21, 0x06, 0x00, 0x01, 0x01,
-    0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05,
-    0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,
-    0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a,
-    0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c,
-    0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e,
-    0x0f, 0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12,
-    0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14,
-    0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16,
-    0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18,
-    0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x20, 0x20,
-    0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22,
-    0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x24, 0x24,
-    0x24, 0x24, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26,
-    0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29,
-    0x29, 0x29, 0x22, 0x06, 0x22, 0x00, 0x22, 0x00,
-    0x22, 0x01, 0x22, 0x01, 0x22, 0x03, 0x22, 0x03,
-    0x22, 0x05, 0x22, 0x05, 0x21, 0x00, 0x85, 0x29,
-    0x01, 0x30, 0x01, 0x0b, 0x0c, 0x00, 0xfa, 0xf1,
-    0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xe2, 0xe4, 0xe6,
-    0xc2, 0xfb, 0xa1, 0xa3, 0xa5, 0xa7, 0xa9, 0xaa,
-    0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba,
-    0xbc, 0xbe, 0xc0, 0xc3, 0xc5, 0xc7, 0xc9, 0xca,
-    0xcb, 0xcc, 0xcd, 0xce, 0xd1, 0xd4, 0xd7, 0xda,
-    0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe3, 0xe5, 0xe7,
-    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xee, 0xf2, 0x98,
-    0x99, 0x31, 0x31, 0x4f, 0x31, 0x55, 0x31, 0x5b,
-    0x31, 0x61, 0x31, 0xa2, 0x00, 0xa3, 0x00, 0xac,
-    0x00, 0xaf, 0x00, 0xa6, 0x00, 0xa5, 0x00, 0xa9,
-    0x20, 0x00, 0x00, 0x02, 0x25, 0x90, 0x21, 0x91,
-    0x21, 0x92, 0x21, 0x93, 0x21, 0xa0, 0x25, 0xcb,
-    0x25, 0x99, 0x10, 0xba, 0x10, 0x00, 0x00, 0x00,
-    0x00, 0x9b, 0x10, 0xba, 0x10, 0x05, 0x05, 0xa5,
-    0x10, 0xba, 0x10, 0x05, 0x31, 0x11, 0x27, 0x11,
-    0x32, 0x11, 0x27, 0x11, 0x55, 0x47, 0x13, 0x3e,
-    0x13, 0x47, 0x13, 0x57, 0x13, 0x55, 0xb9, 0x14,
-    0xba, 0x14, 0xb9, 0x14, 0xb0, 0x14, 0x00, 0x00,
-    0x00, 0x00, 0xb9, 0x14, 0xbd, 0x14, 0x55, 0x50,
-    0xb8, 0x15, 0xaf, 0x15, 0xb9, 0x15, 0xaf, 0x15,
-    0x55, 0x57, 0xd1, 0x65, 0xd1, 0x58, 0xd1, 0x65,
-    0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f, 0xd1, 0x6f,
-    0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f, 0xd1, 0x71,
-    0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55, 0x55, 0x55,
-    0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba, 0xd1, 0x65,
-    0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc, 0xd1, 0x6e,
-    0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc, 0xd1, 0x6f,
-    0xd1, 0x55, 0x55, 0x55, 0x41, 0x00, 0x61, 0x00,
-    0x41, 0x00, 0x61, 0x00, 0x69, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x43, 0x44, 0x00, 0x00,
-    0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00, 0x00, 0x4e,
-    0x4f, 0x50, 0x51, 0x00, 0x53, 0x54, 0x55, 0x56,
-    0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
-    0x00, 0x66, 0x68, 0x00, 0x70, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45, 0x46,
-    0x47, 0x4a, 0x00, 0x53, 0x00, 0x61, 0x00, 0x41,
-    0x42, 0x00, 0x44, 0x45, 0x46, 0x47, 0x00, 0x49,
-    0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f, 0x53, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
+    0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0xe4,
+    0x4e, 0x8c, 0x54, 0xa1, 0x30, 0x01, 0x30, 0x5b,
+    0x27, 0x01, 0x4a, 0x34, 0x00, 0x01, 0x52, 0x39,
+    0x01, 0xa2, 0x30, 0x00, 0x5a, 0x49, 0xa4, 0x30,
+    0x00, 0x27, 0x4f, 0x0c, 0xa4, 0x30, 0x00, 0x4f,
+    0x1d, 0x02, 0x05, 0x4f, 0xa8, 0x30, 0x00, 0x11,
+    0x07, 0x54, 0x21, 0xa8, 0x30, 0x00, 0x54, 0x03,
+    0x54, 0xa4, 0x30, 0x06, 0x4f, 0x15, 0x06, 0x58,
+    0x3c, 0x07, 0x00, 0x46, 0xab, 0x30, 0x00, 0x3e,
+    0x18, 0x1d, 0x00, 0x42, 0x3f, 0x51, 0xac, 0x30,
+    0x00, 0x41, 0x47, 0x00, 0x47, 0x32, 0xae, 0x30,
+    0xac, 0x30, 0xae, 0x30, 0x00, 0x1d, 0x4e, 0xad,
+    0x30, 0x00, 0x38, 0x3d, 0x4f, 0x01, 0x3e, 0x13,
+    0x4f, 0xad, 0x30, 0xed, 0x30, 0xad, 0x30, 0x00,
+    0x40, 0x03, 0x3c, 0x33, 0xad, 0x30, 0x00, 0x40,
+    0x34, 0x4f, 0x1b, 0x3e, 0xad, 0x30, 0x00, 0x40,
+    0x42, 0x16, 0x1b, 0xb0, 0x30, 0x00, 0x39, 0x30,
+    0xa4, 0x30, 0x0c, 0x45, 0x3c, 0x24, 0x4f, 0x0b,
+    0x47, 0x18, 0x00, 0x49, 0xaf, 0x30, 0x00, 0x3e,
+    0x4d, 0x1e, 0xb1, 0x30, 0x00, 0x4b, 0x08, 0x02,
+    0x3a, 0x19, 0x02, 0x4b, 0x2c, 0xa4, 0x30, 0x11,
+    0x00, 0x0b, 0x47, 0xb5, 0x30, 0x00, 0x3e, 0x0c,
+    0x47, 0x2b, 0xb0, 0x30, 0x07, 0x3a, 0x43, 0x00,
+    0xb9, 0x30, 0x02, 0x3a, 0x08, 0x02, 0x3a, 0x0f,
+    0x07, 0x43, 0x00, 0xb7, 0x30, 0x10, 0x00, 0x12,
+    0x34, 0x11, 0x3c, 0x13, 0x17, 0xa4, 0x30, 0x2a,
+    0x1f, 0x24, 0x2b, 0x00, 0x20, 0xbb, 0x30, 0x16,
+    0x41, 0x00, 0x38, 0x0d, 0xc4, 0x30, 0x0d, 0x38,
+    0x00, 0xd0, 0x30, 0x00, 0x2c, 0x1c, 0x1b, 0xa2,
+    0x30, 0x32, 0x00, 0x17, 0x26, 0x49, 0xaf, 0x30,
+    0x25, 0x00, 0x3c, 0xb3, 0x30, 0x21, 0x00, 0x20,
+    0x38, 0xa1, 0x30, 0x34, 0x00, 0x48, 0x22, 0x28,
+    0xa3, 0x30, 0x32, 0x00, 0x59, 0x25, 0xa7, 0x30,
+    0x2f, 0x1c, 0x10, 0x00, 0x44, 0xd5, 0x30, 0x00,
+    0x14, 0x1e, 0xaf, 0x30, 0x29, 0x00, 0x10, 0x4d,
+    0x3c, 0xda, 0x30, 0xbd, 0x30, 0xb8, 0x30, 0x22,
+    0x13, 0x1a, 0x20, 0x33, 0x0c, 0x22, 0x3b, 0x01,
+    0x22, 0x44, 0x00, 0x21, 0x44, 0x07, 0xa4, 0x30,
+    0x39, 0x00, 0x4f, 0x24, 0xc8, 0x30, 0x14, 0x23,
+    0x00, 0xdb, 0x30, 0xf3, 0x30, 0xc9, 0x30, 0x14,
+    0x2a, 0x00, 0x12, 0x33, 0x22, 0x12, 0x33, 0x2a,
+    0xa4, 0x30, 0x3a, 0x00, 0x0b, 0x49, 0xa4, 0x30,
+    0x3a, 0x00, 0x47, 0x3a, 0x1f, 0x2b, 0x3a, 0x47,
+    0x0b, 0xb7, 0x30, 0x27, 0x3c, 0x00, 0x30, 0x3c,
+    0xaf, 0x30, 0x30, 0x00, 0x3e, 0x44, 0xdf, 0x30,
+    0xea, 0x30, 0xd0, 0x30, 0x0f, 0x1a, 0x00, 0x2c,
+    0x1b, 0xe1, 0x30, 0xac, 0x30, 0xac, 0x30, 0x35,
+    0x00, 0x1c, 0x47, 0x35, 0x50, 0x1c, 0x3f, 0xa2,
+    0x30, 0x42, 0x5a, 0x27, 0x42, 0x5a, 0x49, 0x44,
+    0x00, 0x51, 0xc3, 0x30, 0x27, 0x00, 0x05, 0x28,
+    0xea, 0x30, 0xe9, 0x30, 0xd4, 0x30, 0x17, 0x00,
+    0x28, 0xd6, 0x30, 0x15, 0x26, 0x00, 0x15, 0xec,
+    0x30, 0xe0, 0x30, 0xb2, 0x30, 0x3a, 0x41, 0x16,
+    0x00, 0x41, 0xc3, 0x30, 0x2c, 0x00, 0x05, 0x30,
+    0x00, 0xb9, 0x70, 0x31, 0x00, 0x30, 0x00, 0xb9,
+    0x70, 0x32, 0x00, 0x30, 0x00, 0xb9, 0x70, 0x68,
+    0x50, 0x61, 0x64, 0x61, 0x41, 0x55, 0x62, 0x61,
+    0x72, 0x6f, 0x56, 0x70, 0x63, 0x64, 0x6d, 0x64,
+    0x00, 0x6d, 0x00, 0xb2, 0x00, 0x49, 0x00, 0x55,
+    0x00, 0x73, 0x5e, 0x10, 0x62, 0x2d, 0x66, 0x8c,
+    0x54, 0x27, 0x59, 0x63, 0x6b, 0x0e, 0x66, 0xbb,
+    0x6c, 0x2a, 0x68, 0x0f, 0x5f, 0x1a, 0x4f, 0x3e,
+    0x79, 0x70, 0x00, 0x41, 0x6e, 0x00, 0x41, 0xbc,
+    0x03, 0x41, 0x6d, 0x00, 0x41, 0x6b, 0x00, 0x41,
+    0x4b, 0x00, 0x42, 0x4d, 0x00, 0x42, 0x47, 0x00,
+    0x42, 0x63, 0x61, 0x6c, 0x6b, 0x63, 0x61, 0x6c,
+    0x70, 0x00, 0x46, 0x6e, 0x00, 0x46, 0xbc, 0x03,
+    0x46, 0xbc, 0x03, 0x67, 0x6d, 0x00, 0x67, 0x6b,
+    0x00, 0x67, 0x48, 0x00, 0x7a, 0x6b, 0x48, 0x7a,
+    0x4d, 0x48, 0x7a, 0x47, 0x48, 0x7a, 0x54, 0x48,
+    0x7a, 0xbc, 0x03, 0x13, 0x21, 0x6d, 0x00, 0x13,
+    0x21, 0x64, 0x00, 0x13, 0x21, 0x6b, 0x00, 0x13,
+    0x21, 0x66, 0x00, 0x6d, 0x6e, 0x00, 0x6d, 0xbc,
+    0x03, 0x6d, 0x6d, 0x00, 0x6d, 0x63, 0x00, 0x6d,
+    0x6b, 0x00, 0x6d, 0x63, 0x00, 0x0a, 0x0a, 0x4f,
+    0x00, 0x0a, 0x4f, 0x6d, 0x00, 0xb2, 0x00, 0x63,
+    0x00, 0x08, 0x0a, 0x4f, 0x0a, 0x0a, 0x50, 0x00,
+    0x0a, 0x50, 0x6d, 0x00, 0xb3, 0x00, 0x6b, 0x00,
+    0x6d, 0x00, 0xb3, 0x00, 0x6d, 0x00, 0x15, 0x22,
+    0x73, 0x00, 0x6d, 0x00, 0x15, 0x22, 0x73, 0x00,
+    0xb2, 0x00, 0x50, 0x61, 0x6b, 0x50, 0x61, 0x4d,
+    0x50, 0x61, 0x47, 0x50, 0x61, 0x72, 0x61, 0x64,
+    0x72, 0x61, 0x64, 0xd1, 0x73, 0x72, 0x00, 0x61,
+    0x00, 0x64, 0x00, 0x15, 0x22, 0x73, 0x00, 0xb2,
+    0x00, 0x70, 0x00, 0x73, 0x6e, 0x00, 0x73, 0xbc,
+    0x03, 0x73, 0x6d, 0x00, 0x73, 0x70, 0x00, 0x56,
+    0x6e, 0x00, 0x56, 0xbc, 0x03, 0x56, 0x6d, 0x00,
+    0x56, 0x6b, 0x00, 0x56, 0x4d, 0x00, 0x56, 0x70,
+    0x00, 0x57, 0x6e, 0x00, 0x57, 0xbc, 0x03, 0x57,
+    0x6d, 0x00, 0x57, 0x6b, 0x00, 0x57, 0x4d, 0x00,
+    0x57, 0x6b, 0x00, 0xa9, 0x03, 0x4d, 0x00, 0xa9,
+    0x03, 0x61, 0x2e, 0x6d, 0x2e, 0x42, 0x71, 0x63,
+    0x63, 0x63, 0x64, 0x43, 0xd1, 0x6b, 0x67, 0x43,
+    0x6f, 0x2e, 0x64, 0x42, 0x47, 0x79, 0x68, 0x61,
+    0x48, 0x50, 0x69, 0x6e, 0x4b, 0x4b, 0x4b, 0x4d,
+    0x6b, 0x74, 0x6c, 0x6d, 0x6c, 0x6e, 0x6c, 0x6f,
+    0x67, 0x6c, 0x78, 0x6d, 0x62, 0x6d, 0x69, 0x6c,
+    0x6d, 0x6f, 0x6c, 0x50, 0x48, 0x70, 0x2e, 0x6d,
+    0x2e, 0x50, 0x50, 0x4d, 0x50, 0x52, 0x73, 0x72,
+    0x53, 0x76, 0x57, 0x62, 0x56, 0xd1, 0x6d, 0x41,
+    0xd1, 0x6d, 0x31, 0x00, 0xe5, 0x65, 0x31, 0x00,
+    0x30, 0x00, 0xe5, 0x65, 0x32, 0x00, 0x30, 0x00,
+    0xe5, 0x65, 0x33, 0x00, 0x30, 0x00, 0xe5, 0x65,
+    0x67, 0x61, 0x6c, 0x4a, 0x04, 0x4c, 0x04, 0x26,
+    0x01, 0x53, 0x01, 0x27, 0xa7, 0x37, 0xab, 0x6b,
+    0x02, 0x52, 0xab, 0x48, 0x8c, 0xf4, 0x66, 0xca,
+    0x8e, 0xc8, 0x8c, 0xd1, 0x6e, 0x32, 0x4e, 0xe5,
+    0x53, 0x9c, 0x9f, 0x9c, 0x9f, 0x51, 0x59, 0xd1,
+    0x91, 0x87, 0x55, 0x48, 0x59, 0xf6, 0x61, 0x69,
+    0x76, 0x85, 0x7f, 0x3f, 0x86, 0xba, 0x87, 0xf8,
+    0x88, 0x8f, 0x90, 0x02, 0x6a, 0x1b, 0x6d, 0xd9,
+    0x70, 0xde, 0x73, 0x3d, 0x84, 0x6a, 0x91, 0xf1,
+    0x99, 0x82, 0x4e, 0x75, 0x53, 0x04, 0x6b, 0x1b,
+    0x72, 0x2d, 0x86, 0x1e, 0x9e, 0x50, 0x5d, 0xeb,
+    0x6f, 0xcd, 0x85, 0x64, 0x89, 0xc9, 0x62, 0xd8,
+    0x81, 0x1f, 0x88, 0xca, 0x5e, 0x17, 0x67, 0x6a,
+    0x6d, 0xfc, 0x72, 0xce, 0x90, 0x86, 0x4f, 0xb7,
+    0x51, 0xde, 0x52, 0xc4, 0x64, 0xd3, 0x6a, 0x10,
+    0x72, 0xe7, 0x76, 0x01, 0x80, 0x06, 0x86, 0x5c,
+    0x86, 0xef, 0x8d, 0x32, 0x97, 0x6f, 0x9b, 0xfa,
+    0x9d, 0x8c, 0x78, 0x7f, 0x79, 0xa0, 0x7d, 0xc9,
+    0x83, 0x04, 0x93, 0x7f, 0x9e, 0xd6, 0x8a, 0xdf,
+    0x58, 0x04, 0x5f, 0x60, 0x7c, 0x7e, 0x80, 0x62,
+    0x72, 0xca, 0x78, 0xc2, 0x8c, 0xf7, 0x96, 0xd8,
+    0x58, 0x62, 0x5c, 0x13, 0x6a, 0xda, 0x6d, 0x0f,
+    0x6f, 0x2f, 0x7d, 0x37, 0x7e, 0x4b, 0x96, 0xd2,
+    0x52, 0x8b, 0x80, 0xdc, 0x51, 0xcc, 0x51, 0x1c,
+    0x7a, 0xbe, 0x7d, 0xf1, 0x83, 0x75, 0x96, 0x80,
+    0x8b, 0xcf, 0x62, 0x02, 0x6a, 0xfe, 0x8a, 0x39,
+    0x4e, 0xe7, 0x5b, 0x12, 0x60, 0x87, 0x73, 0x70,
+    0x75, 0x17, 0x53, 0xfb, 0x78, 0xbf, 0x4f, 0xa9,
+    0x5f, 0x0d, 0x4e, 0xcc, 0x6c, 0x78, 0x65, 0x22,
+    0x7d, 0xc3, 0x53, 0x5e, 0x58, 0x01, 0x77, 0x49,
+    0x84, 0xaa, 0x8a, 0xba, 0x6b, 0xb0, 0x8f, 0x88,
+    0x6c, 0xfe, 0x62, 0xe5, 0x82, 0xa0, 0x63, 0x65,
+    0x75, 0xae, 0x4e, 0x69, 0x51, 0xc9, 0x51, 0x81,
+    0x68, 0xe7, 0x7c, 0x6f, 0x82, 0xd2, 0x8a, 0xcf,
+    0x91, 0xf5, 0x52, 0x42, 0x54, 0x73, 0x59, 0xec,
+    0x5e, 0xc5, 0x65, 0xfe, 0x6f, 0x2a, 0x79, 0xad,
+    0x95, 0x6a, 0x9a, 0x97, 0x9e, 0xce, 0x9e, 0x9b,
+    0x52, 0xc6, 0x66, 0x77, 0x6b, 0x62, 0x8f, 0x74,
+    0x5e, 0x90, 0x61, 0x00, 0x62, 0x9a, 0x64, 0x23,
+    0x6f, 0x49, 0x71, 0x89, 0x74, 0xca, 0x79, 0xf4,
+    0x7d, 0x6f, 0x80, 0x26, 0x8f, 0xee, 0x84, 0x23,
+    0x90, 0x4a, 0x93, 0x17, 0x52, 0xa3, 0x52, 0xbd,
+    0x54, 0xc8, 0x70, 0xc2, 0x88, 0xaa, 0x8a, 0xc9,
+    0x5e, 0xf5, 0x5f, 0x7b, 0x63, 0xae, 0x6b, 0x3e,
+    0x7c, 0x75, 0x73, 0xe4, 0x4e, 0xf9, 0x56, 0xe7,
+    0x5b, 0xba, 0x5d, 0x1c, 0x60, 0xb2, 0x73, 0x69,
+    0x74, 0x9a, 0x7f, 0x46, 0x80, 0x34, 0x92, 0xf6,
+    0x96, 0x48, 0x97, 0x18, 0x98, 0x8b, 0x4f, 0xae,
+    0x79, 0xb4, 0x91, 0xb8, 0x96, 0xe1, 0x60, 0x86,
+    0x4e, 0xda, 0x50, 0xee, 0x5b, 0x3f, 0x5c, 0x99,
+    0x65, 0x02, 0x6a, 0xce, 0x71, 0x42, 0x76, 0xfc,
+    0x84, 0x7c, 0x90, 0x8d, 0x9f, 0x88, 0x66, 0x2e,
+    0x96, 0x89, 0x52, 0x7b, 0x67, 0xf3, 0x67, 0x41,
+    0x6d, 0x9c, 0x6e, 0x09, 0x74, 0x59, 0x75, 0x6b,
+    0x78, 0x10, 0x7d, 0x5e, 0x98, 0x6d, 0x51, 0x2e,
+    0x62, 0x78, 0x96, 0x2b, 0x50, 0x19, 0x5d, 0xea,
+    0x6d, 0x2a, 0x8f, 0x8b, 0x5f, 0x44, 0x61, 0x17,
+    0x68, 0x87, 0x73, 0x86, 0x96, 0x29, 0x52, 0x0f,
+    0x54, 0x65, 0x5c, 0x13, 0x66, 0x4e, 0x67, 0xa8,
+    0x68, 0xe5, 0x6c, 0x06, 0x74, 0xe2, 0x75, 0x79,
+    0x7f, 0xcf, 0x88, 0xe1, 0x88, 0xcc, 0x91, 0xe2,
+    0x96, 0x3f, 0x53, 0xba, 0x6e, 0x1d, 0x54, 0xd0,
+    0x71, 0x98, 0x74, 0xfa, 0x85, 0xa3, 0x96, 0x57,
+    0x9c, 0x9f, 0x9e, 0x97, 0x67, 0xcb, 0x6d, 0xe8,
+    0x81, 0xcb, 0x7a, 0x20, 0x7b, 0x92, 0x7c, 0xc0,
+    0x72, 0x99, 0x70, 0x58, 0x8b, 0xc0, 0x4e, 0x36,
+    0x83, 0x3a, 0x52, 0x07, 0x52, 0xa6, 0x5e, 0xd3,
+    0x62, 0xd6, 0x7c, 0x85, 0x5b, 0x1e, 0x6d, 0xb4,
+    0x66, 0x3b, 0x8f, 0x4c, 0x88, 0x4d, 0x96, 0x8b,
+    0x89, 0xd3, 0x5e, 0x40, 0x51, 0xc0, 0x55, 0x00,
+    0x00, 0x00, 0x00, 0x5a, 0x58, 0x00, 0x00, 0x74,
+    0x66, 0x00, 0x00, 0x00, 0x00, 0xde, 0x51, 0x2a,
+    0x73, 0xca, 0x76, 0x3c, 0x79, 0x5e, 0x79, 0x65,
+    0x79, 0x8f, 0x79, 0x56, 0x97, 0xbe, 0x7c, 0xbd,
+    0x7f, 0x00, 0x00, 0x12, 0x86, 0x00, 0x00, 0xf8,
+    0x8a, 0x00, 0x00, 0x00, 0x00, 0x38, 0x90, 0xfd,
+    0x90, 0xef, 0x98, 0xfc, 0x98, 0x28, 0x99, 0xb4,
+    0x9d, 0xde, 0x90, 0xb7, 0x96, 0xae, 0x4f, 0xe7,
+    0x50, 0x4d, 0x51, 0xc9, 0x52, 0xe4, 0x52, 0x51,
+    0x53, 0x9d, 0x55, 0x06, 0x56, 0x68, 0x56, 0x40,
+    0x58, 0xa8, 0x58, 0x64, 0x5c, 0x6e, 0x5c, 0x94,
+    0x60, 0x68, 0x61, 0x8e, 0x61, 0xf2, 0x61, 0x4f,
+    0x65, 0xe2, 0x65, 0x91, 0x66, 0x85, 0x68, 0x77,
+    0x6d, 0x1a, 0x6e, 0x22, 0x6f, 0x6e, 0x71, 0x2b,
+    0x72, 0x22, 0x74, 0x91, 0x78, 0x3e, 0x79, 0x49,
+    0x79, 0x48, 0x79, 0x50, 0x79, 0x56, 0x79, 0x5d,
+    0x79, 0x8d, 0x79, 0x8e, 0x79, 0x40, 0x7a, 0x81,
+    0x7a, 0xc0, 0x7b, 0xf4, 0x7d, 0x09, 0x7e, 0x41,
+    0x7e, 0x72, 0x7f, 0x05, 0x80, 0xed, 0x81, 0x79,
+    0x82, 0x79, 0x82, 0x57, 0x84, 0x10, 0x89, 0x96,
+    0x89, 0x01, 0x8b, 0x39, 0x8b, 0xd3, 0x8c, 0x08,
+    0x8d, 0xb6, 0x8f, 0x38, 0x90, 0xe3, 0x96, 0xff,
+    0x97, 0x3b, 0x98, 0x75, 0x60, 0xee, 0x42, 0x18,
+    0x82, 0x02, 0x26, 0x4e, 0xb5, 0x51, 0x68, 0x51,
+    0x80, 0x4f, 0x45, 0x51, 0x80, 0x51, 0xc7, 0x52,
+    0xfa, 0x52, 0x9d, 0x55, 0x55, 0x55, 0x99, 0x55,
+    0xe2, 0x55, 0x5a, 0x58, 0xb3, 0x58, 0x44, 0x59,
+    0x54, 0x59, 0x62, 0x5a, 0x28, 0x5b, 0xd2, 0x5e,
+    0xd9, 0x5e, 0x69, 0x5f, 0xad, 0x5f, 0xd8, 0x60,
+    0x4e, 0x61, 0x08, 0x61, 0x8e, 0x61, 0x60, 0x61,
+    0xf2, 0x61, 0x34, 0x62, 0xc4, 0x63, 0x1c, 0x64,
+    0x52, 0x64, 0x56, 0x65, 0x74, 0x66, 0x17, 0x67,
+    0x1b, 0x67, 0x56, 0x67, 0x79, 0x6b, 0xba, 0x6b,
+    0x41, 0x6d, 0xdb, 0x6e, 0xcb, 0x6e, 0x22, 0x6f,
+    0x1e, 0x70, 0x6e, 0x71, 0xa7, 0x77, 0x35, 0x72,
+    0xaf, 0x72, 0x2a, 0x73, 0x71, 0x74, 0x06, 0x75,
+    0x3b, 0x75, 0x1d, 0x76, 0x1f, 0x76, 0xca, 0x76,
+    0xdb, 0x76, 0xf4, 0x76, 0x4a, 0x77, 0x40, 0x77,
+    0xcc, 0x78, 0xb1, 0x7a, 0xc0, 0x7b, 0x7b, 0x7c,
+    0x5b, 0x7d, 0xf4, 0x7d, 0x3e, 0x7f, 0x05, 0x80,
+    0x52, 0x83, 0xef, 0x83, 0x79, 0x87, 0x41, 0x89,
+    0x86, 0x89, 0x96, 0x89, 0xbf, 0x8a, 0xf8, 0x8a,
+    0xcb, 0x8a, 0x01, 0x8b, 0xfe, 0x8a, 0xed, 0x8a,
+    0x39, 0x8b, 0x8a, 0x8b, 0x08, 0x8d, 0x38, 0x8f,
+    0x72, 0x90, 0x99, 0x91, 0x76, 0x92, 0x7c, 0x96,
+    0xe3, 0x96, 0x56, 0x97, 0xdb, 0x97, 0xff, 0x97,
+    0x0b, 0x98, 0x3b, 0x98, 0x12, 0x9b, 0x9c, 0x9f,
+    0x4a, 0x28, 0x44, 0x28, 0xd5, 0x33, 0x9d, 0x3b,
+    0x18, 0x40, 0x39, 0x40, 0x49, 0x52, 0xd0, 0x5c,
+    0xd3, 0x7e, 0x43, 0x9f, 0x8e, 0x9f, 0x2a, 0xa0,
+    0x02, 0x66, 0x66, 0x66, 0x69, 0x66, 0x6c, 0x66,
+    0x66, 0x69, 0x66, 0x66, 0x6c, 0x7f, 0x01, 0x74,
+    0x73, 0x00, 0x74, 0x65, 0x05, 0x0f, 0x11, 0x0f,
+    0x00, 0x0f, 0x06, 0x19, 0x11, 0x0f, 0x08, 0xd9,
+    0x05, 0xb4, 0x05, 0x00, 0x00, 0x00, 0x00, 0xf2,
+    0x05, 0xb7, 0x05, 0xd0, 0x05, 0x12, 0x00, 0x03,
+    0x04, 0x0b, 0x0c, 0x0d, 0x18, 0x1a, 0xe9, 0x05,
+    0xc1, 0x05, 0xe9, 0x05, 0xc2, 0x05, 0x49, 0xfb,
+    0xc1, 0x05, 0x49, 0xfb, 0xc2, 0x05, 0xd0, 0x05,
+    0xb7, 0x05, 0xd0, 0x05, 0xb8, 0x05, 0xd0, 0x05,
+    0xbc, 0x05, 0xd8, 0x05, 0xbc, 0x05, 0xde, 0x05,
+    0xbc, 0x05, 0xe0, 0x05, 0xbc, 0x05, 0xe3, 0x05,
+    0xbc, 0x05, 0xb9, 0x05, 0x2d, 0x03, 0x2e, 0x03,
+    0x2f, 0x03, 0x30, 0x03, 0x31, 0x03, 0x1c, 0x00,
+    0x18, 0x06, 0x22, 0x06, 0x2b, 0x06, 0xd0, 0x05,
+    0xdc, 0x05, 0x71, 0x06, 0x00, 0x00, 0x0a, 0x0a,
+    0x0a, 0x0a, 0x0d, 0x0d, 0x0d, 0x0d, 0x0f, 0x0f,
+    0x0f, 0x0f, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x0e,
+    0x0e, 0x0e, 0x08, 0x08, 0x08, 0x08, 0x33, 0x33,
+    0x33, 0x33, 0x35, 0x35, 0x35, 0x35, 0x13, 0x13,
+    0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x15, 0x15,
+    0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x1c, 0x1c,
+    0x1b, 0x1b, 0x1d, 0x1d, 0x17, 0x17, 0x27, 0x27,
+    0x20, 0x20, 0x38, 0x38, 0x38, 0x38, 0x3e, 0x3e,
+    0x3e, 0x3e, 0x42, 0x42, 0x42, 0x42, 0x40, 0x40,
+    0x40, 0x40, 0x49, 0x49, 0x4a, 0x4a, 0x4a, 0x4a,
+    0x4f, 0x4f, 0x50, 0x50, 0x50, 0x50, 0x4d, 0x4d,
+    0x4d, 0x4d, 0x61, 0x61, 0x62, 0x62, 0x49, 0x06,
+    0x64, 0x64, 0x64, 0x64, 0x7e, 0x7e, 0x7d, 0x7d,
+    0x7f, 0x7f, 0x2e, 0x82, 0x82, 0x7c, 0x7c, 0x80,
+    0x80, 0x87, 0x87, 0x87, 0x87, 0x00, 0x00, 0x26,
+    0x06, 0x00, 0x01, 0x00, 0x01, 0x00, 0xaf, 0x00,
+    0xaf, 0x00, 0x22, 0x00, 0x22, 0x00, 0xa1, 0x00,
+    0xa1, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa2, 0x00,
+    0xa2, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
+    0x23, 0x00, 0x23, 0x00, 0x23, 0xcc, 0x06, 0x00,
+    0x00, 0x00, 0x00, 0x26, 0x06, 0x00, 0x06, 0x00,
+    0x07, 0x00, 0x1f, 0x00, 0x23, 0x00, 0x24, 0x02,
+    0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x1f, 0x02,
+    0x23, 0x02, 0x24, 0x04, 0x06, 0x04, 0x07, 0x04,
+    0x08, 0x04, 0x1f, 0x04, 0x23, 0x04, 0x24, 0x05,
+    0x06, 0x05, 0x1f, 0x05, 0x23, 0x05, 0x24, 0x06,
+    0x07, 0x06, 0x1f, 0x07, 0x06, 0x07, 0x1f, 0x08,
+    0x06, 0x08, 0x07, 0x08, 0x1f, 0x0d, 0x06, 0x0d,
+    0x07, 0x0d, 0x08, 0x0d, 0x1f, 0x0f, 0x07, 0x0f,
+    0x1f, 0x10, 0x06, 0x10, 0x07, 0x10, 0x08, 0x10,
+    0x1f, 0x11, 0x07, 0x11, 0x1f, 0x12, 0x1f, 0x13,
+    0x06, 0x13, 0x1f, 0x14, 0x06, 0x14, 0x1f, 0x1b,
+    0x06, 0x1b, 0x07, 0x1b, 0x08, 0x1b, 0x1f, 0x1b,
+    0x23, 0x1b, 0x24, 0x1c, 0x07, 0x1c, 0x1f, 0x1c,
+    0x23, 0x1c, 0x24, 0x1d, 0x01, 0x1d, 0x06, 0x1d,
+    0x07, 0x1d, 0x08, 0x1d, 0x1e, 0x1d, 0x1f, 0x1d,
+    0x23, 0x1d, 0x24, 0x1e, 0x06, 0x1e, 0x07, 0x1e,
+    0x08, 0x1e, 0x1f, 0x1e, 0x23, 0x1e, 0x24, 0x1f,
+    0x06, 0x1f, 0x07, 0x1f, 0x08, 0x1f, 0x1f, 0x1f,
+    0x23, 0x1f, 0x24, 0x20, 0x06, 0x20, 0x07, 0x20,
+    0x08, 0x20, 0x1f, 0x20, 0x23, 0x20, 0x24, 0x21,
+    0x06, 0x21, 0x1f, 0x21, 0x23, 0x21, 0x24, 0x24,
+    0x06, 0x24, 0x07, 0x24, 0x08, 0x24, 0x1f, 0x24,
+    0x23, 0x24, 0x24, 0x0a, 0x4a, 0x0b, 0x4a, 0x23,
+    0x4a, 0x20, 0x00, 0x4c, 0x06, 0x51, 0x06, 0x51,
+    0x06, 0xff, 0x00, 0x1f, 0x26, 0x06, 0x00, 0x0b,
+    0x00, 0x0c, 0x00, 0x1f, 0x00, 0x20, 0x00, 0x23,
+    0x00, 0x24, 0x02, 0x0b, 0x02, 0x0c, 0x02, 0x1f,
+    0x02, 0x20, 0x02, 0x23, 0x02, 0x24, 0x04, 0x0b,
+    0x04, 0x0c, 0x04, 0x1f, 0x26, 0x06, 0x04, 0x20,
+    0x04, 0x23, 0x04, 0x24, 0x05, 0x0b, 0x05, 0x0c,
+    0x05, 0x1f, 0x05, 0x20, 0x05, 0x23, 0x05, 0x24,
+    0x1b, 0x23, 0x1b, 0x24, 0x1c, 0x23, 0x1c, 0x24,
+    0x1d, 0x01, 0x1d, 0x1e, 0x1d, 0x1f, 0x1d, 0x23,
+    0x1d, 0x24, 0x1e, 0x1f, 0x1e, 0x23, 0x1e, 0x24,
+    0x1f, 0x01, 0x1f, 0x1f, 0x20, 0x0b, 0x20, 0x0c,
+    0x20, 0x1f, 0x20, 0x20, 0x20, 0x23, 0x20, 0x24,
+    0x23, 0x4a, 0x24, 0x0b, 0x24, 0x0c, 0x24, 0x1f,
+    0x24, 0x20, 0x24, 0x23, 0x24, 0x24, 0x00, 0x06,
+    0x00, 0x07, 0x00, 0x08, 0x00, 0x1f, 0x00, 0x21,
+    0x02, 0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x1f,
+    0x02, 0x21, 0x04, 0x06, 0x04, 0x07, 0x04, 0x08,
+    0x04, 0x1f, 0x04, 0x21, 0x05, 0x1f, 0x06, 0x07,
+    0x06, 0x1f, 0x07, 0x06, 0x07, 0x1f, 0x08, 0x06,
+    0x08, 0x1f, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x08,
+    0x0d, 0x1f, 0x0f, 0x07, 0x0f, 0x08, 0x0f, 0x1f,
+    0x10, 0x06, 0x10, 0x07, 0x10, 0x08, 0x10, 0x1f,
+    0x11, 0x07, 0x12, 0x1f, 0x13, 0x06, 0x13, 0x1f,
+    0x14, 0x06, 0x14, 0x1f, 0x1b, 0x06, 0x1b, 0x07,
+    0x1b, 0x08, 0x1b, 0x1f, 0x1c, 0x07, 0x1c, 0x1f,
+    0x1d, 0x06, 0x1d, 0x07, 0x1d, 0x08, 0x1d, 0x1e,
+    0x1d, 0x1f, 0x1e, 0x06, 0x1e, 0x07, 0x1e, 0x08,
+    0x1e, 0x1f, 0x1e, 0x21, 0x1f, 0x06, 0x1f, 0x07,
+    0x1f, 0x08, 0x1f, 0x1f, 0x20, 0x06, 0x20, 0x07,
+    0x20, 0x08, 0x20, 0x1f, 0x20, 0x21, 0x21, 0x06,
+    0x21, 0x1f, 0x21, 0x4a, 0x24, 0x06, 0x24, 0x07,
+    0x24, 0x08, 0x24, 0x1f, 0x24, 0x21, 0x00, 0x1f,
+    0x00, 0x21, 0x02, 0x1f, 0x02, 0x21, 0x04, 0x1f,
+    0x04, 0x21, 0x05, 0x1f, 0x05, 0x21, 0x0d, 0x1f,
+    0x0d, 0x21, 0x0e, 0x1f, 0x0e, 0x21, 0x1d, 0x1e,
+    0x1d, 0x1f, 0x1e, 0x1f, 0x20, 0x1f, 0x20, 0x21,
+    0x24, 0x1f, 0x24, 0x21, 0x40, 0x06, 0x4e, 0x06,
+    0x51, 0x06, 0x27, 0x06, 0x10, 0x22, 0x10, 0x23,
+    0x12, 0x22, 0x12, 0x23, 0x13, 0x22, 0x13, 0x23,
+    0x0c, 0x22, 0x0c, 0x23, 0x0d, 0x22, 0x0d, 0x23,
+    0x06, 0x22, 0x06, 0x23, 0x05, 0x22, 0x05, 0x23,
+    0x07, 0x22, 0x07, 0x23, 0x0e, 0x22, 0x0e, 0x23,
+    0x0f, 0x22, 0x0f, 0x23, 0x0d, 0x05, 0x0d, 0x06,
+    0x0d, 0x07, 0x0d, 0x1e, 0x0d, 0x0a, 0x0c, 0x0a,
+    0x0e, 0x0a, 0x0f, 0x0a, 0x10, 0x22, 0x10, 0x23,
+    0x12, 0x22, 0x12, 0x23, 0x13, 0x22, 0x13, 0x23,
+    0x0c, 0x22, 0x0c, 0x23, 0x0d, 0x22, 0x0d, 0x23,
+    0x06, 0x22, 0x06, 0x23, 0x05, 0x22, 0x05, 0x23,
+    0x07, 0x22, 0x07, 0x23, 0x0e, 0x22, 0x0e, 0x23,
+    0x0f, 0x22, 0x0f, 0x23, 0x0d, 0x05, 0x0d, 0x06,
+    0x0d, 0x07, 0x0d, 0x1e, 0x0d, 0x0a, 0x0c, 0x0a,
+    0x0e, 0x0a, 0x0f, 0x0a, 0x0d, 0x05, 0x0d, 0x06,
+    0x0d, 0x07, 0x0d, 0x1e, 0x0c, 0x20, 0x0d, 0x20,
+    0x10, 0x1e, 0x0c, 0x05, 0x0c, 0x06, 0x0c, 0x07,
+    0x0d, 0x05, 0x0d, 0x06, 0x0d, 0x07, 0x10, 0x1e,
+    0x11, 0x1e, 0x00, 0x24, 0x00, 0x24, 0x2a, 0x06,
+    0x00, 0x02, 0x1b, 0x00, 0x03, 0x02, 0x00, 0x03,
+    0x02, 0x00, 0x03, 0x1b, 0x00, 0x04, 0x1b, 0x00,
+    0x1b, 0x02, 0x00, 0x1b, 0x03, 0x00, 0x1b, 0x04,
+    0x02, 0x1b, 0x03, 0x02, 0x1b, 0x03, 0x03, 0x1b,
+    0x20, 0x03, 0x1b, 0x1f, 0x09, 0x03, 0x02, 0x09,
+    0x02, 0x03, 0x09, 0x02, 0x1f, 0x09, 0x1b, 0x03,
+    0x09, 0x1b, 0x03, 0x09, 0x1b, 0x02, 0x09, 0x1b,
+    0x1b, 0x09, 0x1b, 0x1b, 0x0b, 0x03, 0x03, 0x0b,
+    0x03, 0x03, 0x0b, 0x1b, 0x1b, 0x0a, 0x03, 0x1b,
+    0x0a, 0x03, 0x1b, 0x0a, 0x02, 0x20, 0x0a, 0x1b,
+    0x04, 0x0a, 0x1b, 0x04, 0x0a, 0x1b, 0x1b, 0x0a,
+    0x1b, 0x1b, 0x0c, 0x03, 0x1f, 0x0c, 0x04, 0x1b,
+    0x0c, 0x04, 0x1b, 0x0d, 0x1b, 0x03, 0x0d, 0x1b,
+    0x03, 0x0d, 0x1b, 0x1b, 0x0d, 0x1b, 0x20, 0x0f,
+    0x02, 0x1b, 0x0f, 0x1b, 0x1b, 0x0f, 0x1b, 0x1b,
+    0x0f, 0x1b, 0x1f, 0x10, 0x1b, 0x1b, 0x10, 0x1b,
+    0x20, 0x10, 0x1b, 0x1f, 0x17, 0x04, 0x1b, 0x17,
+    0x04, 0x1b, 0x18, 0x1b, 0x03, 0x18, 0x1b, 0x1b,
+    0x1a, 0x03, 0x1b, 0x1a, 0x03, 0x20, 0x1a, 0x03,
+    0x1f, 0x1a, 0x02, 0x02, 0x1a, 0x02, 0x02, 0x1a,
+    0x04, 0x1b, 0x1a, 0x04, 0x1b, 0x1a, 0x1b, 0x03,
+    0x1a, 0x1b, 0x03, 0x1b, 0x03, 0x02, 0x1b, 0x03,
+    0x1b, 0x1b, 0x03, 0x20, 0x1b, 0x02, 0x03, 0x1b,
+    0x02, 0x1b, 0x1b, 0x04, 0x02, 0x1b, 0x04, 0x1b,
+    0x28, 0x06, 0x1d, 0x04, 0x06, 0x1f, 0x1d, 0x04,
+    0x1f, 0x1d, 0x1d, 0x1e, 0x05, 0x1d, 0x1e, 0x05,
+    0x21, 0x1e, 0x04, 0x1d, 0x1e, 0x04, 0x1d, 0x1e,
+    0x04, 0x21, 0x1e, 0x1d, 0x22, 0x1e, 0x1d, 0x21,
+    0x22, 0x1d, 0x1d, 0x22, 0x1d, 0x1d, 0x00, 0x06,
+    0x22, 0x02, 0x04, 0x22, 0x02, 0x04, 0x21, 0x02,
+    0x06, 0x22, 0x02, 0x06, 0x21, 0x02, 0x1d, 0x22,
+    0x02, 0x1d, 0x21, 0x04, 0x1d, 0x22, 0x04, 0x05,
+    0x21, 0x04, 0x1d, 0x21, 0x0b, 0x06, 0x21, 0x0d,
+    0x05, 0x22, 0x0c, 0x05, 0x22, 0x0e, 0x05, 0x22,
+    0x1c, 0x04, 0x22, 0x1c, 0x1d, 0x22, 0x22, 0x05,
+    0x22, 0x22, 0x04, 0x22, 0x22, 0x1d, 0x22, 0x1d,
+    0x1d, 0x22, 0x1a, 0x1d, 0x22, 0x1e, 0x05, 0x22,
+    0x1a, 0x1d, 0x05, 0x1c, 0x05, 0x1d, 0x11, 0x1d,
+    0x22, 0x1b, 0x1d, 0x22, 0x1e, 0x04, 0x05, 0x1d,
+    0x06, 0x22, 0x1c, 0x04, 0x1d, 0x1b, 0x1d, 0x1d,
+    0x1c, 0x04, 0x1d, 0x1e, 0x04, 0x05, 0x04, 0x05,
+    0x22, 0x05, 0x04, 0x22, 0x1d, 0x04, 0x22, 0x19,
+    0x1d, 0x22, 0x00, 0x05, 0x22, 0x1b, 0x1d, 0x1d,
+    0x11, 0x04, 0x1d, 0x0d, 0x1d, 0x1d, 0x0b, 0x06,
+    0x22, 0x1e, 0x04, 0x22, 0x35, 0x06, 0x00, 0x0f,
+    0x9d, 0x0d, 0x0f, 0x9d, 0x27, 0x06, 0x00, 0x1d,
+    0x1d, 0x20, 0x00, 0x1c, 0x01, 0x0a, 0x1e, 0x06,
+    0x1e, 0x08, 0x0e, 0x1d, 0x12, 0x1e, 0x0a, 0x0c,
+    0x21, 0x1d, 0x12, 0x1d, 0x23, 0x20, 0x21, 0x0c,
+    0x1d, 0x1e, 0x35, 0x06, 0x00, 0x0f, 0x14, 0x27,
+    0x06, 0x0e, 0x1d, 0x22, 0xff, 0x00, 0x1d, 0x1d,
+    0x20, 0xff, 0x12, 0x1d, 0x23, 0x20, 0xff, 0x21,
+    0x0c, 0x1d, 0x1e, 0x27, 0x06, 0x05, 0x1d, 0xff,
+    0x05, 0x1d, 0x00, 0x1d, 0x20, 0x27, 0x06, 0x0a,
+    0xa5, 0x00, 0x1d, 0x2c, 0x00, 0x01, 0x30, 0x02,
+    0x30, 0x3a, 0x00, 0x3b, 0x00, 0x21, 0x00, 0x3f,
+    0x00, 0x16, 0x30, 0x17, 0x30, 0x26, 0x20, 0x13,
+    0x20, 0x12, 0x01, 0x00, 0x5f, 0x5f, 0x28, 0x29,
+    0x7b, 0x7d, 0x08, 0x30, 0x0c, 0x0d, 0x08, 0x09,
+    0x02, 0x03, 0x00, 0x01, 0x04, 0x05, 0x06, 0x07,
+    0x5b, 0x00, 0x5d, 0x00, 0x3e, 0x20, 0x3e, 0x20,
+    0x3e, 0x20, 0x3e, 0x20, 0x5f, 0x00, 0x5f, 0x00,
+    0x5f, 0x00, 0x2c, 0x00, 0x01, 0x30, 0x2e, 0x00,
+    0x00, 0x00, 0x3b, 0x00, 0x3a, 0x00, 0x3f, 0x00,
+    0x21, 0x00, 0x14, 0x20, 0x28, 0x00, 0x29, 0x00,
+    0x7b, 0x00, 0x7d, 0x00, 0x14, 0x30, 0x15, 0x30,
+    0x23, 0x26, 0x2a, 0x2b, 0x2d, 0x3c, 0x3e, 0x3d,
+    0x00, 0x5c, 0x24, 0x25, 0x40, 0x40, 0x06, 0xff,
+    0x0b, 0x00, 0x0b, 0xff, 0x0c, 0x20, 0x00, 0x4d,
+    0x06, 0x40, 0x06, 0xff, 0x0e, 0x00, 0x0e, 0xff,
+    0x0f, 0x00, 0x0f, 0xff, 0x10, 0x00, 0x10, 0xff,
+    0x11, 0x00, 0x11, 0xff, 0x12, 0x00, 0x12, 0x21,
+    0x06, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03,
+    0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06,
+    0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09,
+    0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b,
+    0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d,
+    0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10,
+    0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13,
+    0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15,
+    0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17,
+    0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19,
+    0x19, 0x19, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21,
+    0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23,
+    0x23, 0x23, 0x24, 0x24, 0x24, 0x24, 0x25, 0x25,
+    0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27,
+    0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x22, 0x06,
+    0x22, 0x00, 0x22, 0x00, 0x22, 0x01, 0x22, 0x01,
+    0x22, 0x03, 0x22, 0x03, 0x22, 0x05, 0x22, 0x05,
+    0x21, 0x00, 0x85, 0x29, 0x01, 0x30, 0x01, 0x0b,
+    0x0c, 0x00, 0xfa, 0xf1, 0xa0, 0xa2, 0xa4, 0xa6,
+    0xa8, 0xe2, 0xe4, 0xe6, 0xc2, 0xfb, 0xa1, 0xa3,
+    0xa5, 0xa7, 0xa9, 0xaa, 0xac, 0xae, 0xb0, 0xb2,
+    0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0, 0xc3,
+    0xc5, 0xc7, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
+    0xd1, 0xd4, 0xd7, 0xda, 0xdd, 0xde, 0xdf, 0xe0,
+    0xe1, 0xe3, 0xe5, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
+    0xec, 0xee, 0xf2, 0x98, 0x99, 0x31, 0x31, 0x4f,
+    0x31, 0x55, 0x31, 0x5b, 0x31, 0x61, 0x31, 0xa2,
+    0x00, 0xa3, 0x00, 0xac, 0x00, 0xaf, 0x00, 0xa6,
+    0x00, 0xa5, 0x00, 0xa9, 0x20, 0x00, 0x00, 0x02,
+    0x25, 0x90, 0x21, 0x91, 0x21, 0x92, 0x21, 0x93,
+    0x21, 0xa0, 0x25, 0xcb, 0x25, 0x99, 0x10, 0xba,
+    0x10, 0x00, 0x00, 0x00, 0x00, 0x9b, 0x10, 0xba,
+    0x10, 0x05, 0x05, 0xa5, 0x10, 0xba, 0x10, 0x05,
+    0x31, 0x11, 0x27, 0x11, 0x32, 0x11, 0x27, 0x11,
+    0x55, 0x47, 0x13, 0x3e, 0x13, 0x47, 0x13, 0x57,
+    0x13, 0x55, 0xb9, 0x14, 0xba, 0x14, 0xb9, 0x14,
+    0xb0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x14,
+    0xbd, 0x14, 0x55, 0x50, 0xb8, 0x15, 0xaf, 0x15,
+    0xb9, 0x15, 0xaf, 0x15, 0x55, 0x57, 0xd1, 0x65,
+    0xd1, 0x58, 0xd1, 0x65, 0xd1, 0x5f, 0xd1, 0x6e,
+    0xd1, 0x5f, 0xd1, 0x6f, 0xd1, 0x5f, 0xd1, 0x70,
+    0xd1, 0x5f, 0xd1, 0x71, 0xd1, 0x5f, 0xd1, 0x72,
+    0xd1, 0x55, 0x55, 0x55, 0x05, 0xb9, 0xd1, 0x65,
+    0xd1, 0xba, 0xd1, 0x65, 0xd1, 0xbb, 0xd1, 0x6e,
+    0xd1, 0xbc, 0xd1, 0x6e, 0xd1, 0xbb, 0xd1, 0x6f,
+    0xd1, 0xbc, 0xd1, 0x6f, 0xd1, 0x55, 0x55, 0x55,
+    0x41, 0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00,
+    0x69, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
+    0x43, 0x44, 0x00, 0x00, 0x47, 0x00, 0x00, 0x4a,
+    0x4b, 0x00, 0x00, 0x4e, 0x4f, 0x50, 0x51, 0x00,
+    0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+    0x61, 0x62, 0x63, 0x64, 0x00, 0x66, 0x68, 0x00,
+    0x70, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x42,
+    0x00, 0x44, 0x45, 0x46, 0x47, 0x4a, 0x00, 0x53,
+    0x00, 0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45,
+    0x46, 0x47, 0x00, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
+    0x00, 0x4f, 0x53, 0x00, 0x61, 0x00, 0x41, 0x00,
     0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
     0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x31, 0x01, 0x37, 0x02, 0x91, 0x03,
+    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x31, 0x01,
+    0x37, 0x02, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
+    0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
+    0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
+    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
     0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
     0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03,
     0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04,
     0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
     0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
-    0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
-    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
-    0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
-    0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30, 0x00,
-    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
-    0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x2a, 0x06,
-    0x1e, 0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a, 0x1b,
-    0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a,
-    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x44,
-    0x90, 0x77, 0x45, 0x28, 0x06, 0x2c, 0x06, 0x00,
-    0x00, 0x47, 0x06, 0x33, 0x06, 0x17, 0x10, 0x11,
-    0x12, 0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f, 0x34,
-    0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00,
-    0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x2d,
-    0x06, 0x00, 0x00, 0x4a, 0x06, 0x00, 0x00, 0x44,
-    0x06, 0x00, 0x00, 0x46, 0x06, 0x33, 0x06, 0x39,
-    0x06, 0x00, 0x00, 0x35, 0x06, 0x42, 0x06, 0x00,
-    0x00, 0x34, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2e,
-    0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a,
-    0x06, 0x00, 0x00, 0xba, 0x06, 0x00, 0x00, 0x6f,
-    0x06, 0x00, 0x00, 0x28, 0x06, 0x2c, 0x06, 0x00,
-    0x00, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2d,
-    0x06, 0x37, 0x06, 0x4a, 0x06, 0x43, 0x06, 0x00,
-    0x00, 0x45, 0x06, 0x46, 0x06, 0x33, 0x06, 0x39,
-    0x06, 0x41, 0x06, 0x35, 0x06, 0x42, 0x06, 0x00,
-    0x00, 0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e,
-    0x06, 0x00, 0x00, 0x36, 0x06, 0x38, 0x06, 0x3a,
-    0x06, 0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06, 0x27,
-    0x06, 0x00, 0x01, 0x05, 0x08, 0x20, 0x21, 0x0b,
-    0x06, 0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b, 0x1c,
-    0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00,
-    0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28, 0x06,
-    0x2c, 0x06, 0x2f, 0x06, 0x00, 0x00, 0x48, 0x06,
-    0x32, 0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06,
-    0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
+    0x0b, 0x0c, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x27, 0x06, 0x00, 0x01,
+    0x05, 0x08, 0x2a, 0x06, 0x1e, 0x08, 0x03, 0x0d,
+    0x20, 0x19, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
     0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06,
-    0x0c, 0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00, 0x2c,
-    0x00, 0x28, 0x00, 0x41, 0x00, 0x29, 0x00, 0x14,
-    0x30, 0x53, 0x00, 0x15, 0x30, 0x43, 0x52, 0x43,
-    0x44, 0x57, 0x5a, 0x41, 0x00, 0x48, 0x56, 0x4d,
-    0x56, 0x53, 0x44, 0x53, 0x53, 0x50, 0x50, 0x56,
-    0x57, 0x43, 0x4d, 0x43, 0x4d, 0x44, 0x44, 0x4a,
-    0x4b, 0x30, 0x30, 0x00, 0x68, 0x68, 0x4b, 0x62,
-    0x57, 0x5b, 0xcc, 0x53, 0xc7, 0x30, 0x8c, 0x4e,
-    0x1a, 0x59, 0xe3, 0x89, 0x29, 0x59, 0xa4, 0x4e,
-    0x20, 0x66, 0x21, 0x71, 0x99, 0x65, 0x4d, 0x52,
-    0x8c, 0x5f, 0x8d, 0x51, 0xb0, 0x65, 0x1d, 0x52,
-    0x42, 0x7d, 0x1f, 0x75, 0xa9, 0x8c, 0xf0, 0x58,
-    0x39, 0x54, 0x14, 0x6f, 0x95, 0x62, 0x55, 0x63,
-    0x00, 0x4e, 0x09, 0x4e, 0x4a, 0x90, 0xe6, 0x5d,
-    0x2d, 0x4e, 0xf3, 0x53, 0x07, 0x63, 0x70, 0x8d,
-    0x53, 0x62, 0x81, 0x79, 0x7a, 0x7a, 0x08, 0x54,
-    0x80, 0x6e, 0x09, 0x67, 0x08, 0x67, 0x33, 0x75,
-    0x72, 0x52, 0xb6, 0x55, 0x4d, 0x91, 0x14, 0x30,
-    0x15, 0x30, 0x2c, 0x67, 0x09, 0x4e, 0x8c, 0x4e,
-    0x89, 0x5b, 0xb9, 0x70, 0x53, 0x62, 0xd7, 0x76,
-    0xdd, 0x52, 0x57, 0x65, 0x97, 0x5f, 0xef, 0x53,
-    0x38, 0x4e, 0x05, 0x00, 0x09, 0x22, 0x01, 0x60,
-    0x4f, 0xae, 0x4f, 0xbb, 0x4f, 0x02, 0x50, 0x7a,
-    0x50, 0x99, 0x50, 0xe7, 0x50, 0xcf, 0x50, 0x9e,
-    0x34, 0x3a, 0x06, 0x4d, 0x51, 0x54, 0x51, 0x64,
-    0x51, 0x77, 0x51, 0x1c, 0x05, 0xb9, 0x34, 0x67,
-    0x51, 0x8d, 0x51, 0x4b, 0x05, 0x97, 0x51, 0xa4,
-    0x51, 0xcc, 0x4e, 0xac, 0x51, 0xb5, 0x51, 0xdf,
-    0x91, 0xf5, 0x51, 0x03, 0x52, 0xdf, 0x34, 0x3b,
-    0x52, 0x46, 0x52, 0x72, 0x52, 0x77, 0x52, 0x15,
-    0x35, 0x02, 0x00, 0x20, 0x80, 0x80, 0x00, 0x08,
-    0x00, 0x00, 0xc7, 0x52, 0x00, 0x02, 0x1d, 0x33,
-    0x3e, 0x3f, 0x50, 0x82, 0x8a, 0x93, 0xac, 0xb6,
-    0xb8, 0xb8, 0xb8, 0x2c, 0x0a, 0x70, 0x70, 0xca,
-    0x53, 0xdf, 0x53, 0x63, 0x0b, 0xeb, 0x53, 0xf1,
-    0x53, 0x06, 0x54, 0x9e, 0x54, 0x38, 0x54, 0x48,
-    0x54, 0x68, 0x54, 0xa2, 0x54, 0xf6, 0x54, 0x10,
-    0x55, 0x53, 0x55, 0x63, 0x55, 0x84, 0x55, 0x84,
-    0x55, 0x99, 0x55, 0xab, 0x55, 0xb3, 0x55, 0xc2,
-    0x55, 0x16, 0x57, 0x06, 0x56, 0x17, 0x57, 0x51,
-    0x56, 0x74, 0x56, 0x07, 0x52, 0xee, 0x58, 0xce,
-    0x57, 0xf4, 0x57, 0x0d, 0x58, 0x8b, 0x57, 0x32,
-    0x58, 0x31, 0x58, 0xac, 0x58, 0xe4, 0x14, 0xf2,
-    0x58, 0xf7, 0x58, 0x06, 0x59, 0x1a, 0x59, 0x22,
-    0x59, 0x62, 0x59, 0xa8, 0x16, 0xea, 0x16, 0xec,
-    0x59, 0x1b, 0x5a, 0x27, 0x5a, 0xd8, 0x59, 0x66,
-    0x5a, 0xee, 0x36, 0xfc, 0x36, 0x08, 0x5b, 0x3e,
-    0x5b, 0x3e, 0x5b, 0xc8, 0x19, 0xc3, 0x5b, 0xd8,
-    0x5b, 0xe7, 0x5b, 0xf3, 0x5b, 0x18, 0x1b, 0xff,
-    0x5b, 0x06, 0x5c, 0x53, 0x5f, 0x22, 0x5c, 0x81,
-    0x37, 0x60, 0x5c, 0x6e, 0x5c, 0xc0, 0x5c, 0x8d,
-    0x5c, 0xe4, 0x1d, 0x43, 0x5d, 0xe6, 0x1d, 0x6e,
-    0x5d, 0x6b, 0x5d, 0x7c, 0x5d, 0xe1, 0x5d, 0xe2,
-    0x5d, 0x2f, 0x38, 0xfd, 0x5d, 0x28, 0x5e, 0x3d,
-    0x5e, 0x69, 0x5e, 0x62, 0x38, 0x83, 0x21, 0x7c,
-    0x38, 0xb0, 0x5e, 0xb3, 0x5e, 0xb6, 0x5e, 0xca,
-    0x5e, 0x92, 0xa3, 0xfe, 0x5e, 0x31, 0x23, 0x31,
-    0x23, 0x01, 0x82, 0x22, 0x5f, 0x22, 0x5f, 0xc7,
-    0x38, 0xb8, 0x32, 0xda, 0x61, 0x62, 0x5f, 0x6b,
-    0x5f, 0xe3, 0x38, 0x9a, 0x5f, 0xcd, 0x5f, 0xd7,
-    0x5f, 0xf9, 0x5f, 0x81, 0x60, 0x3a, 0x39, 0x1c,
-    0x39, 0x94, 0x60, 0xd4, 0x26, 0xc7, 0x60, 0x02,
-    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x08, 0x00,
-    0x80, 0x08, 0x00, 0x00, 0x08, 0x80, 0x28, 0x80,
-    0x02, 0x00, 0x00, 0x02, 0x48, 0x61, 0x00, 0x04,
-    0x06, 0x04, 0x32, 0x46, 0x6a, 0x5c, 0x67, 0x96,
-    0xaa, 0xae, 0xc8, 0xd3, 0x5d, 0x62, 0x00, 0x54,
-    0x77, 0xf3, 0x0c, 0x2b, 0x3d, 0x63, 0xfc, 0x62,
-    0x68, 0x63, 0x83, 0x63, 0xe4, 0x63, 0xf1, 0x2b,
-    0x22, 0x64, 0xc5, 0x63, 0xa9, 0x63, 0x2e, 0x3a,
-    0x69, 0x64, 0x7e, 0x64, 0x9d, 0x64, 0x77, 0x64,
-    0x6c, 0x3a, 0x4f, 0x65, 0x6c, 0x65, 0x0a, 0x30,
-    0xe3, 0x65, 0xf8, 0x66, 0x49, 0x66, 0x19, 0x3b,
-    0x91, 0x66, 0x08, 0x3b, 0xe4, 0x3a, 0x92, 0x51,
-    0x95, 0x51, 0x00, 0x67, 0x9c, 0x66, 0xad, 0x80,
-    0xd9, 0x43, 0x17, 0x67, 0x1b, 0x67, 0x21, 0x67,
-    0x5e, 0x67, 0x53, 0x67, 0xc3, 0x33, 0x49, 0x3b,
-    0xfa, 0x67, 0x85, 0x67, 0x52, 0x68, 0x85, 0x68,
-    0x6d, 0x34, 0x8e, 0x68, 0x1f, 0x68, 0x14, 0x69,
-    0x9d, 0x3b, 0x42, 0x69, 0xa3, 0x69, 0xea, 0x69,
-    0xa8, 0x6a, 0xa3, 0x36, 0xdb, 0x6a, 0x18, 0x3c,
-    0x21, 0x6b, 0xa7, 0x38, 0x54, 0x6b, 0x4e, 0x3c,
-    0x72, 0x6b, 0x9f, 0x6b, 0xba, 0x6b, 0xbb, 0x6b,
-    0x8d, 0x3a, 0x0b, 0x1d, 0xfa, 0x3a, 0x4e, 0x6c,
-    0xbc, 0x3c, 0xbf, 0x6c, 0xcd, 0x6c, 0x67, 0x6c,
-    0x16, 0x6d, 0x3e, 0x6d, 0x77, 0x6d, 0x41, 0x6d,
-    0x69, 0x6d, 0x78, 0x6d, 0x85, 0x6d, 0x1e, 0x3d,
-    0x34, 0x6d, 0x2f, 0x6e, 0x6e, 0x6e, 0x33, 0x3d,
-    0xcb, 0x6e, 0xc7, 0x6e, 0xd1, 0x3e, 0xf9, 0x6d,
-    0x6e, 0x6f, 0x5e, 0x3f, 0x8e, 0x3f, 0xc6, 0x6f,
-    0x39, 0x70, 0x1e, 0x70, 0x1b, 0x70, 0x96, 0x3d,
-    0x4a, 0x70, 0x7d, 0x70, 0x77, 0x70, 0xad, 0x70,
-    0x25, 0x05, 0x45, 0x71, 0x63, 0x42, 0x9c, 0x71,
-    0xab, 0x43, 0x28, 0x72, 0x35, 0x72, 0x50, 0x72,
-    0x08, 0x46, 0x80, 0x72, 0x95, 0x72, 0x35, 0x47,
-    0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
-    0x00, 0x08, 0x80, 0x00, 0x00, 0x02, 0x02, 0x80,
-    0x8a, 0x00, 0x00, 0x20, 0x00, 0x08, 0x0a, 0x00,
-    0x80, 0x88, 0x80, 0x20, 0x14, 0x48, 0x7a, 0x73,
-    0x8b, 0x73, 0xac, 0x3e, 0xa5, 0x73, 0xb8, 0x3e,
-    0xb8, 0x3e, 0x47, 0x74, 0x5c, 0x74, 0x71, 0x74,
-    0x85, 0x74, 0xca, 0x74, 0x1b, 0x3f, 0x24, 0x75,
-    0x36, 0x4c, 0x3e, 0x75, 0x92, 0x4c, 0x70, 0x75,
-    0x9f, 0x21, 0x10, 0x76, 0xa1, 0x4f, 0xb8, 0x4f,
-    0x44, 0x50, 0xfc, 0x3f, 0x08, 0x40, 0xf4, 0x76,
-    0xf3, 0x50, 0xf2, 0x50, 0x19, 0x51, 0x33, 0x51,
-    0x1e, 0x77, 0x1f, 0x77, 0x1f, 0x77, 0x4a, 0x77,
-    0x39, 0x40, 0x8b, 0x77, 0x46, 0x40, 0x96, 0x40,
-    0x1d, 0x54, 0x4e, 0x78, 0x8c, 0x78, 0xcc, 0x78,
-    0xe3, 0x40, 0x26, 0x56, 0x56, 0x79, 0x9a, 0x56,
-    0xc5, 0x56, 0x8f, 0x79, 0xeb, 0x79, 0x2f, 0x41,
-    0x40, 0x7a, 0x4a, 0x7a, 0x4f, 0x7a, 0x7c, 0x59,
-    0xa7, 0x5a, 0xa7, 0x5a, 0xee, 0x7a, 0x02, 0x42,
-    0xab, 0x5b, 0xc6, 0x7b, 0xc9, 0x7b, 0x27, 0x42,
-    0x80, 0x5c, 0xd2, 0x7c, 0xa0, 0x42, 0xe8, 0x7c,
-    0xe3, 0x7c, 0x00, 0x7d, 0x86, 0x5f, 0x63, 0x7d,
-    0x01, 0x43, 0xc7, 0x7d, 0x02, 0x7e, 0x45, 0x7e,
-    0x34, 0x43, 0x28, 0x62, 0x47, 0x62, 0x59, 0x43,
-    0xd9, 0x62, 0x7a, 0x7f, 0x3e, 0x63, 0x95, 0x7f,
-    0xfa, 0x7f, 0x05, 0x80, 0xda, 0x64, 0x23, 0x65,
-    0x60, 0x80, 0xa8, 0x65, 0x70, 0x80, 0x5f, 0x33,
-    0xd5, 0x43, 0xb2, 0x80, 0x03, 0x81, 0x0b, 0x44,
-    0x3e, 0x81, 0xb5, 0x5a, 0xa7, 0x67, 0xb5, 0x67,
-    0x93, 0x33, 0x9c, 0x33, 0x01, 0x82, 0x04, 0x82,
-    0x9e, 0x8f, 0x6b, 0x44, 0x91, 0x82, 0x8b, 0x82,
-    0x9d, 0x82, 0xb3, 0x52, 0xb1, 0x82, 0xb3, 0x82,
-    0xbd, 0x82, 0xe6, 0x82, 0x3c, 0x6b, 0xe5, 0x82,
-    0x1d, 0x83, 0x63, 0x83, 0xad, 0x83, 0x23, 0x83,
-    0xbd, 0x83, 0xe7, 0x83, 0x57, 0x84, 0x53, 0x83,
-    0xca, 0x83, 0xcc, 0x83, 0xdc, 0x83, 0x36, 0x6c,
-    0x6b, 0x6d, 0x02, 0x00, 0x00, 0x20, 0x22, 0x2a,
-    0xa0, 0x0a, 0x00, 0x20, 0x80, 0x28, 0x00, 0xa8,
-    0x20, 0x20, 0x00, 0x02, 0x80, 0x22, 0x02, 0x8a,
-    0x08, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x02, 0x00,
-    0x00, 0x28, 0xd5, 0x6c, 0x2b, 0x45, 0xf1, 0x84,
-    0xf3, 0x84, 0x16, 0x85, 0xca, 0x73, 0x64, 0x85,
-    0x2c, 0x6f, 0x5d, 0x45, 0x61, 0x45, 0xb1, 0x6f,
-    0xd2, 0x70, 0x6b, 0x45, 0x50, 0x86, 0x5c, 0x86,
-    0x67, 0x86, 0x69, 0x86, 0xa9, 0x86, 0x88, 0x86,
-    0x0e, 0x87, 0xe2, 0x86, 0x79, 0x87, 0x28, 0x87,
-    0x6b, 0x87, 0x86, 0x87, 0xd7, 0x45, 0xe1, 0x87,
-    0x01, 0x88, 0xf9, 0x45, 0x60, 0x88, 0x63, 0x88,
-    0x67, 0x76, 0xd7, 0x88, 0xde, 0x88, 0x35, 0x46,
-    0xfa, 0x88, 0xbb, 0x34, 0xae, 0x78, 0x66, 0x79,
-    0xbe, 0x46, 0xc7, 0x46, 0xa0, 0x8a, 0xed, 0x8a,
-    0x8a, 0x8b, 0x55, 0x8c, 0xa8, 0x7c, 0xab, 0x8c,
-    0xc1, 0x8c, 0x1b, 0x8d, 0x77, 0x8d, 0x2f, 0x7f,
-    0x04, 0x08, 0xcb, 0x8d, 0xbc, 0x8d, 0xf0, 0x8d,
-    0xde, 0x08, 0xd4, 0x8e, 0x38, 0x8f, 0xd2, 0x85,
-    0xed, 0x85, 0x94, 0x90, 0xf1, 0x90, 0x11, 0x91,
-    0x2e, 0x87, 0x1b, 0x91, 0x38, 0x92, 0xd7, 0x92,
-    0xd8, 0x92, 0x7c, 0x92, 0xf9, 0x93, 0x15, 0x94,
-    0xfa, 0x8b, 0x8b, 0x95, 0x95, 0x49, 0xb7, 0x95,
-    0x77, 0x8d, 0xe6, 0x49, 0xc3, 0x96, 0xb2, 0x5d,
-    0x23, 0x97, 0x45, 0x91, 0x1a, 0x92, 0x6e, 0x4a,
-    0x76, 0x4a, 0xe0, 0x97, 0x0a, 0x94, 0xb2, 0x4a,
-    0x96, 0x94, 0x0b, 0x98, 0x0b, 0x98, 0x29, 0x98,
-    0xb6, 0x95, 0xe2, 0x98, 0x33, 0x4b, 0x29, 0x99,
-    0xa7, 0x99, 0xc2, 0x99, 0xfe, 0x99, 0xce, 0x4b,
-    0x30, 0x9b, 0x12, 0x9b, 0x40, 0x9c, 0xfd, 0x9c,
-    0xce, 0x4c, 0xed, 0x4c, 0x67, 0x9d, 0xce, 0xa0,
-    0xf8, 0x4c, 0x05, 0xa1, 0x0e, 0xa2, 0x91, 0xa2,
-    0xbb, 0x9e, 0x56, 0x4d, 0xf9, 0x9e, 0xfe, 0x9e,
-    0x05, 0x9f, 0x0f, 0x9f, 0x16, 0x9f, 0x3b, 0x9f,
-    0x00, 0xa6, 0x02, 0x88, 0xa0, 0x00, 0x00, 0x00,
-    0x00, 0x80, 0x00, 0x28, 0x00, 0x08, 0xa0, 0x80,
-    0xa0, 0x80, 0x00, 0x80, 0x80, 0x00, 0x0a, 0x88,
-    0x80, 0x00, 0x80, 0x00, 0x20, 0x2a, 0x00, 0x80,
+    0x0c, 0x0e, 0x10, 0x44, 0x90, 0x77, 0x45, 0x28,
+    0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06, 0x33,
+    0x06, 0x17, 0x10, 0x11, 0x12, 0x13, 0x00, 0x06,
+    0x0e, 0x02, 0x0f, 0x34, 0x06, 0x2a, 0x06, 0x2b,
+    0x06, 0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x00,
+    0x00, 0x3a, 0x06, 0x2d, 0x06, 0x00, 0x00, 0x4a,
+    0x06, 0x00, 0x00, 0x44, 0x06, 0x00, 0x00, 0x46,
+    0x06, 0x33, 0x06, 0x39, 0x06, 0x00, 0x00, 0x35,
+    0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06, 0x00,
+    0x00, 0x00, 0x00, 0x2e, 0x06, 0x00, 0x00, 0x36,
+    0x06, 0x00, 0x00, 0x3a, 0x06, 0x00, 0x00, 0xba,
+    0x06, 0x00, 0x00, 0x6f, 0x06, 0x00, 0x00, 0x28,
+    0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06, 0x00,
+    0x00, 0x00, 0x00, 0x2d, 0x06, 0x37, 0x06, 0x4a,
+    0x06, 0x43, 0x06, 0x00, 0x00, 0x45, 0x06, 0x46,
+    0x06, 0x33, 0x06, 0x39, 0x06, 0x41, 0x06, 0x35,
+    0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06, 0x2a,
+    0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00, 0x36,
+    0x06, 0x38, 0x06, 0x3a, 0x06, 0x6e, 0x06, 0x00,
+    0x00, 0xa1, 0x06, 0x27, 0x06, 0x00, 0x01, 0x05,
+    0x08, 0x20, 0x21, 0x0b, 0x06, 0x10, 0x23, 0x2a,
+    0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b,
+    0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c,
+    0x0e, 0x10, 0x28, 0x06, 0x2c, 0x06, 0x2f, 0x06,
+    0x00, 0x00, 0x48, 0x06, 0x32, 0x06, 0x2d, 0x06,
+    0x37, 0x06, 0x4a, 0x06, 0x2a, 0x06, 0x1a, 0x1b,
+    0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a,
+    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x30,
+    0x2e, 0x30, 0x00, 0x2c, 0x00, 0x28, 0x00, 0x41,
+    0x00, 0x29, 0x00, 0x14, 0x30, 0x53, 0x00, 0x15,
+    0x30, 0x43, 0x52, 0x43, 0x44, 0x57, 0x5a, 0x41,
+    0x00, 0x48, 0x56, 0x4d, 0x56, 0x53, 0x44, 0x53,
+    0x53, 0x50, 0x50, 0x56, 0x57, 0x43, 0x4d, 0x43,
+    0x4d, 0x44, 0x4d, 0x52, 0x44, 0x4a, 0x4b, 0x30,
+    0x30, 0x00, 0x68, 0x68, 0x4b, 0x62, 0x57, 0x5b,
+    0xcc, 0x53, 0xc7, 0x30, 0x8c, 0x4e, 0x1a, 0x59,
+    0xe3, 0x89, 0x29, 0x59, 0xa4, 0x4e, 0x20, 0x66,
+    0x21, 0x71, 0x99, 0x65, 0x4d, 0x52, 0x8c, 0x5f,
+    0x8d, 0x51, 0xb0, 0x65, 0x1d, 0x52, 0x42, 0x7d,
+    0x1f, 0x75, 0xa9, 0x8c, 0xf0, 0x58, 0x39, 0x54,
+    0x14, 0x6f, 0x95, 0x62, 0x55, 0x63, 0x00, 0x4e,
+    0x09, 0x4e, 0x4a, 0x90, 0xe6, 0x5d, 0x2d, 0x4e,
+    0xf3, 0x53, 0x07, 0x63, 0x70, 0x8d, 0x53, 0x62,
+    0x81, 0x79, 0x7a, 0x7a, 0x08, 0x54, 0x80, 0x6e,
+    0x09, 0x67, 0x08, 0x67, 0x33, 0x75, 0x72, 0x52,
+    0xb6, 0x55, 0x4d, 0x91, 0x14, 0x30, 0x15, 0x30,
+    0x2c, 0x67, 0x09, 0x4e, 0x8c, 0x4e, 0x89, 0x5b,
+    0xb9, 0x70, 0x53, 0x62, 0xd7, 0x76, 0xdd, 0x52,
+    0x57, 0x65, 0x97, 0x5f, 0xef, 0x53, 0x38, 0x4e,
+    0x05, 0x00, 0x09, 0x22, 0x01, 0x60, 0x4f, 0xae,
+    0x4f, 0xbb, 0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99,
+    0x50, 0xe7, 0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a,
+    0x06, 0x4d, 0x51, 0x54, 0x51, 0x64, 0x51, 0x77,
+    0x51, 0x1c, 0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d,
+    0x51, 0x4b, 0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc,
+    0x4e, 0xac, 0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5,
+    0x51, 0x03, 0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46,
+    0x52, 0x72, 0x52, 0x77, 0x52, 0x15, 0x35, 0x02,
+    0x00, 0x20, 0x80, 0x80, 0x00, 0x08, 0x00, 0x00,
+    0xc7, 0x52, 0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f,
+    0x50, 0x82, 0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8,
+    0xb8, 0x2c, 0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf,
+    0x53, 0x63, 0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06,
+    0x54, 0x9e, 0x54, 0x38, 0x54, 0x48, 0x54, 0x68,
+    0x54, 0xa2, 0x54, 0xf6, 0x54, 0x10, 0x55, 0x53,
+    0x55, 0x63, 0x55, 0x84, 0x55, 0x84, 0x55, 0x99,
+    0x55, 0xab, 0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16,
+    0x57, 0x06, 0x56, 0x17, 0x57, 0x51, 0x56, 0x74,
+    0x56, 0x07, 0x52, 0xee, 0x58, 0xce, 0x57, 0xf4,
+    0x57, 0x0d, 0x58, 0x8b, 0x57, 0x32, 0x58, 0x31,
+    0x58, 0xac, 0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7,
+    0x58, 0x06, 0x59, 0x1a, 0x59, 0x22, 0x59, 0x62,
+    0x59, 0xa8, 0x16, 0xea, 0x16, 0xec, 0x59, 0x1b,
+    0x5a, 0x27, 0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee,
+    0x36, 0xfc, 0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e,
+    0x5b, 0xc8, 0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7,
+    0x5b, 0xf3, 0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06,
+    0x5c, 0x53, 0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60,
+    0x5c, 0x6e, 0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4,
+    0x1d, 0x43, 0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b,
+    0x5d, 0x7c, 0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f,
+    0x38, 0xfd, 0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69,
+    0x5e, 0x62, 0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0,
+    0x5e, 0xb3, 0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92,
+    0xa3, 0xfe, 0x5e, 0x31, 0x23, 0x31, 0x23, 0x01,
+    0x82, 0x22, 0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8,
+    0x32, 0xda, 0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3,
+    0x38, 0x9a, 0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9,
+    0x5f, 0x81, 0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94,
+    0x60, 0xd4, 0x26, 0xc7, 0x60, 0x02, 0x02, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x0a, 0x00, 0x00, 0x02, 0x08, 0x00, 0x80, 0x08,
+    0x00, 0x00, 0x08, 0x80, 0x28, 0x80, 0x02, 0x00,
+    0x00, 0x02, 0x48, 0x61, 0x00, 0x04, 0x06, 0x04,
+    0x32, 0x46, 0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae,
+    0xc8, 0xd3, 0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3,
+    0x0c, 0x2b, 0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63,
+    0x83, 0x63, 0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64,
+    0xc5, 0x63, 0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64,
+    0x7e, 0x64, 0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a,
+    0x4f, 0x65, 0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65,
+    0xf8, 0x66, 0x49, 0x66, 0x19, 0x3b, 0x91, 0x66,
+    0x08, 0x3b, 0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51,
+    0x00, 0x67, 0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43,
+    0x17, 0x67, 0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67,
+    0x53, 0x67, 0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67,
+    0x85, 0x67, 0x52, 0x68, 0x85, 0x68, 0x6d, 0x34,
+    0x8e, 0x68, 0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b,
+    0x42, 0x69, 0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a,
+    0xa3, 0x36, 0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b,
+    0xa7, 0x38, 0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b,
+    0x9f, 0x6b, 0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a,
+    0x0b, 0x1d, 0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c,
+    0xbf, 0x6c, 0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d,
+    0x3e, 0x6d, 0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d,
+    0x78, 0x6d, 0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d,
+    0x2f, 0x6e, 0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e,
+    0xc7, 0x6e, 0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f,
+    0x5e, 0x3f, 0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70,
+    0x1e, 0x70, 0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70,
+    0x7d, 0x70, 0x77, 0x70, 0xad, 0x70, 0x25, 0x05,
+    0x45, 0x71, 0x63, 0x42, 0x9c, 0x71, 0xab, 0x43,
+    0x28, 0x72, 0x35, 0x72, 0x50, 0x72, 0x08, 0x46,
+    0x80, 0x72, 0x95, 0x72, 0x35, 0x47, 0x02, 0x20,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x80, 0x00, 0x00, 0x02, 0x02, 0x80, 0x8a, 0x00,
+    0x00, 0x20, 0x00, 0x08, 0x0a, 0x00, 0x80, 0x88,
+    0x80, 0x20, 0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73,
+    0xac, 0x3e, 0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e,
+    0x47, 0x74, 0x5c, 0x74, 0x71, 0x74, 0x85, 0x74,
+    0xca, 0x74, 0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c,
+    0x3e, 0x75, 0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21,
+    0x10, 0x76, 0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50,
+    0xfc, 0x3f, 0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50,
+    0xf2, 0x50, 0x19, 0x51, 0x33, 0x51, 0x1e, 0x77,
+    0x1f, 0x77, 0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40,
+    0x8b, 0x77, 0x46, 0x40, 0x96, 0x40, 0x1d, 0x54,
+    0x4e, 0x78, 0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40,
+    0x26, 0x56, 0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56,
+    0x8f, 0x79, 0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a,
+    0x4a, 0x7a, 0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a,
+    0xa7, 0x5a, 0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b,
+    0xc6, 0x7b, 0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c,
+    0xd2, 0x7c, 0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c,
+    0x00, 0x7d, 0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43,
+    0xc7, 0x7d, 0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43,
+    0x28, 0x62, 0x47, 0x62, 0x59, 0x43, 0xd9, 0x62,
+    0x7a, 0x7f, 0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f,
+    0x05, 0x80, 0xda, 0x64, 0x23, 0x65, 0x60, 0x80,
+    0xa8, 0x65, 0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43,
+    0xb2, 0x80, 0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81,
+    0xb5, 0x5a, 0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33,
+    0x9c, 0x33, 0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f,
+    0x6b, 0x44, 0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82,
+    0xb3, 0x52, 0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82,
+    0xe6, 0x82, 0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83,
+    0x63, 0x83, 0xad, 0x83, 0x23, 0x83, 0xbd, 0x83,
+    0xe7, 0x83, 0x57, 0x84, 0x53, 0x83, 0xca, 0x83,
+    0xcc, 0x83, 0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d,
+    0x02, 0x00, 0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a,
+    0x00, 0x20, 0x80, 0x28, 0x00, 0xa8, 0x20, 0x20,
+    0x00, 0x02, 0x80, 0x22, 0x02, 0x8a, 0x08, 0x00,
+    0xaa, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x28,
+    0xd5, 0x6c, 0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84,
+    0x16, 0x85, 0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f,
+    0x5d, 0x45, 0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70,
+    0x6b, 0x45, 0x50, 0x86, 0x5c, 0x86, 0x67, 0x86,
+    0x69, 0x86, 0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87,
+    0xe2, 0x86, 0x79, 0x87, 0x28, 0x87, 0x6b, 0x87,
+    0x86, 0x87, 0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88,
+    0xf9, 0x45, 0x60, 0x88, 0x63, 0x88, 0x67, 0x76,
+    0xd7, 0x88, 0xde, 0x88, 0x35, 0x46, 0xfa, 0x88,
+    0xbb, 0x34, 0xae, 0x78, 0x66, 0x79, 0xbe, 0x46,
+    0xc7, 0x46, 0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b,
+    0x55, 0x8c, 0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c,
+    0x1b, 0x8d, 0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08,
+    0xcb, 0x8d, 0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08,
+    0xd4, 0x8e, 0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85,
+    0x94, 0x90, 0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87,
+    0x1b, 0x91, 0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92,
+    0x7c, 0x92, 0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b,
+    0x8b, 0x95, 0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d,
+    0xe6, 0x49, 0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97,
+    0x45, 0x91, 0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a,
+    0xe0, 0x97, 0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94,
+    0x0b, 0x98, 0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95,
+    0xe2, 0x98, 0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99,
+    0xc2, 0x99, 0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b,
+    0x12, 0x9b, 0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c,
+    0xed, 0x4c, 0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c,
+    0x05, 0xa1, 0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e,
+    0x56, 0x4d, 0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f,
+    0x0f, 0x9f, 0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6,
+    0x02, 0x88, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x80,
+    0x00, 0x28, 0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80,
+    0x00, 0x80, 0x80, 0x00, 0x0a, 0x88, 0x80, 0x00,
+    0x80, 0x00, 0x20, 0x2a, 0x00, 0x80,
 };
 
 static const uint16_t unicode_comp_table[944] = {
@@ -2162,8 +2173,8 @@ static const uint16_t unicode_comp_table[944] = {
     0x5704, 0x5706, 0x5708, 0x570a, 0x570c, 0x570e, 0x5710, 0x5712,
     0x5714, 0x5716, 0x5740, 0x5742, 0x5744, 0x5780, 0x5781, 0x57c0,
     0x57c1, 0x5800, 0x5801, 0x5840, 0x5841, 0x5880, 0x5881, 0x5900,
-    0x5901, 0x5902, 0x5903, 0x5940, 0x8e00, 0x8e02, 0x8e40, 0x8e80,
-    0x8e81, 0x8ec0, 0x8ec1, 0x8f01, 0x8f00, 0x8f03, 0x8f40, 0x8f41,
+    0x5901, 0x5902, 0x5903, 0x5940, 0x8e40, 0x8e42, 0x8e80, 0x8ec0,
+    0x8ec1, 0x8f00, 0x8f01, 0x8f41, 0x8f40, 0x8f43, 0x8f80, 0x8f81,
 };
 
 typedef enum {
@@ -2249,7 +2260,7 @@ static const char unicode_gc_name_table[] =
     "C,Other"                  "\0"
 ;
 
-static const uint8_t unicode_gc_table[3655] = {
+static const uint8_t unicode_gc_table[3719] = {
     0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13,
     0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
     0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e,
@@ -2329,7 +2340,7 @@ static const uint8_t unicode_gc_table[3655] = {
     0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x08, 0x40, 0x05,
     0x46, 0x67, 0x00, 0x46, 0x00, 0x66, 0xc0, 0x26,
     0x00, 0x45, 0x80, 0x25, 0x26, 0x20, 0xe9, 0x02,
-    0xe0, 0x00, 0xcb, 0x0f, 0x05, 0x06, 0x27, 0x16,
+    0xc0, 0x16, 0xcb, 0x0f, 0x05, 0x06, 0x27, 0x16,
     0xe5, 0x00, 0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00,
     0xe5, 0x02, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07,
     0x06, 0x87, 0x00, 0x06, 0x27, 0x00, 0x27, 0x26,
@@ -2345,260 +2356,259 @@ static const uint8_t unicode_gc_table[3655] = {
     0x00, 0xa0, 0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0,
     0x04, 0xe5, 0x28, 0x06, 0x25, 0xc6, 0x60, 0x0d,
     0xa5, 0x04, 0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36,
-    0xe0, 0x1d, 0x25, 0x00, 0x05, 0x20, 0x25, 0x00,
-    0x05, 0x20, 0x05, 0xa0, 0x65, 0x00, 0xc5, 0x00,
-    0x45, 0x00, 0x05, 0x00, 0x05, 0x20, 0x25, 0x00,
-    0x65, 0x06, 0x25, 0xa6, 0x00, 0x26, 0x05, 0x20,
-    0x85, 0x00, 0x04, 0x00, 0xa6, 0x20, 0xe9, 0x02,
-    0x20, 0x65, 0xe0, 0x18, 0x05, 0x4f, 0xf6, 0x07,
-    0x0f, 0x16, 0x4f, 0x26, 0xaf, 0xe9, 0x02, 0xeb,
-    0x02, 0x0f, 0x06, 0x0f, 0x06, 0x0f, 0x06, 0x12,
-    0x13, 0x12, 0x13, 0x27, 0xe5, 0x00, 0x00, 0xe5,
-    0x1c, 0x60, 0xe6, 0x06, 0x07, 0x86, 0x16, 0x26,
-    0x85, 0xe6, 0x03, 0x00, 0xe6, 0x1c, 0x00, 0xef,
-    0x00, 0x06, 0xaf, 0x00, 0x2f, 0x96, 0x6f, 0x36,
-    0xe0, 0x1d, 0xe5, 0x23, 0x27, 0x66, 0x07, 0xa6,
-    0x07, 0x26, 0x27, 0x26, 0x05, 0xe9, 0x02, 0xb6,
-    0xa5, 0x27, 0x26, 0x65, 0x46, 0x05, 0x47, 0x25,
-    0xc7, 0x45, 0x66, 0xe5, 0x05, 0x06, 0x27, 0x26,
-    0xa7, 0x06, 0x05, 0x07, 0xe9, 0x02, 0x47, 0x06,
-    0x2f, 0xe1, 0x1e, 0x00, 0x01, 0x80, 0x01, 0x20,
-    0xe2, 0x23, 0x16, 0x04, 0x42, 0xe5, 0x80, 0xc1,
-    0x00, 0x65, 0x20, 0xc5, 0x00, 0x05, 0x00, 0x65,
-    0x20, 0xe5, 0x21, 0x00, 0x65, 0x20, 0xe5, 0x19,
-    0x00, 0x65, 0x20, 0xc5, 0x00, 0x05, 0x00, 0x65,
-    0x20, 0xe5, 0x07, 0x00, 0xe5, 0x31, 0x00, 0x65,
-    0x20, 0xe5, 0x3b, 0x20, 0x46, 0xf6, 0x01, 0xeb,
-    0x0c, 0x40, 0xe5, 0x08, 0xef, 0x02, 0xa0, 0xe1,
-    0x4e, 0x20, 0xa2, 0x20, 0x11, 0xe5, 0x81, 0xe4,
-    0x36, 0xe5, 0x09, 0x17, 0xe5, 0x12, 0x12, 0x13,
-    0x40, 0xe5, 0x43, 0x56, 0x4a, 0xe5, 0x00, 0xc0,
-    0xe5, 0x05, 0x00, 0x65, 0x46, 0xe0, 0x03, 0xe5,
-    0x0a, 0x46, 0x36, 0xe0, 0x01, 0xe5, 0x0a, 0x26,
-    0xe0, 0x04, 0xe5, 0x05, 0x00, 0x45, 0x00, 0x26,
-    0xe0, 0x04, 0xe5, 0x2c, 0x26, 0x07, 0xc6, 0xe7,
-    0x00, 0x06, 0x27, 0xe6, 0x03, 0x56, 0x04, 0x56,
-    0x0d, 0x05, 0x06, 0x20, 0xe9, 0x02, 0xa0, 0xeb,
-    0x02, 0xa0, 0xb6, 0x11, 0x76, 0x46, 0x1b, 0x00,
-    0xe9, 0x02, 0xa0, 0xe5, 0x1b, 0x04, 0xe5, 0x2d,
-    0xc0, 0x85, 0x26, 0xe5, 0x1a, 0x06, 0x05, 0x80,
-    0xe5, 0x3e, 0xe0, 0x02, 0xe5, 0x17, 0x00, 0x46,
-    0x67, 0x26, 0x47, 0x60, 0x27, 0x06, 0xa7, 0x46,
-    0x60, 0x0f, 0x40, 0x36, 0xe9, 0x02, 0xe5, 0x16,
-    0x20, 0x85, 0xe0, 0x03, 0xe5, 0x24, 0x60, 0xe5,
-    0x12, 0xa0, 0xe9, 0x02, 0x0b, 0x40, 0xef, 0x1a,
-    0xe5, 0x0f, 0x26, 0x27, 0x06, 0x20, 0x36, 0xe5,
-    0x2d, 0x07, 0x06, 0x07, 0xc6, 0x00, 0x06, 0x07,
-    0x06, 0x27, 0xe6, 0x00, 0xa7, 0xe6, 0x02, 0x20,
-    0x06, 0xe9, 0x02, 0xa0, 0xe9, 0x02, 0xa0, 0xd6,
-    0x04, 0xb6, 0x20, 0xe6, 0x06, 0x08, 0xe0, 0x39,
-    0x66, 0x07, 0xe5, 0x27, 0x06, 0x07, 0x86, 0x07,
-    0x06, 0x87, 0x06, 0x27, 0xc5, 0x60, 0xe9, 0x02,
-    0xd6, 0xef, 0x02, 0xe6, 0x01, 0xef, 0x01, 0x40,
-    0x26, 0x07, 0xe5, 0x16, 0x07, 0x66, 0x27, 0x26,
-    0x07, 0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06,
-    0x07, 0x26, 0x47, 0x06, 0x07, 0x46, 0x27, 0xe0,
-    0x00, 0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00,
-    0x27, 0x26, 0x40, 0x96, 0xe9, 0x02, 0x40, 0x45,
-    0xe9, 0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01,
-    0xc0, 0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0,
-    0x00, 0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65,
-    0x06, 0x65, 0x27, 0x06, 0x25, 0x07, 0x26, 0xa0,
-    0xe2, 0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2,
-    0x1a, 0xe4, 0x1d, 0xe6, 0x32, 0x00, 0x86, 0xff,
-    0x80, 0x0e, 0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00,
-    0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00,
-    0xe1, 0x00, 0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20,
-    0xa1, 0x20, 0xe2, 0x00, 0x00, 0x01, 0x00, 0x01,
-    0x00, 0x01, 0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2,
-    0x06, 0x20, 0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00,
-    0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00,
-    0x22, 0x61, 0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00,
-    0x22, 0x61, 0x03, 0x4e, 0x62, 0x20, 0x22, 0x61,
-    0x00, 0x4e, 0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42,
-    0x00, 0x22, 0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03,
-    0x9b, 0xb1, 0x36, 0x14, 0x15, 0x12, 0x34, 0x15,
-    0x12, 0x14, 0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17,
-    0xf6, 0x01, 0x14, 0x15, 0x76, 0x30, 0x56, 0x0c,
-    0x12, 0x13, 0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6,
-    0x02, 0x17, 0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04,
-    0x20, 0xab, 0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02,
-    0x4c, 0x12, 0x13, 0x00, 0xe4, 0x05, 0x40, 0xed,
-    0x18, 0xe0, 0x08, 0xe6, 0x05, 0x68, 0x06, 0x48,
-    0xe6, 0x04, 0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01,
-    0x2f, 0x02, 0x41, 0x22, 0x41, 0x02, 0x0f, 0x01,
-    0x2f, 0x0c, 0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f,
-    0x01, 0x0f, 0x61, 0x0f, 0x02, 0x61, 0x02, 0x65,
-    0x02, 0x2f, 0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f,
-    0x0c, 0x2f, 0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b,
-    0x3f, 0x6a, 0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c,
-    0x6f, 0x0c, 0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c,
-    0xef, 0x17, 0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef,
-    0x17, 0xec, 0x80, 0x84, 0xef, 0x00, 0x12, 0x13,
-    0x12, 0x13, 0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13,
-    0xef, 0x49, 0x0c, 0xef, 0x16, 0xec, 0x11, 0xef,
-    0x20, 0xac, 0xef, 0x3d, 0xe0, 0x11, 0xef, 0x03,
-    0xe0, 0x0d, 0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e,
-    0xef, 0x80, 0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef,
-    0x2e, 0xec, 0x00, 0xef, 0x67, 0x0c, 0xef, 0x80,
-    0x70, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xeb,
-    0x16, 0xef, 0x24, 0x8c, 0x12, 0x13, 0xec, 0x17,
+    0xe0, 0x1d, 0x25, 0x00, 0x05, 0x00, 0x85, 0x00,
+    0xe5, 0x10, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x06,
+    0x25, 0xe6, 0x01, 0x05, 0x20, 0x85, 0x00, 0x04,
+    0x00, 0xa6, 0x20, 0xe9, 0x02, 0x20, 0x65, 0xe0,
+    0x18, 0x05, 0x4f, 0xf6, 0x07, 0x0f, 0x16, 0x4f,
+    0x26, 0xaf, 0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06,
+    0x0f, 0x06, 0x0f, 0x06, 0x12, 0x13, 0x12, 0x13,
+    0x27, 0xe5, 0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6,
+    0x06, 0x07, 0x86, 0x16, 0x26, 0x85, 0xe6, 0x03,
+    0x00, 0xe6, 0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf,
+    0x00, 0x2f, 0x96, 0x6f, 0x36, 0xe0, 0x1d, 0xe5,
+    0x23, 0x27, 0x66, 0x07, 0xa6, 0x07, 0x26, 0x27,
+    0x26, 0x05, 0xe9, 0x02, 0xb6, 0xa5, 0x27, 0x26,
+    0x65, 0x46, 0x05, 0x47, 0x25, 0xc7, 0x45, 0x66,
+    0xe5, 0x05, 0x06, 0x27, 0x26, 0xa7, 0x06, 0x05,
+    0x07, 0xe9, 0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e,
+    0x00, 0x01, 0x80, 0x01, 0x20, 0xe2, 0x23, 0x16,
+    0x04, 0x42, 0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20,
+    0xc5, 0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x21,
+    0x00, 0x65, 0x20, 0xe5, 0x19, 0x00, 0x65, 0x20,
+    0xc5, 0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x07,
+    0x00, 0xe5, 0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b,
+    0x20, 0x46, 0xf6, 0x01, 0xeb, 0x0c, 0x40, 0xe5,
+    0x08, 0xef, 0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2,
+    0x20, 0x11, 0xe5, 0x81, 0xe4, 0x0f, 0x16, 0xe5,
+    0x09, 0x17, 0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5,
+    0x43, 0x56, 0x4a, 0xe5, 0x00, 0xc0, 0xe5, 0x05,
+    0x00, 0x65, 0x46, 0xe0, 0x03, 0xe5, 0x0a, 0x46,
+    0x36, 0xe0, 0x01, 0xe5, 0x0a, 0x26, 0xe0, 0x04,
+    0xe5, 0x05, 0x00, 0x45, 0x00, 0x26, 0xe0, 0x04,
+    0xe5, 0x2c, 0x26, 0x07, 0xc6, 0xe7, 0x00, 0x06,
+    0x27, 0xe6, 0x03, 0x56, 0x04, 0x56, 0x0d, 0x05,
+    0x06, 0x20, 0xe9, 0x02, 0xa0, 0xeb, 0x02, 0xa0,
+    0xb6, 0x11, 0x76, 0x46, 0x1b, 0x00, 0xe9, 0x02,
+    0xa0, 0xe5, 0x1b, 0x04, 0xe5, 0x2d, 0xc0, 0x85,
+    0x26, 0xe5, 0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e,
+    0xe0, 0x02, 0xe5, 0x17, 0x00, 0x46, 0x67, 0x26,
+    0x47, 0x60, 0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f,
+    0x40, 0x36, 0xe9, 0x02, 0xe5, 0x16, 0x20, 0x85,
+    0xe0, 0x03, 0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0,
+    0xe9, 0x02, 0x0b, 0x40, 0xef, 0x1a, 0xe5, 0x0f,
+    0x26, 0x27, 0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07,
+    0x06, 0x07, 0xc6, 0x00, 0x06, 0x07, 0x06, 0x27,
+    0xe6, 0x00, 0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9,
+    0x02, 0xa0, 0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6,
+    0x20, 0xe6, 0x06, 0x08, 0xe0, 0x39, 0x66, 0x07,
+    0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87,
+    0x06, 0x27, 0xc5, 0x60, 0xe9, 0x02, 0xd6, 0xef,
+    0x02, 0xe6, 0x01, 0xef, 0x01, 0x40, 0x26, 0x07,
+    0xe5, 0x16, 0x07, 0x66, 0x27, 0x26, 0x07, 0x46,
+    0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06, 0x07, 0x26,
+    0x47, 0x06, 0x07, 0x46, 0x27, 0xe0, 0x00, 0x76,
+    0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00, 0x27, 0x26,
+    0x40, 0x96, 0xe9, 0x02, 0x40, 0x45, 0xe9, 0x02,
+    0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01, 0xc0, 0xe1,
+    0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0, 0x00, 0x46,
+    0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65, 0x06, 0xa5,
+    0x06, 0x25, 0x07, 0x26, 0x05, 0x80, 0xe2, 0x24,
+    0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2, 0x1a, 0xe4,
+    0x1d, 0xe6, 0x32, 0x00, 0x86, 0xff, 0x80, 0x0e,
+    0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00,
+    0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00,
+    0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20,
+    0xe2, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+    0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20,
+    0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00,
+    0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61,
+    0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61,
+    0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e,
+    0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22,
+    0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1,
+    0x36, 0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14,
+    0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01,
+    0x14, 0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13,
+    0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17,
+    0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab,
+    0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12,
+    0x13, 0x00, 0xe4, 0x05, 0x40, 0xed, 0x18, 0xe0,
+    0x08, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04,
+    0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02,
+    0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c,
+    0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f,
+    0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f,
+    0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f,
+    0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a,
+    0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c,
+    0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17,
+    0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec,
+    0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13,
+    0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49,
+    0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac,
+    0xef, 0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d,
+    0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80,
+    0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec,
+    0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef,
+    0x24, 0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0xec, 0x08, 0xef, 0x80, 0x78, 0xec,
-    0x7b, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0xec, 0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12,
     0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec,
-    0x37, 0x12, 0x13, 0x12, 0x13, 0xec, 0x18, 0x12,
-    0x13, 0xec, 0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d,
-    0x2f, 0xac, 0xef, 0x1f, 0x20, 0xef, 0x18, 0x20,
-    0xef, 0x29, 0x00, 0xef, 0x2d, 0x00, 0xe1, 0x27,
-    0x00, 0xe2, 0x27, 0x00, 0x5f, 0x21, 0x22, 0xdf,
-    0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24, 0x41,
-    0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f,
-    0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00, 0x02,
-    0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16,
-    0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01, 0xc5,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12,
+    0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec,
+    0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac,
+    0xef, 0x1f, 0x20, 0xef, 0x18, 0x20, 0xef, 0x60,
+    0xe1, 0x27, 0x00, 0xe2, 0x27, 0x00, 0x5f, 0x21,
+    0x22, 0xdf, 0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82,
+    0x24, 0x41, 0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f,
+    0x46, 0x3f, 0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e,
+    0x00, 0x02, 0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0,
+    0x04, 0x16, 0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0,
+    0x01, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
     0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
-    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xe6,
-    0x18, 0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14,
-    0x15, 0x16, 0x14, 0x15, 0xf6, 0x01, 0x11, 0x36,
-    0x11, 0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x96,
-    0x04, 0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12,
-    0xf6, 0x04, 0xe0, 0x29, 0xef, 0x12, 0x00, 0xef,
-    0x51, 0xe0, 0x04, 0xef, 0x80, 0x4e, 0xe0, 0x12,
-    0xef, 0x04, 0x60, 0x17, 0x56, 0x0f, 0x04, 0x05,
-    0x0a, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x2f, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x11, 0x12, 0x33, 0x0f,
-    0xea, 0x01, 0x66, 0x27, 0x11, 0x84, 0x2f, 0x4a,
-    0x04, 0x05, 0x16, 0x2f, 0x00, 0xe5, 0x4e, 0x20,
-    0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5, 0x52, 0x16,
-    0x44, 0x05, 0x80, 0xe5, 0x23, 0x00, 0xe5, 0x56,
-    0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5, 0x13, 0x80,
-    0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08, 0xef, 0x17,
-    0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb, 0x00, 0x0f,
-    0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02, 0xef, 0x1f,
-    0xeb, 0x07, 0xef, 0x37, 0x00, 0xef, 0x80, 0x78,
-    0xe5, 0x99, 0x2e, 0xe0, 0x02, 0xef, 0x38, 0xe5,
-    0xc0, 0x11, 0x68, 0xe0, 0x08, 0xe5, 0x0d, 0x04,
-    0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01,
-    0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84, 0x04,
-    0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c,
-    0xff, 0x26, 0x05, 0x06, 0x48, 0x16, 0xe6, 0x02,
-    0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e,
-    0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee, 0x0f,
-    0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36,
-    0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04, 0x2e,
-    0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02,
-    0x81, 0x02, 0x7f, 0xe0, 0x35, 0x05, 0x24, 0x02,
-    0xc5, 0x06, 0x45, 0x06, 0x65, 0x06, 0xe5, 0x0f,
-    0x27, 0x26, 0x07, 0x6f, 0x60, 0xab, 0x2f, 0x0d,
-    0x0f, 0xa0, 0xe5, 0x2c, 0x76, 0xe0, 0x00, 0x27,
-    0xe5, 0x2a, 0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36,
-    0xe9, 0x02, 0xa0, 0xe6, 0x0a, 0xa5, 0x56, 0x05,
-    0x16, 0x25, 0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6,
-    0x00, 0x36, 0xe5, 0x0f, 0xe6, 0x03, 0x27, 0xe0,
-    0x03, 0x16, 0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5,
-    0x27, 0x06, 0x27, 0x66, 0x27, 0x06, 0x67, 0xf6,
-    0x05, 0x00, 0x04, 0xe9, 0x02, 0x60, 0x36, 0x85,
-    0x06, 0x04, 0xe5, 0x01, 0xe9, 0x02, 0x85, 0x00,
-    0xe5, 0x21, 0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0,
-    0x01, 0x45, 0x06, 0xe5, 0x00, 0x06, 0x07, 0x20,
-    0xe9, 0x02, 0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5,
-    0x4f, 0x05, 0x07, 0x06, 0x07, 0xe5, 0x2a, 0x06,
-    0x05, 0x46, 0x25, 0x26, 0x85, 0x26, 0x05, 0x06,
-    0x05, 0xe0, 0x10, 0x25, 0x04, 0x36, 0xe5, 0x03,
-    0x07, 0x26, 0x27, 0x36, 0x05, 0x24, 0x07, 0x06,
-    0xe0, 0x02, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0xe0,
-    0x01, 0xc5, 0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e,
-    0x64, 0xa2, 0xe0, 0x02, 0xe2, 0x48, 0xe5, 0x1b,
-    0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06,
-    0x20, 0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c, 0xe0,
-    0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc,
-    0x87, 0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80, 0xe6,
-    0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04,
-    0x82, 0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c, 0xe5,
-    0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00,
-    0x25, 0x00, 0xe5, 0x64, 0xee, 0x08, 0xe0, 0x09,
-    0xe5, 0x80, 0xe3, 0x13, 0x12, 0xe0, 0x08, 0xe5,
-    0x38, 0x20, 0xe5, 0x2e, 0xe0, 0x20, 0xe5, 0x04,
-    0x0d, 0x0f, 0x20, 0xe6, 0x08, 0xd6, 0x12, 0x13,
-    0x16, 0xa0, 0xe6, 0x08, 0x16, 0x31, 0x30, 0x12,
+    0x00, 0xe6, 0x18, 0x36, 0x14, 0x15, 0x14, 0x15,
+    0x56, 0x14, 0x15, 0x16, 0x14, 0x15, 0xf6, 0x01,
+    0x11, 0x36, 0x11, 0x16, 0x14, 0x15, 0x36, 0x14,
+    0x15, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x96, 0x04, 0xf6, 0x02, 0x31, 0x76, 0x11,
+    0x16, 0x12, 0xf6, 0x05, 0xe0, 0x28, 0xef, 0x12,
+    0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80, 0x4e,
+    0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56, 0x0f,
+    0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0x12,
+    0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11, 0x84,
+    0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00, 0xe5,
+    0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5,
+    0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23, 0x00,
+    0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5,
+    0x13, 0x80, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08,
+    0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb,
+    0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02,
+    0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5,
+    0x99, 0x2e, 0xe0, 0x02, 0xef, 0x38, 0xe5, 0xc0,
+    0x11, 0x68, 0xe0, 0x08, 0xe5, 0x0d, 0x04, 0xe5,
+    0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01, 0xe5,
+    0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84, 0x04, 0x56,
+    0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c, 0xff,
+    0x26, 0x05, 0x06, 0x48, 0x16, 0xe6, 0x02, 0x16,
+    0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e, 0xea,
+    0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee, 0x0f, 0xe4,
+    0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36, 0x04,
+    0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04, 0x2e, 0x7f,
+    0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02, 0x81,
+    0x02, 0xff, 0x02, 0x20, 0x5f, 0x21, 0xe0, 0x28,
+    0x05, 0x24, 0x02, 0xc5, 0x06, 0x45, 0x06, 0x65,
+    0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07, 0x6f, 0x60,
+    0xab, 0x2f, 0x0d, 0x0f, 0xa0, 0xe5, 0x2c, 0x76,
+    0xe0, 0x00, 0x27, 0xe5, 0x2a, 0xe7, 0x08, 0x26,
+    0xe0, 0x00, 0x36, 0xe9, 0x02, 0xa0, 0xe6, 0x0a,
+    0xa5, 0x56, 0x05, 0x16, 0x25, 0x06, 0xe9, 0x02,
+    0xe5, 0x14, 0xe6, 0x00, 0x36, 0xe5, 0x0f, 0xe6,
+    0x03, 0x27, 0xe0, 0x03, 0x16, 0xe5, 0x15, 0x40,
+    0x46, 0x07, 0xe5, 0x27, 0x06, 0x27, 0x66, 0x27,
+    0x26, 0x47, 0xf6, 0x05, 0x00, 0x04, 0xe9, 0x02,
+    0x60, 0x36, 0x85, 0x06, 0x04, 0xe5, 0x01, 0xe9,
+    0x02, 0x85, 0x00, 0xe5, 0x21, 0xa6, 0x27, 0x26,
+    0x27, 0x26, 0xe0, 0x01, 0x45, 0x06, 0xe5, 0x00,
+    0x06, 0x07, 0x20, 0xe9, 0x02, 0x20, 0x76, 0xe5,
+    0x08, 0x04, 0xa5, 0x4f, 0x05, 0x07, 0x06, 0x07,
+    0xe5, 0x2a, 0x06, 0x05, 0x46, 0x25, 0x26, 0x85,
+    0x26, 0x05, 0x06, 0x05, 0xe0, 0x10, 0x25, 0x04,
+    0x36, 0xe5, 0x03, 0x07, 0x26, 0x27, 0x36, 0x05,
+    0x24, 0x07, 0x06, 0xe0, 0x02, 0xa5, 0x20, 0xa5,
+    0x20, 0xa5, 0xe0, 0x01, 0xc5, 0x00, 0xc5, 0x00,
+    0xe2, 0x23, 0x0e, 0x64, 0xe2, 0x00, 0xe0, 0x00,
+    0xe2, 0x48, 0xe5, 0x1b, 0x27, 0x06, 0x27, 0x06,
+    0x27, 0x16, 0x07, 0x06, 0x20, 0xe9, 0x02, 0xa0,
+    0xe5, 0xab, 0x1c, 0xe0, 0x04, 0xe5, 0x0f, 0x60,
+    0xe5, 0x29, 0x60, 0xfc, 0x87, 0x78, 0xfd, 0x98,
+    0x78, 0xe5, 0x80, 0xe6, 0x20, 0xe5, 0x62, 0xe0,
+    0x1e, 0xc2, 0xe0, 0x04, 0x82, 0x80, 0x05, 0x06,
+    0xe5, 0x02, 0x0c, 0xe5, 0x05, 0x00, 0x85, 0x00,
+    0x05, 0x00, 0x25, 0x00, 0x25, 0x00, 0xe5, 0x64,
+    0xee, 0x08, 0xe0, 0x09, 0xe5, 0x80, 0xe3, 0x13,
+    0x12, 0xe0, 0x08, 0xe5, 0x38, 0x20, 0xe5, 0x2e,
+    0xe0, 0x20, 0xe5, 0x04, 0x0d, 0x0f, 0x20, 0xe6,
+    0x08, 0xd6, 0x12, 0x13, 0x16, 0xa0, 0xe6, 0x08,
+    0x16, 0x31, 0x30, 0x12, 0x13, 0x12, 0x13, 0x12,
     0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x36,
-    0x12, 0x13, 0x76, 0x50, 0x56, 0x00, 0x76, 0x11,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x56, 0x0c,
-    0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60, 0x85,
-    0x00, 0xe5, 0x7f, 0x20, 0x1b, 0x00, 0x56, 0x0d,
-    0x56, 0x12, 0x13, 0x16, 0x0c, 0x16, 0x11, 0x36,
-    0xe9, 0x02, 0x36, 0x4c, 0x36, 0xe1, 0x12, 0x12,
-    0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12, 0x12,
-    0x0c, 0x13, 0x0c, 0x12, 0x13, 0x16, 0x12, 0x13,
-    0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24, 0xe5,
-    0x17, 0x40, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0x20,
-    0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d, 0x00,
-    0x0f, 0x6c, 0x2f, 0xe0, 0x02, 0x5b, 0x2f, 0x20,
-    0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5, 0x0b,
-    0x00, 0x25, 0x00, 0xe5, 0x07, 0x20, 0xe5, 0x06,
-    0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60, 0xeb,
-    0x25, 0x40, 0xef, 0x01, 0xea, 0x2d, 0x6b, 0xef,
-    0x09, 0x2b, 0x4f, 0x00, 0xef, 0x04, 0x60, 0x0f,
-    0xe0, 0x27, 0xef, 0x25, 0x06, 0xe0, 0x7a, 0xe5,
-    0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06, 0xeb,
-    0x13, 0x60, 0xe5, 0x18, 0x6b, 0xe0, 0x01, 0xe5,
-    0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5, 0x1e,
-    0x86, 0x80, 0xe5, 0x16, 0x00, 0x16, 0xe5, 0x1c,
-    0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22, 0xe1,
-    0x20, 0xe2, 0x20, 0xe5, 0x46, 0x20, 0xe9, 0x02,
-    0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60, 0xe5,
-    0x20, 0xe0, 0x00, 0xe5, 0x2c, 0xe0, 0x03, 0x16,
-    0xe0, 0x80, 0x08, 0xe5, 0x80, 0xaf, 0xe0, 0x01,
-    0xe5, 0x0e, 0xe0, 0x02, 0xe5, 0x00, 0xe0, 0x80,
-    0x10, 0xa5, 0x20, 0x05, 0x00, 0xe5, 0x24, 0x00,
-    0x25, 0x40, 0x05, 0x20, 0xe5, 0x0f, 0x00, 0x16,
-    0xeb, 0x00, 0xe5, 0x0f, 0x2f, 0xcb, 0xe5, 0x17,
-    0xe0, 0x00, 0xeb, 0x01, 0xe0, 0x28, 0xe5, 0x0b,
-    0x00, 0x25, 0x80, 0x8b, 0xe5, 0x0e, 0xab, 0x40,
-    0x16, 0xe5, 0x12, 0x80, 0x16, 0xe0, 0x38, 0xe5,
-    0x30, 0x60, 0x2b, 0x25, 0xeb, 0x08, 0x20, 0xeb,
-    0x26, 0x05, 0x46, 0x00, 0x26, 0x80, 0x66, 0x65,
-    0x00, 0x45, 0x00, 0xe5, 0x15, 0x20, 0x46, 0x60,
-    0x06, 0xeb, 0x01, 0xc0, 0xf6, 0x01, 0xc0, 0xe5,
-    0x15, 0x2b, 0x16, 0xe5, 0x15, 0x4b, 0xe0, 0x18,
-    0xe5, 0x00, 0x0f, 0xe5, 0x14, 0x26, 0x60, 0x8b,
-    0xd6, 0xe0, 0x01, 0xe5, 0x2e, 0x40, 0xd6, 0xe5,
-    0x0e, 0x20, 0xeb, 0x00, 0xe5, 0x0b, 0x80, 0xeb,
-    0x00, 0xe5, 0x0a, 0xc0, 0x76, 0xe0, 0x04, 0xcb,
-    0xe0, 0x48, 0xe5, 0x41, 0xe0, 0x2f, 0xe1, 0x2b,
-    0xe0, 0x05, 0xe2, 0x2b, 0xc0, 0xab, 0xe5, 0x1c,
-    0x66, 0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x9e,
-    0xeb, 0x17, 0xe0, 0x79, 0xe5, 0x15, 0xeb, 0x02,
-    0x05, 0xe0, 0x00, 0xe5, 0x0e, 0xe6, 0x03, 0x6b,
-    0x96, 0xe0, 0x80, 0x1e, 0x07, 0x06, 0x07, 0xe5,
-    0x2d, 0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c, 0xe9,
-    0x02, 0xe0, 0x07, 0x46, 0x07, 0xe5, 0x25, 0x47,
-    0x66, 0x27, 0x26, 0x36, 0x1b, 0x76, 0xe0, 0x03,
-    0x1b, 0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0,
-    0x46, 0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00,
-    0xe9, 0x02, 0x76, 0x05, 0x27, 0xe0, 0x01, 0xe5,
-    0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07,
-    0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76,
-    0x66, 0x16, 0x20, 0xe9, 0x02, 0x05, 0x16, 0x05,
-    0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a,
-    0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07,
-    0x26, 0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00, 0x05,
-    0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02,
-    0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00,
-    0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5,
-    0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5,
-    0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27,
-    0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05,
-    0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40,
-    0x86, 0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47, 0xe6,
-    0x00, 0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9,
-    0x02, 0x00, 0x16, 0x00, 0x16, 0x06, 0xe0, 0x19,
+    0x13, 0x12, 0x13, 0x36, 0x12, 0x13, 0x76, 0x50,
+    0x56, 0x00, 0x76, 0x11, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16,
+    0x0d, 0x36, 0x60, 0x85, 0x00, 0xe5, 0x7f, 0x20,
+    0x1b, 0x00, 0x56, 0x0d, 0x56, 0x12, 0x13, 0x16,
+    0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36, 0x4c,
+    0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e, 0x10,
+    0x0e, 0xe2, 0x12, 0x12, 0x0c, 0x13, 0x0c, 0x12,
+    0x13, 0x16, 0x12, 0x13, 0x36, 0xe5, 0x02, 0x04,
+    0xe5, 0x25, 0x24, 0xe5, 0x17, 0x40, 0xa5, 0x20,
+    0xa5, 0x20, 0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c,
+    0x0e, 0x0f, 0x2d, 0x00, 0x0f, 0x6c, 0x2f, 0xe0,
+    0x02, 0x5b, 0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5,
+    0x12, 0x00, 0xe5, 0x0b, 0x00, 0x25, 0x00, 0xe5,
+    0x07, 0x20, 0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73,
+    0x80, 0x56, 0x60, 0xeb, 0x25, 0x40, 0xef, 0x01,
+    0xea, 0x2d, 0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00,
+    0xef, 0x04, 0x60, 0x0f, 0xe0, 0x27, 0xef, 0x25,
+    0x06, 0xe0, 0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29,
+    0xe0, 0x07, 0x06, 0xeb, 0x13, 0x60, 0xe5, 0x18,
+    0x6b, 0xe0, 0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00,
+    0x0a, 0x80, 0xe5, 0x1e, 0x86, 0x80, 0xe5, 0x16,
+    0x00, 0x16, 0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16,
+    0x8a, 0xe0, 0x22, 0xe1, 0x20, 0xe2, 0x20, 0xe5,
+    0x46, 0x20, 0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60,
+    0xe2, 0x1c, 0x60, 0xe5, 0x20, 0xe0, 0x00, 0xe5,
+    0x2c, 0xe0, 0x03, 0x16, 0xe0, 0x80, 0x08, 0xe5,
+    0x80, 0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02,
+    0xe5, 0x00, 0xe0, 0x80, 0x10, 0xa5, 0x20, 0x05,
+    0x00, 0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20,
+    0xe5, 0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f,
+    0x2f, 0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01,
+    0xe0, 0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b,
+    0xe5, 0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80,
+    0x16, 0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25,
+    0xeb, 0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00,
+    0x26, 0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5,
+    0x15, 0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0,
+    0xf6, 0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5,
+    0x15, 0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5,
+    0x14, 0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5,
+    0x2e, 0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00,
+    0xe5, 0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0,
+    0x76, 0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41,
+    0xe0, 0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b,
+    0xc0, 0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9,
+    0x02, 0xe0, 0x80, 0x9e, 0xeb, 0x17, 0xe0, 0x79,
+    0xe5, 0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00, 0xe5,
+    0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x7e, 0xe5,
+    0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07, 0xe5, 0x2d,
+    0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c, 0xe9, 0x02,
+    0xe0, 0x07, 0x46, 0x07, 0xe5, 0x25, 0x47, 0x66,
+    0x27, 0x26, 0x36, 0x1b, 0x76, 0xe0, 0x03, 0x1b,
+    0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0, 0x46,
+    0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9,
+    0x02, 0x76, 0x05, 0x27, 0xe0, 0x01, 0xe5, 0x1b,
+    0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07, 0xe5,
+    0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76, 0x66,
+    0x16, 0x20, 0xe9, 0x02, 0x05, 0x16, 0x05, 0x56,
+    0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a, 0x00,
+    0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07, 0x26,
+    0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00, 0x05, 0x00,
+    0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02, 0x16,
+    0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00, 0x80,
+    0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5, 0x00,
+    0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00,
+    0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27, 0x06,
+    0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05, 0xa0,
+    0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40, 0x86,
+    0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47, 0xe6, 0x00,
+    0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9, 0x02,
+    0x00, 0x16, 0x00, 0x16, 0x06, 0x05, 0xe0, 0x18,
     0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67, 0x26,
     0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9,
     0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47, 0x66,
@@ -2607,99 +2617,108 @@ static const uint8_t unicode_gc_table[3655] = {
     0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03,
     0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b, 0xe5,
     0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06,
-    0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x2e, 0xe5, 0x13,
+    0x05, 0xc0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5, 0x13,
     0x20, 0x46, 0x27, 0x66, 0x07, 0x86, 0x60, 0xe9,
     0x02, 0x2b, 0x56, 0x0f, 0xe0, 0x80, 0x38, 0xe5,
     0x24, 0x47, 0xe6, 0x01, 0x07, 0x26, 0x16, 0xe0,
     0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9, 0x02, 0xeb,
-    0x01, 0xe0, 0x04, 0x05, 0xe0, 0x80, 0x78, 0x05,
-    0xe6, 0x02, 0xe5, 0x20, 0xa6, 0x07, 0x05, 0x66,
-    0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05, 0xa6, 0x27,
-    0x46, 0xe5, 0x20, 0x20, 0x65, 0xe6, 0x05, 0x07,
-    0x26, 0x56, 0x05, 0x96, 0xe0, 0x15, 0xe5, 0x31,
-    0xe0, 0x80, 0x7f, 0xe5, 0x01, 0x00, 0xe5, 0x1d,
-    0x07, 0xc6, 0x00, 0xa6, 0x07, 0x06, 0x05, 0x96,
-    0xe0, 0x02, 0xe9, 0x02, 0xeb, 0x0b, 0x40, 0x36,
-    0xe5, 0x16, 0x20, 0xe6, 0x0e, 0x00, 0x07, 0xc6,
-    0x07, 0x26, 0x07, 0x26, 0xe0, 0x41, 0xc5, 0x00,
-    0x25, 0x00, 0xe5, 0x1e, 0xa6, 0x40, 0x06, 0x00,
-    0x26, 0x00, 0xc6, 0x05, 0x06, 0xe0, 0x00, 0xe9,
-    0x02, 0xa0, 0xa5, 0x00, 0x25, 0x00, 0xe5, 0x18,
-    0x87, 0x00, 0x26, 0x00, 0x27, 0x06, 0x07, 0x06,
-    0x05, 0xc0, 0xe9, 0x02, 0xe0, 0x80, 0xae, 0xe5,
-    0x0b, 0x26, 0x27, 0x36, 0xe0, 0x80, 0x7f, 0xe5,
-    0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00, 0x96,
-    0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x8a, 0x34,
-    0xe5, 0x83, 0xa7, 0xe0, 0x8f, 0x49, 0xe5, 0x81,
-    0xbf, 0xe0, 0xa1, 0x31, 0xe5, 0x81, 0xb1, 0xc0,
-    0xe5, 0x17, 0x00, 0xe9, 0x02, 0x60, 0x36, 0xe0,
-    0x58, 0xe5, 0x16, 0x20, 0x86, 0x16, 0xe0, 0x02,
-    0xe5, 0x28, 0xc6, 0x96, 0x6f, 0x64, 0x16, 0x0f,
-    0xe0, 0x02, 0xe9, 0x02, 0x00, 0xcb, 0x00, 0xe5,
-    0x0d, 0x80, 0xe5, 0x0b, 0xe0, 0x82, 0x28, 0xe1,
-    0x18, 0xe2, 0x18, 0xeb, 0x0f, 0x76, 0xe0, 0x5d,
-    0xe5, 0x3d, 0xe0, 0x03, 0x05, 0xe7, 0x26, 0xe0,
-    0x08, 0x66, 0xe4, 0x05, 0xe0, 0x38, 0x24, 0xe0,
-    0x16, 0xe5, 0x97, 0x6a, 0xe0, 0x06, 0xe5, 0x82,
-    0x6b, 0xe0, 0xa4, 0x85, 0xe5, 0x80, 0x97, 0xe0,
-    0x49, 0xe5, 0x81, 0x04, 0xe0, 0x88, 0x7c, 0xe5,
-    0x63, 0x80, 0xe5, 0x05, 0x40, 0xe5, 0x01, 0xc0,
-    0xe5, 0x02, 0x20, 0x0f, 0x26, 0x16, 0x7b, 0xe0,
-    0x92, 0xd4, 0xef, 0x80, 0x6e, 0xe0, 0x02, 0xef,
-    0x1f, 0x20, 0xef, 0x34, 0x27, 0x46, 0x4f, 0xa7,
-    0xfb, 0x00, 0xe6, 0x00, 0x2f, 0xc6, 0xef, 0x16,
-    0x66, 0xef, 0x33, 0xe0, 0x0f, 0xef, 0x3a, 0x46,
-    0x0f, 0xe0, 0x80, 0x12, 0xeb, 0x0c, 0xe0, 0x04,
-    0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11, 0xe0, 0x7f,
-    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xc2, 0x00,
-    0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12, 0x01, 0x00,
-    0x21, 0x20, 0x01, 0x20, 0x21, 0x20, 0x61, 0x00,
-    0xe1, 0x00, 0x62, 0x00, 0x02, 0x00, 0xc2, 0x00,
-    0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12, 0x21, 0x00,
-    0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1, 0x00, 0xe2,
-    0x12, 0x21, 0x00, 0x61, 0x00, 0x81, 0x00, 0x01,
-    0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1, 0x12, 0xe2,
-    0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2,
-    0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2,
-    0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20, 0xe1, 0x11,
+    0x01, 0xe0, 0x04, 0x05, 0xe0, 0x80, 0x18, 0xe5,
+    0x00, 0x20, 0xe5, 0x1f, 0x47, 0x66, 0x20, 0x26,
+    0x67, 0x06, 0x05, 0x16, 0x05, 0x07, 0xe0, 0x13,
+    0x05, 0xe6, 0x02, 0xe5, 0x20, 0xa6, 0x07, 0x05,
+    0x66, 0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05, 0xa6,
+    0x27, 0x46, 0xe5, 0x26, 0xe6, 0x05, 0x07, 0x26,
+    0x56, 0x05, 0x96, 0xe0, 0x15, 0xe5, 0x31, 0xe0,
+    0x80, 0x7f, 0xe5, 0x01, 0x00, 0xe5, 0x1d, 0x07,
+    0xc6, 0x00, 0xa6, 0x07, 0x06, 0x05, 0x96, 0xe0,
+    0x02, 0xe9, 0x02, 0xeb, 0x0b, 0x40, 0x36, 0xe5,
+    0x16, 0x20, 0xe6, 0x0e, 0x00, 0x07, 0xc6, 0x07,
+    0x26, 0x07, 0x26, 0xe0, 0x41, 0xc5, 0x00, 0x25,
+    0x00, 0xe5, 0x1e, 0xa6, 0x40, 0x06, 0x00, 0x26,
+    0x00, 0xc6, 0x05, 0x06, 0xe0, 0x00, 0xe9, 0x02,
+    0xa0, 0xa5, 0x00, 0x25, 0x00, 0xe5, 0x18, 0x87,
+    0x00, 0x26, 0x00, 0x27, 0x06, 0x07, 0x06, 0x05,
+    0xc0, 0xe9, 0x02, 0xe0, 0x80, 0xae, 0xe5, 0x0b,
+    0x26, 0x27, 0x36, 0xe0, 0x80, 0x3f, 0xeb, 0x0d,
+    0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16,
+    0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00,
+    0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x8a,
+    0x34, 0xe5, 0x83, 0xa7, 0x00, 0xfb, 0x01, 0xe0,
+    0x8f, 0x3f, 0xe5, 0x81, 0xbf, 0xe0, 0xa1, 0x31,
+    0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00, 0xe9,
+    0x02, 0x60, 0x36, 0xe0, 0x58, 0xe5, 0x16, 0x20,
+    0x86, 0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96,
+    0x6f, 0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02,
+    0x00, 0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b,
+    0xe0, 0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb,
+    0x0f, 0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06,
+    0x05, 0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0,
+    0x38, 0x24, 0x16, 0x04, 0xe0, 0x14, 0xe5, 0x97,
+    0x70, 0xe0, 0x00, 0xe5, 0x82, 0x6b, 0xe0, 0xa4,
+    0x85, 0xe5, 0x80, 0x97, 0xe0, 0x29, 0x45, 0xe0,
+    0x09, 0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0,
+    0x88, 0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05, 0x40,
+    0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26,
+    0x16, 0x7b, 0xe0, 0x92, 0xd4, 0xef, 0x80, 0x6e,
+    0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27,
+    0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6, 0x00, 0x2f,
+    0xc6, 0xef, 0x16, 0x66, 0xef, 0x33, 0xe0, 0x0f,
+    0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x80, 0x12, 0xeb,
+    0x0c, 0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb,
+    0x11, 0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
+    0x12, 0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2,
+    0x12, 0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21,
+    0x20, 0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02,
+    0x00, 0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2,
+    0x12, 0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00,
+    0xc1, 0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00,
+    0x81, 0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12,
+    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12,
+    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12,
+    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14,
+    0x20, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2,
+    0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1,
+    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11,
     0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
-    0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2,
-    0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11,
-    0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c,
-    0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef, 0x81, 0x78,
-    0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef, 0x00, 0x06,
-    0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0, 0x07, 0x86,
-    0x00, 0xe6, 0x07, 0xe0, 0x84, 0xc8, 0xc6, 0x00,
-    0xe6, 0x09, 0x20, 0xc6, 0x00, 0x26, 0x00, 0x86,
-    0xe0, 0x87, 0x4d, 0xe5, 0x80, 0x3d, 0x20, 0xeb,
-    0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a, 0xe2, 0x1a,
-    0xc6, 0x80, 0xe9, 0x02, 0x60, 0x36, 0xe0, 0x82,
-    0x89, 0xeb, 0x33, 0x0f, 0x4b, 0x0d, 0x6b, 0xe0,
-    0x80, 0xc3, 0x65, 0x00, 0xe5, 0x13, 0x00, 0x25,
-    0x00, 0x05, 0x20, 0x05, 0x00, 0xe5, 0x02, 0x00,
-    0x65, 0x00, 0x05, 0x00, 0x05, 0xa0, 0x05, 0x60,
-    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x45, 0x00,
-    0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0x05, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x25, 0x00,
-    0x05, 0x20, 0x65, 0x00, 0xc5, 0x00, 0x65, 0x00,
-    0x65, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x00, 0xe5,
-    0x09, 0x80, 0x45, 0x00, 0x85, 0x00, 0xe5, 0x09,
-    0xe0, 0x2c, 0x2c, 0xe0, 0x80, 0x86, 0xef, 0x24,
-    0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef, 0x07, 0x20,
-    0xef, 0x07, 0x00, 0xef, 0x07, 0x00, 0xef, 0x1d,
-    0xe0, 0x02, 0xeb, 0x05, 0x40, 0xef, 0x54, 0x60,
-    0xef, 0x35, 0xe0, 0x31, 0xef, 0x15, 0xe0, 0x05,
-    0xef, 0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0,
-    0x06, 0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73,
-    0x8e, 0xef, 0x82, 0x4d, 0xe0, 0x03, 0xef, 0x05,
-    0x40, 0xef, 0x02, 0xa0, 0xef, 0x6c, 0xe0, 0x04,
-    0xef, 0x51, 0xe0, 0x1f, 0xef, 0x04, 0x60, 0xef,
-    0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0, 0xef, 0x20,
-    0xe0, 0x00, 0xef, 0x16, 0xe0, 0x4a, 0xef, 0x04,
-    0x60, 0xef, 0x27, 0x00, 0xef, 0x29, 0x20, 0x6f,
-    0x40, 0x0f, 0x00, 0xef, 0x1f, 0xe0, 0x05, 0xef,
-    0x02, 0xa0, 0x4f, 0xe0, 0x05, 0xef, 0x28, 0xe0,
-    0x58, 0xef, 0x06, 0xe0, 0x85, 0x0a, 0xe5, 0xc0,
+    0xe2, 0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a,
+    0xef, 0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a,
+    0xef, 0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96,
+    0xe0, 0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x84,
+    0xc8, 0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6, 0x00,
+    0x26, 0x00, 0x86, 0xe0, 0x80, 0x4d, 0xe5, 0x25,
+    0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05,
+    0x0f, 0xe0, 0x80, 0xe8, 0xe5, 0x24, 0x66, 0xe9,
+    0x02, 0x80, 0x0d, 0xe0, 0x84, 0x78, 0xe5, 0x80,
+    0x3d, 0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1,
+    0x1a, 0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02,
+    0x60, 0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f,
+    0x4b, 0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f,
+    0xeb, 0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5,
+    0x13, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
+    0xe5, 0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05,
+    0xa0, 0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05,
+    0x00, 0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05,
+    0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
+    0x00, 0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5,
+    0x00, 0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5,
+    0x02, 0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85,
+    0x00, 0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80,
+    0x86, 0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04,
+    0xef, 0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07,
+    0x00, 0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0x40,
+    0xef, 0x55, 0x40, 0xef, 0x35, 0xe0, 0x31, 0xef,
+    0x15, 0xe0, 0x05, 0xef, 0x24, 0x60, 0xef, 0x01,
+    0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0, 0x80, 0x12,
+    0xef, 0x80, 0x73, 0x8e, 0xef, 0x82, 0x4e, 0xe0,
+    0x02, 0xef, 0x05, 0x40, 0xef, 0x03, 0x80, 0xef,
+    0x6c, 0xe0, 0x04, 0xef, 0x51, 0xc0, 0xef, 0x04,
+    0xe0, 0x0c, 0xef, 0x04, 0x60, 0xef, 0x30, 0xe0,
+    0x00, 0xef, 0x02, 0xa0, 0xef, 0x20, 0xe0, 0x00,
+    0xef, 0x16, 0xe0, 0x4a, 0xef, 0x04, 0x00, 0xef,
+    0x5d, 0x00, 0x6f, 0x40, 0xef, 0x21, 0x20, 0xaf,
+    0x40, 0xef, 0x15, 0x20, 0xef, 0x7f, 0xe0, 0x04,
+    0xef, 0x06, 0x20, 0x6f, 0x60, 0x4f, 0x80, 0x4f,
+    0xe0, 0x05, 0xaf, 0xe0, 0x84, 0xe2, 0xe5, 0xc0,
     0x66, 0x4f, 0xe0, 0x21, 0xe5, 0x8f, 0xad, 0xe0,
     0x03, 0xe5, 0x80, 0x56, 0x20, 0xe5, 0x95, 0xfa,
     0xe0, 0x06, 0xe5, 0x9c, 0xa9, 0xe0, 0x8b, 0x97,
@@ -2745,6 +2764,7 @@ typedef enum {
     UNICODE_SCRIPT_Duployan,
     UNICODE_SCRIPT_Egyptian_Hieroglyphs,
     UNICODE_SCRIPT_Elbasan,
+    UNICODE_SCRIPT_Elymaic,
     UNICODE_SCRIPT_Ethiopic,
     UNICODE_SCRIPT_Georgian,
     UNICODE_SCRIPT_Glagolitic,
@@ -2802,10 +2822,12 @@ typedef enum {
     UNICODE_SCRIPT_Multani,
     UNICODE_SCRIPT_Myanmar,
     UNICODE_SCRIPT_Nabataean,
+    UNICODE_SCRIPT_Nandinagari,
     UNICODE_SCRIPT_New_Tai_Lue,
     UNICODE_SCRIPT_Newa,
     UNICODE_SCRIPT_Nko,
     UNICODE_SCRIPT_Nushu,
+    UNICODE_SCRIPT_Nyiakeng_Puachue_Hmong,
     UNICODE_SCRIPT_Ogham,
     UNICODE_SCRIPT_Ol_Chiki,
     UNICODE_SCRIPT_Old_Hungarian,
@@ -2856,6 +2878,7 @@ typedef enum {
     UNICODE_SCRIPT_Tirhuta,
     UNICODE_SCRIPT_Ugaritic,
     UNICODE_SCRIPT_Vai,
+    UNICODE_SCRIPT_Wancho,
     UNICODE_SCRIPT_Warang_Citi,
     UNICODE_SCRIPT_Yi,
     UNICODE_SCRIPT_Zanabazar_Square,
@@ -2897,6 +2920,7 @@ static const char unicode_script_name_table[] =
     "Duployan,Dupl"               "\0"
     "Egyptian_Hieroglyphs,Egyp"   "\0"
     "Elbasan,Elba"                "\0"
+    "Elymaic,Elym"                "\0"
     "Ethiopic,Ethi"               "\0"
     "Georgian,Geor"               "\0"
     "Glagolitic,Glag"             "\0"
@@ -2954,10 +2978,12 @@ static const char unicode_script_name_table[] =
     "Multani,Mult"                "\0"
     "Myanmar,Mymr"                "\0"
     "Nabataean,Nbat"              "\0"
+    "Nandinagari,Nand"            "\0"
     "New_Tai_Lue,Talu"            "\0"
     "Newa,Newa"                   "\0"
     "Nko,Nkoo"                    "\0"
     "Nushu,Nshu"                  "\0"
+    "Nyiakeng_Puachue_Hmong,Hmnp" "\0"
     "Ogham,Ogam"                  "\0"
     "Ol_Chiki,Olck"               "\0"
     "Old_Hungarian,Hung"          "\0"
@@ -3008,296 +3034,301 @@ static const char unicode_script_name_table[] =
     "Tirhuta,Tirh"                "\0"
     "Ugaritic,Ugar"               "\0"
     "Vai,Vaii"                    "\0"
+    "Wancho,Wcho"                 "\0"
     "Warang_Citi,Wara"            "\0"
     "Yi,Yiii"                     "\0"
     "Zanabazar_Square,Zanb"       "\0"
 ;
 
-static const uint8_t unicode_script_table[2522] = {
-    0xc0, 0x18, 0x99, 0x41, 0x85, 0x18, 0x99, 0x41,
-    0xae, 0x18, 0x80, 0x41, 0x8e, 0x18, 0x80, 0x41,
-    0x84, 0x18, 0x96, 0x41, 0x80, 0x18, 0x9e, 0x41,
-    0x80, 0x18, 0xe1, 0x60, 0x41, 0xa6, 0x18, 0x84,
-    0x41, 0x84, 0x18, 0x81, 0x0d, 0x93, 0x18, 0xe0,
-    0x0f, 0x34, 0x83, 0x28, 0x80, 0x18, 0x82, 0x28,
-    0x01, 0x83, 0x28, 0x80, 0x18, 0x80, 0x28, 0x03,
-    0x80, 0x28, 0x80, 0x18, 0x80, 0x28, 0x80, 0x18,
-    0x82, 0x28, 0x00, 0x80, 0x28, 0x00, 0x93, 0x28,
-    0x00, 0xbe, 0x28, 0x8d, 0x19, 0x8f, 0x28, 0xe0,
-    0x24, 0x1c, 0x81, 0x34, 0xe0, 0x48, 0x1c, 0x00,
+static const uint8_t unicode_script_table[2565] = {
+    0xc0, 0x18, 0x99, 0x42, 0x85, 0x18, 0x99, 0x42,
+    0xae, 0x18, 0x80, 0x42, 0x8e, 0x18, 0x80, 0x42,
+    0x84, 0x18, 0x96, 0x42, 0x80, 0x18, 0x9e, 0x42,
+    0x80, 0x18, 0xe1, 0x60, 0x42, 0xa6, 0x18, 0x84,
+    0x42, 0x84, 0x18, 0x81, 0x0d, 0x93, 0x18, 0xe0,
+    0x0f, 0x35, 0x83, 0x29, 0x80, 0x18, 0x82, 0x29,
+    0x01, 0x83, 0x29, 0x80, 0x18, 0x80, 0x29, 0x03,
+    0x80, 0x29, 0x80, 0x18, 0x80, 0x29, 0x80, 0x18,
+    0x82, 0x29, 0x00, 0x80, 0x29, 0x00, 0x93, 0x29,
+    0x00, 0xbe, 0x29, 0x8d, 0x19, 0x8f, 0x29, 0xe0,
+    0x24, 0x1c, 0x81, 0x35, 0xe0, 0x48, 0x1c, 0x00,
     0xa5, 0x05, 0x01, 0xaf, 0x05, 0x80, 0x18, 0x80,
-    0x05, 0x01, 0x82, 0x05, 0x00, 0xb6, 0x31, 0x07,
-    0x9a, 0x31, 0x03, 0x85, 0x31, 0x0a, 0x84, 0x04,
+    0x05, 0x01, 0x82, 0x05, 0x00, 0xb6, 0x32, 0x07,
+    0x9a, 0x32, 0x03, 0x85, 0x32, 0x0a, 0x84, 0x04,
     0x80, 0x18, 0x85, 0x04, 0x80, 0x18, 0x8d, 0x04,
     0x80, 0x18, 0x80, 0x04, 0x00, 0x80, 0x04, 0x80,
     0x18, 0x9f, 0x04, 0x80, 0x18, 0x89, 0x04, 0x8a,
-    0x34, 0x99, 0x04, 0x80, 0x34, 0xe0, 0x0b, 0x04,
-    0x80, 0x18, 0xa1, 0x04, 0x8d, 0x81, 0x00, 0xbb,
-    0x81, 0x01, 0x82, 0x81, 0xaf, 0x04, 0xb1, 0x8b,
-    0x0d, 0xba, 0x5e, 0x01, 0x82, 0x5e, 0xad, 0x75,
-    0x01, 0x8e, 0x75, 0x00, 0x9b, 0x4c, 0x01, 0x80,
-    0x4c, 0x00, 0x8a, 0x81, 0x34, 0x94, 0x04, 0x00,
+    0x35, 0x99, 0x04, 0x80, 0x35, 0xe0, 0x0b, 0x04,
+    0x80, 0x18, 0xa1, 0x04, 0x8d, 0x84, 0x00, 0xbb,
+    0x84, 0x01, 0x82, 0x84, 0xaf, 0x04, 0xb1, 0x8e,
+    0x0d, 0xba, 0x60, 0x01, 0x82, 0x60, 0xad, 0x78,
+    0x01, 0x8e, 0x78, 0x00, 0x9b, 0x4d, 0x01, 0x80,
+    0x4d, 0x00, 0x8a, 0x84, 0x34, 0x94, 0x04, 0x00,
     0x87, 0x04, 0x14, 0x8e, 0x04, 0x80, 0x18, 0x9c,
-    0x04, 0xd0, 0x1e, 0x81, 0x34, 0x90, 0x1e, 0x81,
+    0x04, 0xd0, 0x1e, 0x83, 0x35, 0x8e, 0x1e, 0x81,
     0x18, 0x99, 0x1e, 0x83, 0x0b, 0x00, 0x87, 0x0b,
     0x01, 0x81, 0x0b, 0x01, 0x95, 0x0b, 0x00, 0x86,
     0x0b, 0x00, 0x80, 0x0b, 0x02, 0x83, 0x0b, 0x01,
     0x88, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x83, 0x0b,
     0x07, 0x80, 0x0b, 0x03, 0x81, 0x0b, 0x00, 0x84,
-    0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x2b, 0x00,
-    0x85, 0x2b, 0x03, 0x81, 0x2b, 0x01, 0x95, 0x2b,
-    0x00, 0x86, 0x2b, 0x00, 0x81, 0x2b, 0x00, 0x81,
-    0x2b, 0x00, 0x81, 0x2b, 0x01, 0x80, 0x2b, 0x00,
-    0x84, 0x2b, 0x03, 0x81, 0x2b, 0x01, 0x82, 0x2b,
-    0x02, 0x80, 0x2b, 0x06, 0x83, 0x2b, 0x00, 0x80,
-    0x2b, 0x06, 0x90, 0x2b, 0x09, 0x82, 0x29, 0x00,
-    0x88, 0x29, 0x00, 0x82, 0x29, 0x00, 0x95, 0x29,
-    0x00, 0x86, 0x29, 0x00, 0x81, 0x29, 0x00, 0x84,
-    0x29, 0x01, 0x89, 0x29, 0x00, 0x82, 0x29, 0x00,
-    0x82, 0x29, 0x01, 0x80, 0x29, 0x0e, 0x83, 0x29,
-    0x01, 0x8b, 0x29, 0x06, 0x86, 0x29, 0x00, 0x82,
-    0x6a, 0x00, 0x87, 0x6a, 0x01, 0x81, 0x6a, 0x01,
-    0x95, 0x6a, 0x00, 0x86, 0x6a, 0x00, 0x81, 0x6a,
-    0x00, 0x84, 0x6a, 0x01, 0x88, 0x6a, 0x01, 0x81,
-    0x6a, 0x01, 0x82, 0x6a, 0x07, 0x81, 0x6a, 0x03,
-    0x81, 0x6a, 0x00, 0x84, 0x6a, 0x01, 0x91, 0x6a,
-    0x09, 0x81, 0x88, 0x00, 0x85, 0x88, 0x02, 0x82,
-    0x88, 0x00, 0x83, 0x88, 0x02, 0x81, 0x88, 0x00,
-    0x80, 0x88, 0x00, 0x81, 0x88, 0x02, 0x81, 0x88,
-    0x02, 0x82, 0x88, 0x02, 0x8b, 0x88, 0x03, 0x84,
-    0x88, 0x02, 0x82, 0x88, 0x00, 0x83, 0x88, 0x01,
-    0x80, 0x88, 0x05, 0x80, 0x88, 0x0d, 0x94, 0x88,
-    0x04, 0x8c, 0x8a, 0x00, 0x82, 0x8a, 0x00, 0x96,
-    0x8a, 0x00, 0x8f, 0x8a, 0x02, 0x87, 0x8a, 0x00,
-    0x82, 0x8a, 0x00, 0x83, 0x8a, 0x06, 0x81, 0x8a,
-    0x00, 0x82, 0x8a, 0x04, 0x83, 0x8a, 0x01, 0x89,
-    0x8a, 0x07, 0x87, 0x8a, 0x8c, 0x39, 0x00, 0x82,
-    0x39, 0x00, 0x96, 0x39, 0x00, 0x89, 0x39, 0x00,
-    0x84, 0x39, 0x01, 0x88, 0x39, 0x00, 0x82, 0x39,
-    0x00, 0x83, 0x39, 0x06, 0x81, 0x39, 0x06, 0x80,
-    0x39, 0x00, 0x83, 0x39, 0x01, 0x89, 0x39, 0x00,
-    0x81, 0x39, 0x0c, 0x83, 0x4b, 0x00, 0x87, 0x4b,
-    0x00, 0x82, 0x4b, 0x00, 0xb2, 0x4b, 0x00, 0x82,
-    0x4b, 0x00, 0x85, 0x4b, 0x03, 0x8f, 0x4b, 0x01,
-    0x99, 0x4b, 0x01, 0x81, 0x7b, 0x00, 0x91, 0x7b,
-    0x02, 0x97, 0x7b, 0x00, 0x88, 0x7b, 0x00, 0x80,
-    0x7b, 0x01, 0x86, 0x7b, 0x02, 0x80, 0x7b, 0x03,
-    0x85, 0x7b, 0x00, 0x80, 0x7b, 0x00, 0x87, 0x7b,
-    0x05, 0x89, 0x7b, 0x01, 0x82, 0x7b, 0x0b, 0xb9,
-    0x8c, 0x03, 0x80, 0x18, 0x9b, 0x8c, 0x24, 0x81,
-    0x40, 0x00, 0x80, 0x40, 0x01, 0x81, 0x40, 0x00,
-    0x80, 0x40, 0x01, 0x80, 0x40, 0x05, 0x83, 0x40,
-    0x00, 0x86, 0x40, 0x00, 0x82, 0x40, 0x00, 0x80,
-    0x40, 0x00, 0x80, 0x40, 0x01, 0x81, 0x40, 0x00,
-    0x8c, 0x40, 0x00, 0x82, 0x40, 0x01, 0x84, 0x40,
-    0x00, 0x80, 0x40, 0x00, 0x85, 0x40, 0x01, 0x89,
-    0x40, 0x01, 0x83, 0x40, 0x1f, 0xc7, 0x8d, 0x00,
-    0xa3, 0x8d, 0x03, 0xa6, 0x8d, 0x00, 0xa3, 0x8d,
-    0x00, 0x8e, 0x8d, 0x00, 0x86, 0x8d, 0x83, 0x18,
-    0x81, 0x8d, 0x24, 0xe0, 0x3f, 0x5a, 0xa5, 0x24,
-    0x00, 0x80, 0x24, 0x04, 0x80, 0x24, 0x01, 0xaa,
-    0x24, 0x80, 0x18, 0x83, 0x24, 0xe0, 0x9f, 0x2d,
-    0xc8, 0x23, 0x00, 0x83, 0x23, 0x01, 0x86, 0x23,
-    0x00, 0x80, 0x23, 0x00, 0x83, 0x23, 0x01, 0xa8,
-    0x23, 0x00, 0x83, 0x23, 0x01, 0xa0, 0x23, 0x00,
-    0x83, 0x23, 0x01, 0x86, 0x23, 0x00, 0x80, 0x23,
-    0x00, 0x83, 0x23, 0x01, 0x8e, 0x23, 0x00, 0xb8,
-    0x23, 0x00, 0x83, 0x23, 0x01, 0xc2, 0x23, 0x01,
-    0x9f, 0x23, 0x02, 0x99, 0x23, 0x05, 0xd5, 0x17,
-    0x01, 0x85, 0x17, 0x01, 0xe2, 0x1f, 0x12, 0x9c,
-    0x60, 0x02, 0xca, 0x74, 0x82, 0x18, 0x8a, 0x74,
-    0x06, 0x8c, 0x82, 0x00, 0x86, 0x82, 0x0a, 0x94,
-    0x2f, 0x81, 0x18, 0x08, 0x93, 0x11, 0x0b, 0x8c,
-    0x83, 0x00, 0x82, 0x83, 0x00, 0x81, 0x83, 0x0b,
-    0xdd, 0x3d, 0x01, 0x89, 0x3d, 0x05, 0x89, 0x3d,
-    0x05, 0x81, 0x57, 0x81, 0x18, 0x80, 0x57, 0x80,
-    0x18, 0x88, 0x57, 0x00, 0x89, 0x57, 0x05, 0xd8,
-    0x57, 0x06, 0xaa, 0x57, 0x04, 0xc5, 0x12, 0x09,
-    0x9e, 0x43, 0x00, 0x8b, 0x43, 0x03, 0x8b, 0x43,
-    0x03, 0x80, 0x43, 0x02, 0x8b, 0x43, 0x9d, 0x84,
-    0x01, 0x84, 0x84, 0x0a, 0xab, 0x5c, 0x03, 0x99,
-    0x5c, 0x05, 0x8a, 0x5c, 0x02, 0x81, 0x5c, 0x9f,
-    0x3d, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x85,
-    0x00, 0x9c, 0x85, 0x01, 0x8a, 0x85, 0x05, 0x89,
-    0x85, 0x05, 0x8d, 0x85, 0x01, 0x8e, 0x34, 0x40,
-    0xcb, 0x07, 0x03, 0xac, 0x07, 0x02, 0xbf, 0x7f,
-    0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x42, 0x02,
-    0x8e, 0x42, 0x02, 0x82, 0x42, 0xaf, 0x61, 0x88,
-    0x1c, 0x06, 0xaa, 0x24, 0x01, 0x82, 0x24, 0x87,
-    0x7f, 0x07, 0x82, 0x34, 0x80, 0x18, 0x8c, 0x34,
-    0x80, 0x18, 0x86, 0x34, 0x83, 0x18, 0x80, 0x34,
-    0x85, 0x18, 0x80, 0x34, 0x82, 0x18, 0x81, 0x34,
-    0x05, 0xa5, 0x41, 0x84, 0x28, 0x80, 0x1c, 0xb0,
-    0x41, 0x84, 0x28, 0x83, 0x41, 0x84, 0x28, 0x8c,
-    0x41, 0x80, 0x1c, 0xc5, 0x41, 0x80, 0x28, 0xb9,
-    0x34, 0x00, 0x84, 0x34, 0xe0, 0x9f, 0x41, 0x95,
-    0x28, 0x01, 0x85, 0x28, 0x01, 0xa5, 0x28, 0x01,
-    0x85, 0x28, 0x01, 0x87, 0x28, 0x00, 0x80, 0x28,
-    0x00, 0x80, 0x28, 0x00, 0x80, 0x28, 0x00, 0x9e,
-    0x28, 0x01, 0xb4, 0x28, 0x00, 0x8e, 0x28, 0x00,
-    0x8d, 0x28, 0x01, 0x85, 0x28, 0x00, 0x92, 0x28,
-    0x01, 0x82, 0x28, 0x00, 0x88, 0x28, 0x00, 0x8b,
-    0x18, 0x81, 0x34, 0xd6, 0x18, 0x00, 0x8a, 0x18,
-    0x80, 0x41, 0x01, 0x8a, 0x18, 0x80, 0x41, 0x8e,
-    0x18, 0x00, 0x8c, 0x41, 0x02, 0x9f, 0x18, 0x0f,
-    0xa0, 0x34, 0x0e, 0xa5, 0x18, 0x80, 0x28, 0x82,
-    0x18, 0x81, 0x41, 0x85, 0x18, 0x80, 0x41, 0x9a,
-    0x18, 0x80, 0x41, 0x90, 0x18, 0xa8, 0x41, 0x82,
-    0x18, 0x03, 0xe2, 0x36, 0x18, 0x18, 0x8a, 0x18,
-    0x14, 0xe3, 0x3f, 0x18, 0xe0, 0x9f, 0x0f, 0xe2,
-    0x13, 0x18, 0x01, 0x9f, 0x18, 0x01, 0xb0, 0x18,
-    0x00, 0xb4, 0x18, 0x00, 0xae, 0x25, 0x00, 0xae,
-    0x25, 0x00, 0x9f, 0x41, 0xe0, 0x13, 0x19, 0x04,
-    0x86, 0x19, 0xa5, 0x24, 0x00, 0x80, 0x24, 0x04,
-    0x80, 0x24, 0x01, 0xb7, 0x8e, 0x06, 0x81, 0x8e,
-    0x0d, 0x80, 0x8e, 0x96, 0x23, 0x08, 0x86, 0x23,
-    0x00, 0x86, 0x23, 0x00, 0x86, 0x23, 0x00, 0x86,
-    0x23, 0x00, 0x86, 0x23, 0x00, 0x86, 0x23, 0x00,
-    0x86, 0x23, 0x00, 0x86, 0x23, 0x00, 0x9f, 0x1c,
-    0xce, 0x18, 0x30, 0x99, 0x2c, 0x00, 0xd8, 0x2c,
-    0x0b, 0xe0, 0x75, 0x2c, 0x19, 0x8b, 0x18, 0x03,
-    0x84, 0x18, 0x80, 0x2c, 0x80, 0x18, 0x80, 0x2c,
-    0x98, 0x18, 0x88, 0x2c, 0x83, 0x34, 0x81, 0x2d,
-    0x87, 0x18, 0x83, 0x2c, 0x83, 0x18, 0x00, 0xd5,
-    0x32, 0x01, 0x81, 0x34, 0x81, 0x18, 0x82, 0x32,
-    0x80, 0x18, 0xd9, 0x3a, 0x81, 0x18, 0x82, 0x3a,
-    0x04, 0xaa, 0x0d, 0x00, 0xdd, 0x2d, 0x00, 0x8f,
-    0x18, 0x9a, 0x0d, 0x04, 0xa3, 0x18, 0x0b, 0x8f,
-    0x3a, 0x9e, 0x2d, 0x00, 0xbf, 0x18, 0x9e, 0x2d,
-    0xd0, 0x18, 0xae, 0x3a, 0x00, 0xd7, 0x3a, 0xe0,
-    0x47, 0x18, 0xf0, 0x09, 0x55, 0x2c, 0x09, 0xbf,
-    0x18, 0xf0, 0x41, 0x8f, 0x2c, 0x0f, 0xe4, 0x2c,
-    0x93, 0x02, 0xb6, 0x93, 0x08, 0xaf, 0x46, 0xe0,
-    0xcb, 0x91, 0x13, 0xdf, 0x1c, 0xd7, 0x08, 0x07,
-    0xa1, 0x18, 0xe0, 0x05, 0x41, 0x82, 0x18, 0xae,
-    0x41, 0x3c, 0x88, 0x41, 0xab, 0x80, 0x03, 0x89,
-    0x18, 0x05, 0xb7, 0x70, 0x07, 0xc5, 0x76, 0x07,
-    0x8b, 0x76, 0x05, 0x9f, 0x1e, 0xad, 0x3b, 0x80,
-    0x18, 0x80, 0x3b, 0xa3, 0x73, 0x0a, 0x80, 0x73,
-    0x9c, 0x2d, 0x02, 0xcd, 0x37, 0x00, 0x80, 0x18,
-    0x89, 0x37, 0x03, 0x81, 0x37, 0x9e, 0x5a, 0x00,
-    0xb6, 0x16, 0x08, 0x8d, 0x16, 0x01, 0x89, 0x16,
-    0x01, 0x83, 0x16, 0x9f, 0x5a, 0xc2, 0x86, 0x17,
-    0x84, 0x86, 0x96, 0x51, 0x09, 0x85, 0x23, 0x01,
-    0x85, 0x23, 0x01, 0x85, 0x23, 0x08, 0x86, 0x23,
-    0x00, 0x86, 0x23, 0x00, 0xaa, 0x41, 0x80, 0x18,
-    0x88, 0x41, 0x80, 0x28, 0x09, 0xcf, 0x17, 0xad,
-    0x51, 0x01, 0x89, 0x51, 0x05, 0xf0, 0x1b, 0x43,
-    0x2d, 0x0b, 0x96, 0x2d, 0x03, 0xb0, 0x2d, 0x70,
-    0x10, 0xa3, 0xe1, 0x0d, 0x2c, 0x01, 0xe0, 0x09,
-    0x2c, 0x25, 0x86, 0x41, 0x0b, 0x84, 0x05, 0x04,
-    0x99, 0x31, 0x00, 0x84, 0x31, 0x00, 0x80, 0x31,
-    0x00, 0x81, 0x31, 0x00, 0x81, 0x31, 0x00, 0x89,
-    0x31, 0xe0, 0x11, 0x04, 0x10, 0xe1, 0x0a, 0x04,
+    0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x2c, 0x00,
+    0x85, 0x2c, 0x03, 0x81, 0x2c, 0x01, 0x95, 0x2c,
+    0x00, 0x86, 0x2c, 0x00, 0x81, 0x2c, 0x00, 0x81,
+    0x2c, 0x00, 0x81, 0x2c, 0x01, 0x80, 0x2c, 0x00,
+    0x84, 0x2c, 0x03, 0x81, 0x2c, 0x01, 0x82, 0x2c,
+    0x02, 0x80, 0x2c, 0x06, 0x83, 0x2c, 0x00, 0x80,
+    0x2c, 0x06, 0x90, 0x2c, 0x09, 0x82, 0x2a, 0x00,
+    0x88, 0x2a, 0x00, 0x82, 0x2a, 0x00, 0x95, 0x2a,
+    0x00, 0x86, 0x2a, 0x00, 0x81, 0x2a, 0x00, 0x84,
+    0x2a, 0x01, 0x89, 0x2a, 0x00, 0x82, 0x2a, 0x00,
+    0x82, 0x2a, 0x01, 0x80, 0x2a, 0x0e, 0x83, 0x2a,
+    0x01, 0x8b, 0x2a, 0x06, 0x86, 0x2a, 0x00, 0x82,
+    0x6d, 0x00, 0x87, 0x6d, 0x01, 0x81, 0x6d, 0x01,
+    0x95, 0x6d, 0x00, 0x86, 0x6d, 0x00, 0x81, 0x6d,
+    0x00, 0x84, 0x6d, 0x01, 0x88, 0x6d, 0x01, 0x81,
+    0x6d, 0x01, 0x82, 0x6d, 0x07, 0x81, 0x6d, 0x03,
+    0x81, 0x6d, 0x00, 0x84, 0x6d, 0x01, 0x91, 0x6d,
+    0x09, 0x81, 0x8b, 0x00, 0x85, 0x8b, 0x02, 0x82,
+    0x8b, 0x00, 0x83, 0x8b, 0x02, 0x81, 0x8b, 0x00,
+    0x80, 0x8b, 0x00, 0x81, 0x8b, 0x02, 0x81, 0x8b,
+    0x02, 0x82, 0x8b, 0x02, 0x8b, 0x8b, 0x03, 0x84,
+    0x8b, 0x02, 0x82, 0x8b, 0x00, 0x83, 0x8b, 0x01,
+    0x80, 0x8b, 0x05, 0x80, 0x8b, 0x0d, 0x94, 0x8b,
+    0x04, 0x8c, 0x8d, 0x00, 0x82, 0x8d, 0x00, 0x96,
+    0x8d, 0x00, 0x8f, 0x8d, 0x02, 0x87, 0x8d, 0x00,
+    0x82, 0x8d, 0x00, 0x83, 0x8d, 0x06, 0x81, 0x8d,
+    0x00, 0x82, 0x8d, 0x04, 0x83, 0x8d, 0x01, 0x89,
+    0x8d, 0x06, 0x88, 0x8d, 0x8c, 0x3a, 0x00, 0x82,
+    0x3a, 0x00, 0x96, 0x3a, 0x00, 0x89, 0x3a, 0x00,
+    0x84, 0x3a, 0x01, 0x88, 0x3a, 0x00, 0x82, 0x3a,
+    0x00, 0x83, 0x3a, 0x06, 0x81, 0x3a, 0x06, 0x80,
+    0x3a, 0x00, 0x83, 0x3a, 0x01, 0x89, 0x3a, 0x00,
+    0x81, 0x3a, 0x0c, 0x83, 0x4c, 0x00, 0x87, 0x4c,
+    0x00, 0x82, 0x4c, 0x00, 0xb2, 0x4c, 0x00, 0x82,
+    0x4c, 0x00, 0x85, 0x4c, 0x03, 0x8f, 0x4c, 0x01,
+    0x99, 0x4c, 0x01, 0x81, 0x7e, 0x00, 0x91, 0x7e,
+    0x02, 0x97, 0x7e, 0x00, 0x88, 0x7e, 0x00, 0x80,
+    0x7e, 0x01, 0x86, 0x7e, 0x02, 0x80, 0x7e, 0x03,
+    0x85, 0x7e, 0x00, 0x80, 0x7e, 0x00, 0x87, 0x7e,
+    0x05, 0x89, 0x7e, 0x01, 0x82, 0x7e, 0x0b, 0xb9,
+    0x8f, 0x03, 0x80, 0x18, 0x9b, 0x8f, 0x24, 0x81,
+    0x41, 0x00, 0x80, 0x41, 0x00, 0x84, 0x41, 0x00,
+    0x97, 0x41, 0x00, 0x80, 0x41, 0x00, 0x96, 0x41,
+    0x01, 0x84, 0x41, 0x00, 0x80, 0x41, 0x00, 0x85,
+    0x41, 0x01, 0x89, 0x41, 0x01, 0x83, 0x41, 0x1f,
+    0xc7, 0x90, 0x00, 0xa3, 0x90, 0x03, 0xa6, 0x90,
+    0x00, 0xa3, 0x90, 0x00, 0x8e, 0x90, 0x00, 0x86,
+    0x90, 0x83, 0x18, 0x81, 0x90, 0x24, 0xe0, 0x3f,
+    0x5b, 0xa5, 0x25, 0x00, 0x80, 0x25, 0x04, 0x80,
+    0x25, 0x01, 0xaa, 0x25, 0x80, 0x18, 0x83, 0x25,
+    0xe0, 0x9f, 0x2e, 0xc8, 0x24, 0x00, 0x83, 0x24,
+    0x01, 0x86, 0x24, 0x00, 0x80, 0x24, 0x00, 0x83,
+    0x24, 0x01, 0xa8, 0x24, 0x00, 0x83, 0x24, 0x01,
+    0xa0, 0x24, 0x00, 0x83, 0x24, 0x01, 0x86, 0x24,
+    0x00, 0x80, 0x24, 0x00, 0x83, 0x24, 0x01, 0x8e,
+    0x24, 0x00, 0xb8, 0x24, 0x00, 0x83, 0x24, 0x01,
+    0xc2, 0x24, 0x01, 0x9f, 0x24, 0x02, 0x99, 0x24,
+    0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01, 0xe2,
+    0x1f, 0x12, 0x9c, 0x63, 0x02, 0xca, 0x77, 0x82,
+    0x18, 0x8a, 0x77, 0x06, 0x8c, 0x85, 0x00, 0x86,
+    0x85, 0x0a, 0x94, 0x30, 0x81, 0x18, 0x08, 0x93,
+    0x11, 0x0b, 0x8c, 0x86, 0x00, 0x82, 0x86, 0x00,
+    0x81, 0x86, 0x0b, 0xdd, 0x3e, 0x01, 0x89, 0x3e,
+    0x05, 0x89, 0x3e, 0x05, 0x81, 0x58, 0x81, 0x18,
+    0x80, 0x58, 0x80, 0x18, 0x88, 0x58, 0x00, 0x89,
+    0x58, 0x05, 0xd8, 0x58, 0x06, 0xaa, 0x58, 0x04,
+    0xc5, 0x12, 0x09, 0x9e, 0x44, 0x00, 0x8b, 0x44,
+    0x03, 0x8b, 0x44, 0x03, 0x80, 0x44, 0x02, 0x8b,
+    0x44, 0x9d, 0x87, 0x01, 0x84, 0x87, 0x0a, 0xab,
+    0x5e, 0x03, 0x99, 0x5e, 0x05, 0x8a, 0x5e, 0x02,
+    0x81, 0x5e, 0x9f, 0x3e, 0x9b, 0x10, 0x01, 0x81,
+    0x10, 0xbe, 0x88, 0x00, 0x9c, 0x88, 0x01, 0x8a,
+    0x88, 0x05, 0x89, 0x88, 0x05, 0x8d, 0x88, 0x01,
+    0x8e, 0x35, 0x40, 0xcb, 0x07, 0x03, 0xac, 0x07,
+    0x02, 0xbf, 0x82, 0xb3, 0x0a, 0x07, 0x83, 0x0a,
+    0xb7, 0x43, 0x02, 0x8e, 0x43, 0x02, 0x82, 0x43,
+    0xaf, 0x64, 0x88, 0x1c, 0x06, 0xaa, 0x25, 0x01,
+    0x82, 0x25, 0x87, 0x82, 0x07, 0x82, 0x35, 0x80,
+    0x18, 0x8c, 0x35, 0x80, 0x18, 0x86, 0x35, 0x83,
+    0x18, 0x80, 0x35, 0x85, 0x18, 0x80, 0x35, 0x82,
+    0x18, 0x81, 0x35, 0x80, 0x18, 0x04, 0xa5, 0x42,
+    0x84, 0x29, 0x80, 0x1c, 0xb0, 0x42, 0x84, 0x29,
+    0x83, 0x42, 0x84, 0x29, 0x8c, 0x42, 0x80, 0x1c,
+    0xc5, 0x42, 0x80, 0x29, 0xb9, 0x35, 0x00, 0x84,
+    0x35, 0xe0, 0x9f, 0x42, 0x95, 0x29, 0x01, 0x85,
+    0x29, 0x01, 0xa5, 0x29, 0x01, 0x85, 0x29, 0x01,
+    0x87, 0x29, 0x00, 0x80, 0x29, 0x00, 0x80, 0x29,
+    0x00, 0x80, 0x29, 0x00, 0x9e, 0x29, 0x01, 0xb4,
+    0x29, 0x00, 0x8e, 0x29, 0x00, 0x8d, 0x29, 0x01,
+    0x85, 0x29, 0x00, 0x92, 0x29, 0x01, 0x82, 0x29,
+    0x00, 0x88, 0x29, 0x00, 0x8b, 0x18, 0x81, 0x35,
+    0xd6, 0x18, 0x00, 0x8a, 0x18, 0x80, 0x42, 0x01,
+    0x8a, 0x18, 0x80, 0x42, 0x8e, 0x18, 0x00, 0x8c,
+    0x42, 0x02, 0x9f, 0x18, 0x0f, 0xa0, 0x35, 0x0e,
+    0xa5, 0x18, 0x80, 0x29, 0x82, 0x18, 0x81, 0x42,
+    0x85, 0x18, 0x80, 0x42, 0x9a, 0x18, 0x80, 0x42,
+    0x90, 0x18, 0xa8, 0x42, 0x82, 0x18, 0x03, 0xe2,
+    0x36, 0x18, 0x18, 0x8a, 0x18, 0x14, 0xe3, 0x3f,
+    0x18, 0xe0, 0x9f, 0x0f, 0xe2, 0x13, 0x18, 0x01,
+    0x9f, 0x18, 0x01, 0xe0, 0x07, 0x18, 0xae, 0x26,
+    0x00, 0xae, 0x26, 0x00, 0x9f, 0x42, 0xe0, 0x13,
+    0x19, 0x04, 0x86, 0x19, 0xa5, 0x25, 0x00, 0x80,
+    0x25, 0x04, 0x80, 0x25, 0x01, 0xb7, 0x91, 0x06,
+    0x81, 0x91, 0x0d, 0x80, 0x91, 0x96, 0x24, 0x08,
+    0x86, 0x24, 0x00, 0x86, 0x24, 0x00, 0x86, 0x24,
+    0x00, 0x86, 0x24, 0x00, 0x86, 0x24, 0x00, 0x86,
+    0x24, 0x00, 0x86, 0x24, 0x00, 0x86, 0x24, 0x00,
+    0x9f, 0x1c, 0xcf, 0x18, 0x2f, 0x99, 0x2d, 0x00,
+    0xd8, 0x2d, 0x0b, 0xe0, 0x75, 0x2d, 0x19, 0x8b,
+    0x18, 0x03, 0x84, 0x18, 0x80, 0x2d, 0x80, 0x18,
+    0x80, 0x2d, 0x98, 0x18, 0x88, 0x2d, 0x83, 0x35,
+    0x81, 0x2e, 0x87, 0x18, 0x83, 0x2d, 0x83, 0x18,
+    0x00, 0xd5, 0x33, 0x01, 0x81, 0x35, 0x81, 0x18,
+    0x82, 0x33, 0x80, 0x18, 0xd9, 0x3b, 0x81, 0x18,
+    0x82, 0x3b, 0x04, 0xaa, 0x0d, 0x00, 0xdd, 0x2e,
+    0x00, 0x8f, 0x18, 0x9a, 0x0d, 0x04, 0xa3, 0x18,
+    0x0b, 0x8f, 0x3b, 0x9e, 0x2e, 0x00, 0xbf, 0x18,
+    0x9e, 0x2e, 0xd0, 0x18, 0xae, 0x3b, 0x80, 0x18,
+    0xd7, 0x3b, 0xe0, 0x47, 0x18, 0xf0, 0x09, 0x55,
+    0x2d, 0x09, 0xbf, 0x18, 0xf0, 0x41, 0x8f, 0x2d,
+    0x0f, 0xe4, 0x2c, 0x97, 0x02, 0xb6, 0x97, 0x08,
+    0xaf, 0x47, 0xe0, 0xcb, 0x94, 0x13, 0xdf, 0x1c,
+    0xd7, 0x08, 0x07, 0xa1, 0x18, 0xe0, 0x05, 0x42,
+    0x82, 0x18, 0xb4, 0x42, 0x01, 0x84, 0x42, 0x2f,
+    0x88, 0x42, 0xab, 0x83, 0x03, 0x89, 0x18, 0x05,
+    0xb7, 0x73, 0x07, 0xc5, 0x79, 0x07, 0x8b, 0x79,
+    0x05, 0x9f, 0x1e, 0xad, 0x3c, 0x80, 0x18, 0x80,
+    0x3c, 0xa3, 0x76, 0x0a, 0x80, 0x76, 0x9c, 0x2e,
+    0x02, 0xcd, 0x38, 0x00, 0x80, 0x18, 0x89, 0x38,
+    0x03, 0x81, 0x38, 0x9e, 0x5b, 0x00, 0xb6, 0x16,
+    0x08, 0x8d, 0x16, 0x01, 0x89, 0x16, 0x01, 0x83,
+    0x16, 0x9f, 0x5b, 0xc2, 0x89, 0x17, 0x84, 0x89,
+    0x96, 0x52, 0x09, 0x85, 0x24, 0x01, 0x85, 0x24,
+    0x01, 0x85, 0x24, 0x08, 0x86, 0x24, 0x00, 0x86,
+    0x24, 0x00, 0xaa, 0x42, 0x80, 0x18, 0x88, 0x42,
+    0x80, 0x29, 0x81, 0x42, 0x07, 0xcf, 0x17, 0xad,
+    0x52, 0x01, 0x89, 0x52, 0x05, 0xf0, 0x1b, 0x43,
+    0x2e, 0x0b, 0x96, 0x2e, 0x03, 0xb0, 0x2e, 0x70,
+    0x10, 0xa3, 0xe1, 0x0d, 0x2d, 0x01, 0xe0, 0x09,
+    0x2d, 0x25, 0x86, 0x42, 0x0b, 0x84, 0x05, 0x04,
+    0x99, 0x32, 0x00, 0x84, 0x32, 0x00, 0x80, 0x32,
+    0x00, 0x81, 0x32, 0x00, 0x81, 0x32, 0x00, 0x89,
+    0x32, 0xe0, 0x11, 0x04, 0x10, 0xe1, 0x0a, 0x04,
     0x81, 0x18, 0x0f, 0xbf, 0x04, 0x01, 0xb5, 0x04,
-    0x27, 0x8d, 0x04, 0x01, 0x8f, 0x34, 0x89, 0x18,
-    0x05, 0x8d, 0x34, 0x81, 0x1c, 0xa2, 0x18, 0x00,
+    0x27, 0x8d, 0x04, 0x01, 0x8f, 0x35, 0x89, 0x18,
+    0x05, 0x8d, 0x35, 0x81, 0x1c, 0xa2, 0x18, 0x00,
     0x92, 0x18, 0x00, 0x83, 0x18, 0x03, 0x84, 0x04,
     0x00, 0xe0, 0x26, 0x04, 0x01, 0x80, 0x18, 0x00,
-    0x9f, 0x18, 0x99, 0x41, 0x85, 0x18, 0x99, 0x41,
-    0x8a, 0x18, 0x89, 0x3a, 0x80, 0x18, 0xac, 0x3a,
-    0x81, 0x18, 0x9e, 0x2d, 0x02, 0x85, 0x2d, 0x01,
-    0x85, 0x2d, 0x01, 0x85, 0x2d, 0x01, 0x82, 0x2d,
+    0x9f, 0x18, 0x99, 0x42, 0x85, 0x18, 0x99, 0x42,
+    0x8a, 0x18, 0x89, 0x3b, 0x80, 0x18, 0xac, 0x3b,
+    0x81, 0x18, 0x9e, 0x2e, 0x02, 0x85, 0x2e, 0x01,
+    0x85, 0x2e, 0x01, 0x85, 0x2e, 0x01, 0x82, 0x2e,
     0x02, 0x86, 0x18, 0x00, 0x86, 0x18, 0x09, 0x84,
-    0x18, 0x01, 0x8b, 0x45, 0x00, 0x99, 0x45, 0x00,
-    0x92, 0x45, 0x00, 0x81, 0x45, 0x00, 0x8e, 0x45,
-    0x01, 0x8d, 0x45, 0x21, 0xe0, 0x1a, 0x45, 0x04,
+    0x18, 0x01, 0x8b, 0x46, 0x00, 0x99, 0x46, 0x00,
+    0x92, 0x46, 0x00, 0x81, 0x46, 0x00, 0x8e, 0x46,
+    0x01, 0x8d, 0x46, 0x21, 0xe0, 0x1a, 0x46, 0x04,
     0x82, 0x18, 0x03, 0xac, 0x18, 0x02, 0x88, 0x18,
-    0xce, 0x28, 0x00, 0x8b, 0x18, 0x03, 0x80, 0x28,
-    0x2e, 0xac, 0x18, 0x80, 0x34, 0x60, 0x21, 0x9c,
-    0x47, 0x02, 0xb0, 0x13, 0x0e, 0x80, 0x34, 0x9a,
-    0x18, 0x03, 0xa3, 0x63, 0x08, 0x82, 0x63, 0x9a,
-    0x26, 0x04, 0xaa, 0x65, 0x04, 0x9d, 0x90, 0x00,
-    0x80, 0x90, 0xa3, 0x66, 0x03, 0x8d, 0x66, 0x29,
-    0xcf, 0x1d, 0xaf, 0x78, 0x9d, 0x6c, 0x01, 0x89,
-    0x6c, 0x05, 0xa3, 0x6b, 0x03, 0xa3, 0x6b, 0x03,
+    0xce, 0x29, 0x00, 0x8b, 0x18, 0x03, 0x80, 0x29,
+    0x2e, 0xac, 0x18, 0x80, 0x35, 0x60, 0x21, 0x9c,
+    0x48, 0x02, 0xb0, 0x13, 0x0e, 0x80, 0x35, 0x9a,
+    0x18, 0x03, 0xa3, 0x66, 0x08, 0x82, 0x66, 0x9a,
+    0x27, 0x04, 0xaa, 0x68, 0x04, 0x9d, 0x93, 0x00,
+    0x80, 0x93, 0xa3, 0x69, 0x03, 0x8d, 0x69, 0x29,
+    0xcf, 0x1d, 0xaf, 0x7b, 0x9d, 0x6f, 0x01, 0x89,
+    0x6f, 0x05, 0xa3, 0x6e, 0x03, 0xa3, 0x6e, 0x03,
     0xa7, 0x22, 0x07, 0xb3, 0x14, 0x0a, 0x80, 0x14,
-    0x60, 0x2f, 0xe0, 0xd6, 0x44, 0x08, 0x95, 0x44,
-    0x09, 0x87, 0x44, 0x60, 0x37, 0x85, 0x1b, 0x01,
+    0x60, 0x2f, 0xe0, 0xd6, 0x45, 0x08, 0x95, 0x45,
+    0x09, 0x87, 0x45, 0x60, 0x37, 0x85, 0x1b, 0x01,
     0x80, 0x1b, 0x00, 0xab, 0x1b, 0x00, 0x81, 0x1b,
-    0x02, 0x80, 0x1b, 0x01, 0x80, 0x1b, 0x95, 0x33,
-    0x00, 0x88, 0x33, 0x9f, 0x6e, 0x9e, 0x5b, 0x07,
-    0x88, 0x5b, 0x2f, 0x92, 0x30, 0x00, 0x81, 0x30,
-    0x04, 0x84, 0x30, 0x9b, 0x71, 0x02, 0x80, 0x71,
-    0x99, 0x48, 0x04, 0x80, 0x48, 0x3f, 0x9f, 0x54,
-    0x97, 0x53, 0x03, 0x93, 0x53, 0x01, 0xad, 0x53,
-    0x83, 0x3c, 0x00, 0x81, 0x3c, 0x04, 0x87, 0x3c,
-    0x00, 0x82, 0x3c, 0x00, 0x9c, 0x3c, 0x01, 0x82,
-    0x3c, 0x03, 0x89, 0x3c, 0x06, 0x88, 0x3c, 0x06,
-    0x9f, 0x68, 0x9f, 0x64, 0x1f, 0xa6, 0x4d, 0x03,
-    0x8b, 0x4d, 0x08, 0xb5, 0x06, 0x02, 0x86, 0x06,
-    0x95, 0x36, 0x01, 0x87, 0x36, 0x92, 0x35, 0x04,
-    0x87, 0x35, 0x91, 0x72, 0x06, 0x83, 0x72, 0x0b,
-    0x86, 0x72, 0x4f, 0xc8, 0x69, 0x36, 0xb2, 0x62,
-    0x0c, 0xb2, 0x62, 0x06, 0x85, 0x62, 0xa7, 0x2e,
-    0x07, 0x89, 0x2e, 0x60, 0xc5, 0x9e, 0x04, 0x60,
-    0x20, 0xa7, 0x67, 0x07, 0xa9, 0x7c, 0x60, 0x45,
-    0xcd, 0x0e, 0x03, 0x9d, 0x0e, 0x0e, 0x80, 0x0e,
-    0xc1, 0x38, 0x0a, 0x80, 0x38, 0x01, 0x98, 0x7d,
-    0x06, 0x89, 0x7d, 0x05, 0xb4, 0x15, 0x00, 0x90,
-    0x15, 0x08, 0xa6, 0x4a, 0x08, 0xcd, 0x77, 0x01,
-    0x8f, 0x77, 0x00, 0x93, 0x7b, 0x0a, 0x91, 0x3e,
-    0x00, 0xab, 0x3e, 0x40, 0x86, 0x59, 0x00, 0x80,
-    0x59, 0x00, 0x83, 0x59, 0x00, 0x8e, 0x59, 0x00,
-    0x8a, 0x59, 0x05, 0xba, 0x3f, 0x04, 0x89, 0x3f,
-    0x05, 0x83, 0x27, 0x00, 0x87, 0x27, 0x01, 0x81,
-    0x27, 0x01, 0x95, 0x27, 0x00, 0x86, 0x27, 0x00,
-    0x81, 0x27, 0x00, 0x84, 0x27, 0x00, 0x80, 0x34,
-    0x88, 0x27, 0x01, 0x81, 0x27, 0x01, 0x82, 0x27,
-    0x01, 0x80, 0x27, 0x05, 0x80, 0x27, 0x04, 0x86,
-    0x27, 0x01, 0x86, 0x27, 0x02, 0x84, 0x27, 0x60,
-    0x2a, 0xd9, 0x5d, 0x00, 0x80, 0x5d, 0x00, 0x81,
-    0x5d, 0x20, 0xc7, 0x8f, 0x07, 0x89, 0x8f, 0x60,
-    0x45, 0xb5, 0x79, 0x01, 0xa5, 0x79, 0x21, 0xc4,
-    0x56, 0x0a, 0x89, 0x56, 0x05, 0x8c, 0x57, 0x12,
-    0xb7, 0x87, 0x07, 0x89, 0x87, 0x35, 0x9a, 0x02,
-    0x01, 0x8e, 0x02, 0x03, 0x8f, 0x02, 0x60, 0x5f,
-    0xbb, 0x1f, 0x60, 0x03, 0xd2, 0x92, 0x0b, 0x80,
-    0x92, 0x60, 0x9f, 0xc7, 0x94, 0x07, 0xb3, 0x7e,
-    0x01, 0x9c, 0x7e, 0x1c, 0xb8, 0x6f, 0x60, 0xa6,
-    0x88, 0x0c, 0x00, 0xac, 0x0c, 0x00, 0x8d, 0x0c,
-    0x09, 0x9c, 0x0c, 0x02, 0x9f, 0x4e, 0x01, 0x95,
-    0x4e, 0x00, 0x8d, 0x4e, 0x48, 0x86, 0x4f, 0x00,
-    0x81, 0x4f, 0x00, 0xab, 0x4f, 0x02, 0x80, 0x4f,
-    0x00, 0x81, 0x4f, 0x00, 0x88, 0x4f, 0x07, 0x89,
-    0x4f, 0x05, 0x85, 0x2a, 0x00, 0x81, 0x2a, 0x00,
-    0xa4, 0x2a, 0x00, 0x81, 0x2a, 0x00, 0x85, 0x2a,
-    0x06, 0x89, 0x2a, 0x60, 0xd5, 0x98, 0x49, 0x60,
-    0xa6, 0xe3, 0x39, 0x1a, 0x60, 0x05, 0xe0, 0x0e,
-    0x1a, 0x00, 0x84, 0x1a, 0x0a, 0xe0, 0x63, 0x1a,
-    0x6a, 0x5b, 0xe3, 0xce, 0x21, 0x6f, 0x70, 0xe1,
-    0xe6, 0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8, 0x08,
-    0x06, 0x9e, 0x58, 0x00, 0x89, 0x58, 0x03, 0x81,
-    0x58, 0x5f, 0x9d, 0x09, 0x01, 0x85, 0x09, 0x09,
-    0xc5, 0x6d, 0x09, 0x89, 0x6d, 0x00, 0x86, 0x6d,
-    0x00, 0x94, 0x6d, 0x04, 0x92, 0x6d, 0x62, 0x4f,
-    0xda, 0x50, 0x60, 0x04, 0xc4, 0x55, 0x0a, 0xae,
-    0x55, 0x0f, 0x90, 0x55, 0x3f, 0x80, 0x89, 0x80,
-    0x5f, 0x1d, 0xf0, 0x07, 0x91, 0x89, 0x0d, 0xe2,
-    0x92, 0x89, 0x70, 0x14, 0xac, 0x80, 0x3a, 0xe0,
-    0xbd, 0x32, 0x50, 0xe1, 0x2b, 0x5f, 0x68, 0xa3,
-    0xe0, 0x0a, 0x20, 0x04, 0x8c, 0x20, 0x02, 0x88,
-    0x20, 0x06, 0x89, 0x20, 0x01, 0x83, 0x20, 0x83,
-    0x18, 0x70, 0x02, 0xfb, 0xe0, 0x95, 0x18, 0x09,
-    0xa6, 0x18, 0x01, 0xbd, 0x18, 0x82, 0x34, 0x90,
-    0x18, 0x87, 0x34, 0x81, 0x18, 0x86, 0x34, 0x9d,
-    0x18, 0x83, 0x34, 0xba, 0x18, 0x16, 0xc5, 0x28,
-    0x60, 0x39, 0x93, 0x18, 0x0b, 0xd6, 0x18, 0x08,
-    0x98, 0x18, 0x60, 0x26, 0xd4, 0x18, 0x00, 0xc6,
-    0x18, 0x00, 0x81, 0x18, 0x01, 0x80, 0x18, 0x01,
-    0x81, 0x18, 0x01, 0x83, 0x18, 0x00, 0x8b, 0x18,
-    0x00, 0x80, 0x18, 0x00, 0x86, 0x18, 0x00, 0xc0,
-    0x18, 0x00, 0x83, 0x18, 0x01, 0x87, 0x18, 0x00,
-    0x86, 0x18, 0x00, 0x9b, 0x18, 0x00, 0x83, 0x18,
-    0x00, 0x84, 0x18, 0x00, 0x80, 0x18, 0x02, 0x86,
-    0x18, 0x00, 0xe0, 0xf3, 0x18, 0x01, 0xe0, 0xc3,
-    0x18, 0x01, 0xb1, 0x18, 0xe2, 0x2b, 0x7a, 0x0e,
-    0x84, 0x7a, 0x00, 0x8e, 0x7a, 0x64, 0xef, 0x86,
-    0x25, 0x00, 0x90, 0x25, 0x01, 0x86, 0x25, 0x00,
-    0x81, 0x25, 0x00, 0x84, 0x25, 0x67, 0x74, 0xe0,
-    0x64, 0x52, 0x01, 0x8f, 0x52, 0x28, 0xca, 0x01,
-    0x04, 0x89, 0x01, 0x03, 0x81, 0x01, 0x62, 0xb0,
-    0xc3, 0x18, 0x60, 0xea, 0x83, 0x04, 0x00, 0x9a,
+    0x02, 0x80, 0x1b, 0x01, 0x80, 0x1b, 0x95, 0x34,
+    0x00, 0x88, 0x34, 0x9f, 0x71, 0x9e, 0x5c, 0x07,
+    0x88, 0x5c, 0x2f, 0x92, 0x31, 0x00, 0x81, 0x31,
+    0x04, 0x84, 0x31, 0x9b, 0x74, 0x02, 0x80, 0x74,
+    0x99, 0x49, 0x04, 0x80, 0x49, 0x3f, 0x9f, 0x55,
+    0x97, 0x54, 0x03, 0x93, 0x54, 0x01, 0xad, 0x54,
+    0x83, 0x3d, 0x00, 0x81, 0x3d, 0x04, 0x87, 0x3d,
+    0x00, 0x82, 0x3d, 0x00, 0x9c, 0x3d, 0x01, 0x82,
+    0x3d, 0x03, 0x89, 0x3d, 0x06, 0x88, 0x3d, 0x06,
+    0x9f, 0x6b, 0x9f, 0x67, 0x1f, 0xa6, 0x4e, 0x03,
+    0x8b, 0x4e, 0x08, 0xb5, 0x06, 0x02, 0x86, 0x06,
+    0x95, 0x37, 0x01, 0x87, 0x37, 0x92, 0x36, 0x04,
+    0x87, 0x36, 0x91, 0x75, 0x06, 0x83, 0x75, 0x0b,
+    0x86, 0x75, 0x4f, 0xc8, 0x6c, 0x36, 0xb2, 0x65,
+    0x0c, 0xb2, 0x65, 0x06, 0x85, 0x65, 0xa7, 0x2f,
+    0x07, 0x89, 0x2f, 0x60, 0xc5, 0x9e, 0x04, 0x60,
+    0x20, 0xa7, 0x6a, 0x07, 0xa9, 0x7f, 0x60, 0x25,
+    0x96, 0x23, 0x08, 0xcd, 0x0e, 0x03, 0x9d, 0x0e,
+    0x0e, 0x80, 0x0e, 0xc1, 0x39, 0x0a, 0x80, 0x39,
+    0x01, 0x98, 0x80, 0x06, 0x89, 0x80, 0x05, 0xb4,
+    0x15, 0x00, 0x90, 0x15, 0x08, 0xa6, 0x4b, 0x08,
+    0xcd, 0x7a, 0x01, 0x8f, 0x7a, 0x00, 0x93, 0x7e,
+    0x0a, 0x91, 0x3f, 0x00, 0xab, 0x3f, 0x40, 0x86,
+    0x5a, 0x00, 0x80, 0x5a, 0x00, 0x83, 0x5a, 0x00,
+    0x8e, 0x5a, 0x00, 0x8a, 0x5a, 0x05, 0xba, 0x40,
+    0x04, 0x89, 0x40, 0x05, 0x83, 0x28, 0x00, 0x87,
+    0x28, 0x01, 0x81, 0x28, 0x01, 0x95, 0x28, 0x00,
+    0x86, 0x28, 0x00, 0x81, 0x28, 0x00, 0x84, 0x28,
+    0x00, 0x80, 0x35, 0x88, 0x28, 0x01, 0x81, 0x28,
+    0x01, 0x82, 0x28, 0x01, 0x80, 0x28, 0x05, 0x80,
+    0x28, 0x04, 0x86, 0x28, 0x01, 0x86, 0x28, 0x02,
+    0x84, 0x28, 0x60, 0x2a, 0xd9, 0x5f, 0x00, 0x80,
+    0x5f, 0x00, 0x82, 0x5f, 0x1f, 0xc7, 0x92, 0x07,
+    0x89, 0x92, 0x60, 0x45, 0xb5, 0x7c, 0x01, 0xa5,
+    0x7c, 0x21, 0xc4, 0x57, 0x0a, 0x89, 0x57, 0x05,
+    0x8c, 0x58, 0x12, 0xb8, 0x8a, 0x06, 0x89, 0x8a,
+    0x35, 0x9a, 0x02, 0x01, 0x8e, 0x02, 0x03, 0x8f,
+    0x02, 0x60, 0x5f, 0xbb, 0x1f, 0x60, 0x03, 0xd2,
+    0x96, 0x0b, 0x80, 0x96, 0x60, 0x3f, 0x87, 0x5d,
+    0x01, 0xad, 0x5d, 0x01, 0x8a, 0x5d, 0x1a, 0xc7,
+    0x98, 0x07, 0xd2, 0x81, 0x1c, 0xb8, 0x72, 0x60,
+    0xa6, 0x88, 0x0c, 0x00, 0xac, 0x0c, 0x00, 0x8d,
+    0x0c, 0x09, 0x9c, 0x0c, 0x02, 0x9f, 0x4f, 0x01,
+    0x95, 0x4f, 0x00, 0x8d, 0x4f, 0x48, 0x86, 0x50,
+    0x00, 0x81, 0x50, 0x00, 0xab, 0x50, 0x02, 0x80,
+    0x50, 0x00, 0x81, 0x50, 0x00, 0x88, 0x50, 0x07,
+    0x89, 0x50, 0x05, 0x85, 0x2b, 0x00, 0x81, 0x2b,
+    0x00, 0xa4, 0x2b, 0x00, 0x81, 0x2b, 0x00, 0x85,
+    0x2b, 0x06, 0x89, 0x2b, 0x60, 0xd5, 0x98, 0x4a,
+    0x60, 0x66, 0xb1, 0x8b, 0x0c, 0x80, 0x8b, 0xe3,
+    0x39, 0x1a, 0x60, 0x05, 0xe0, 0x0e, 0x1a, 0x00,
+    0x84, 0x1a, 0x0a, 0xe0, 0x63, 0x1a, 0x6a, 0x5b,
+    0xe3, 0xce, 0x21, 0x00, 0x88, 0x21, 0x6f, 0x66,
+    0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8,
+    0x08, 0x06, 0x9e, 0x59, 0x00, 0x89, 0x59, 0x03,
+    0x81, 0x59, 0x5f, 0x9d, 0x09, 0x01, 0x85, 0x09,
+    0x09, 0xc5, 0x70, 0x09, 0x89, 0x70, 0x00, 0x86,
+    0x70, 0x00, 0x94, 0x70, 0x04, 0x92, 0x70, 0x62,
+    0x4f, 0xda, 0x51, 0x60, 0x04, 0xca, 0x56, 0x03,
+    0xb8, 0x56, 0x06, 0x90, 0x56, 0x3f, 0x80, 0x8c,
+    0x80, 0x61, 0x81, 0x18, 0x1b, 0xf0, 0x07, 0x97,
+    0x8c, 0x07, 0xe2, 0x92, 0x8c, 0x70, 0x14, 0xac,
+    0x80, 0x3b, 0xe0, 0xbd, 0x33, 0x30, 0x82, 0x33,
+    0x10, 0x83, 0x3b, 0x07, 0xe1, 0x2b, 0x61, 0x68,
+    0xa3, 0xe0, 0x0a, 0x20, 0x04, 0x8c, 0x20, 0x02,
+    0x88, 0x20, 0x06, 0x89, 0x20, 0x01, 0x83, 0x20,
+    0x83, 0x18, 0x70, 0x02, 0xfb, 0xe0, 0x95, 0x18,
+    0x09, 0xa6, 0x18, 0x01, 0xbd, 0x18, 0x82, 0x35,
+    0x90, 0x18, 0x87, 0x35, 0x81, 0x18, 0x86, 0x35,
+    0x9d, 0x18, 0x83, 0x35, 0xba, 0x18, 0x16, 0xc5,
+    0x29, 0x60, 0x39, 0x93, 0x18, 0x0b, 0xd6, 0x18,
+    0x08, 0x98, 0x18, 0x60, 0x26, 0xd4, 0x18, 0x00,
+    0xc6, 0x18, 0x00, 0x81, 0x18, 0x01, 0x80, 0x18,
+    0x01, 0x81, 0x18, 0x01, 0x83, 0x18, 0x00, 0x8b,
+    0x18, 0x00, 0x80, 0x18, 0x00, 0x86, 0x18, 0x00,
+    0xc0, 0x18, 0x00, 0x83, 0x18, 0x01, 0x87, 0x18,
+    0x00, 0x86, 0x18, 0x00, 0x9b, 0x18, 0x00, 0x83,
+    0x18, 0x00, 0x84, 0x18, 0x00, 0x80, 0x18, 0x02,
+    0x86, 0x18, 0x00, 0xe0, 0xf3, 0x18, 0x01, 0xe0,
+    0xc3, 0x18, 0x01, 0xb1, 0x18, 0xe2, 0x2b, 0x7d,
+    0x0e, 0x84, 0x7d, 0x00, 0x8e, 0x7d, 0x64, 0xef,
+    0x86, 0x26, 0x00, 0x90, 0x26, 0x01, 0x86, 0x26,
+    0x00, 0x81, 0x26, 0x00, 0x84, 0x26, 0x60, 0x74,
+    0xac, 0x62, 0x02, 0x8d, 0x62, 0x01, 0x89, 0x62,
+    0x03, 0x81, 0x62, 0x61, 0x0f, 0xb9, 0x95, 0x04,
+    0x80, 0x95, 0x64, 0x9f, 0xe0, 0x64, 0x53, 0x01,
+    0x8f, 0x53, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
+    0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x18, 0x4b,
+    0xbc, 0x18, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a,
     0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
     0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83, 0x04,
     0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05, 0x80,
@@ -3313,118 +3344,126 @@ static const uint8_t unicode_script_table[2522] = {
     0x04, 0x60, 0xad, 0xab, 0x18, 0x03, 0xe0, 0x03,
     0x18, 0x0b, 0x8e, 0x18, 0x01, 0x8e, 0x18, 0x00,
     0x8e, 0x18, 0x00, 0xa4, 0x18, 0x09, 0x8c, 0x18,
-    0x02, 0xdb, 0x18, 0x03, 0xbc, 0x18, 0x38, 0x99,
-    0x18, 0x80, 0x32, 0x81, 0x18, 0x0c, 0xab, 0x18,
+    0x02, 0xdc, 0x18, 0x02, 0xbc, 0x18, 0x38, 0x99,
+    0x18, 0x80, 0x33, 0x81, 0x18, 0x0c, 0xab, 0x18,
     0x03, 0x88, 0x18, 0x06, 0x81, 0x18, 0x0d, 0x85,
-    0x18, 0x60, 0x39, 0xe3, 0x74, 0x18, 0x0a, 0x8c,
-    0x18, 0x02, 0x89, 0x18, 0x05, 0xe0, 0x13, 0x18,
-    0x0b, 0xd8, 0x18, 0x26, 0x8b, 0x18, 0x03, 0xb7,
-    0x18, 0x07, 0x89, 0x18, 0x05, 0xa7, 0x18, 0x07,
-    0x9d, 0x18, 0x51, 0x8b, 0x18, 0x03, 0xae, 0x18,
-    0x00, 0xb0, 0x18, 0x01, 0x83, 0x18, 0x02, 0x80,
-    0x18, 0x00, 0xa6, 0x18, 0x0c, 0x89, 0x18, 0x05,
-    0x82, 0x18, 0x0c, 0xaf, 0x18, 0x5f, 0x8d, 0x18,
-    0x65, 0x31, 0xf0, 0x96, 0x76, 0x2c, 0x28, 0xef,
-    0xd4, 0x2c, 0x0a, 0xe0, 0x7d, 0x2c, 0x01, 0xf0,
-    0x06, 0x21, 0x2c, 0x0d, 0xf0, 0x0c, 0xd0, 0x2c,
-    0x6b, 0xbe, 0xe1, 0xbd, 0x2c, 0x7a, 0xf5, 0x82,
-    0x80, 0x18, 0x1d, 0xdf, 0x18, 0x60, 0x1f, 0xe0,
-    0x8f, 0x34,
+    0x18, 0x60, 0x39, 0xe3, 0x75, 0x18, 0x09, 0x8c,
+    0x18, 0x02, 0x8a, 0x18, 0x04, 0xe0, 0x13, 0x18,
+    0x0b, 0xd8, 0x18, 0x06, 0x8b, 0x18, 0x13, 0x8b,
+    0x18, 0x03, 0xb7, 0x18, 0x07, 0x89, 0x18, 0x05,
+    0xa7, 0x18, 0x07, 0x9d, 0x18, 0x51, 0x8b, 0x18,
+    0x00, 0xe0, 0x04, 0x18, 0x00, 0x83, 0x18, 0x02,
+    0xa8, 0x18, 0x01, 0x85, 0x18, 0x02, 0x9c, 0x18,
+    0x01, 0xe0, 0x26, 0x18, 0x0b, 0x8d, 0x18, 0x01,
+    0x83, 0x18, 0x03, 0x82, 0x18, 0x04, 0x82, 0x18,
+    0x0c, 0x85, 0x18, 0x65, 0x09, 0xf0, 0x96, 0x76,
+    0x2d, 0x28, 0xef, 0xd4, 0x2d, 0x0a, 0xe0, 0x7d,
+    0x2d, 0x01, 0xf0, 0x06, 0x21, 0x2d, 0x0d, 0xf0,
+    0x0c, 0xd0, 0x2d, 0x6b, 0xbe, 0xe1, 0xbd, 0x2d,
+    0x7a, 0xf5, 0x82, 0x80, 0x18, 0x1d, 0xdf, 0x18,
+    0x60, 0x1f, 0xe0, 0x8f, 0x35,
 };
 
-static const uint8_t unicode_script_ext_table[735] = {
-    0x82, 0xc1, 0x00, 0x00, 0x01, 0x28, 0x01, 0x00,
-    0x00, 0x01, 0x28, 0x1c, 0x00, 0x0c, 0x01, 0x41,
-    0x80, 0x92, 0x00, 0x00, 0x02, 0x1c, 0x65, 0x00,
-    0x02, 0x1c, 0x25, 0x01, 0x02, 0x1c, 0x41, 0x00,
-    0x02, 0x1c, 0x25, 0x80, 0x80, 0x00, 0x00, 0x02,
-    0x05, 0x24, 0x80, 0x01, 0x00, 0x00, 0x04, 0x04,
-    0x2e, 0x81, 0x8b, 0x0d, 0x00, 0x00, 0x04, 0x04,
-    0x2e, 0x81, 0x8b, 0x00, 0x03, 0x04, 0x81, 0x8b,
-    0x01, 0x00, 0x00, 0x04, 0x04, 0x2e, 0x81, 0x8b,
-    0x1f, 0x00, 0x00, 0x08, 0x01, 0x04, 0x4c, 0x4d,
-    0x72, 0x2e, 0x7c, 0x81, 0x09, 0x00, 0x0a, 0x02,
-    0x04, 0x81, 0x09, 0x00, 0x09, 0x02, 0x04, 0x8b,
-    0x05, 0x00, 0x00, 0x02, 0x04, 0x81, 0x62, 0x00,
-    0x00, 0x02, 0x04, 0x2e, 0x81, 0xfb, 0x00, 0x00,
-    0x0d, 0x0b, 0x1e, 0x27, 0x29, 0x2b, 0x39, 0x41,
-    0x4b, 0x6a, 0x77, 0x88, 0x8a, 0x8f, 0x00, 0x0c,
-    0x0b, 0x1e, 0x27, 0x29, 0x2b, 0x39, 0x41, 0x4b,
-    0x6a, 0x88, 0x8a, 0x8f, 0x10, 0x00, 0x00, 0x12,
-    0x0b, 0x1e, 0x1f, 0x2a, 0x27, 0x29, 0x2b, 0x39,
-    0x4a, 0x4b, 0x6a, 0x3f, 0x7b, 0x80, 0x87, 0x88,
-    0x8a, 0x8f, 0x00, 0x13, 0x0b, 0x1e, 0x1f, 0x2a,
-    0x27, 0x29, 0x2b, 0x39, 0x43, 0x4a, 0x4b, 0x6a,
-    0x3f, 0x7b, 0x80, 0x87, 0x88, 0x8a, 0x8f, 0x09,
-    0x04, 0x1e, 0x1f, 0x38, 0x4a, 0x75, 0x00, 0x09,
-    0x03, 0x0b, 0x15, 0x80, 0x75, 0x00, 0x09, 0x02,
-    0x2b, 0x59, 0x75, 0x00, 0x09, 0x02, 0x29, 0x3e,
-    0x80, 0x75, 0x00, 0x0d, 0x02, 0x27, 0x88, 0x83,
-    0xcb, 0x00, 0x09, 0x03, 0x15, 0x5a, 0x84, 0x80,
-    0x30, 0x00, 0x00, 0x02, 0x24, 0x41, 0x85, 0xb8,
-    0x00, 0x01, 0x04, 0x11, 0x2f, 0x83, 0x82, 0x80,
-    0x4a, 0x00, 0x01, 0x02, 0x57, 0x70, 0x00, 0x00,
-    0x00, 0x02, 0x57, 0x70, 0x84, 0x49, 0x00, 0x00,
-    0x04, 0x0b, 0x1e, 0x27, 0x39, 0x00, 0x01, 0x1e,
-    0x00, 0x04, 0x0b, 0x1e, 0x27, 0x39, 0x00, 0x02,
-    0x1e, 0x27, 0x00, 0x01, 0x1e, 0x01, 0x02, 0x0b,
-    0x1e, 0x00, 0x02, 0x1e, 0x77, 0x00, 0x02, 0x0b,
-    0x1e, 0x00, 0x02, 0x1e, 0x77, 0x00, 0x06, 0x1e,
-    0x39, 0x4b, 0x6a, 0x88, 0x8a, 0x00, 0x01, 0x1e,
-    0x01, 0x02, 0x1e, 0x77, 0x01, 0x01, 0x1e, 0x00,
-    0x02, 0x1e, 0x77, 0x00, 0x02, 0x0b, 0x1e, 0x07,
-    0x01, 0x1e, 0x00, 0x02, 0x0b, 0x1e, 0x01, 0x01,
-    0x1e, 0x00, 0x02, 0x0b, 0x1e, 0x03, 0x01, 0x1e,
-    0x01, 0x02, 0x1e, 0x27, 0x00, 0x03, 0x1e, 0x27,
-    0x39, 0x01, 0x02, 0x0b, 0x1e, 0x00, 0x01, 0x0b,
-    0x01, 0x02, 0x1e, 0x27, 0x80, 0x45, 0x00, 0x01,
-    0x01, 0x28, 0x82, 0xad, 0x00, 0x00, 0x03, 0x1e,
-    0x27, 0x41, 0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1c,
-    0x25, 0x81, 0x3c, 0x00, 0x01, 0x06, 0x0d, 0x2d,
-    0x2c, 0x32, 0x3a, 0x93, 0x00, 0x05, 0x0d, 0x2d,
-    0x2c, 0x32, 0x3a, 0x01, 0x00, 0x00, 0x01, 0x2c,
-    0x00, 0x00, 0x09, 0x06, 0x0d, 0x2d, 0x2c, 0x32,
-    0x3a, 0x93, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x2d,
-    0x2c, 0x32, 0x3a, 0x07, 0x06, 0x0d, 0x2d, 0x2c,
-    0x32, 0x3a, 0x93, 0x03, 0x05, 0x0d, 0x2d, 0x2c,
-    0x32, 0x3a, 0x09, 0x00, 0x03, 0x02, 0x0d, 0x2c,
-    0x01, 0x00, 0x00, 0x05, 0x0d, 0x2d, 0x2c, 0x32,
-    0x3a, 0x04, 0x02, 0x32, 0x3a, 0x00, 0x00, 0x00,
-    0x05, 0x0d, 0x2d, 0x2c, 0x32, 0x3a, 0x03, 0x00,
-    0x01, 0x03, 0x2c, 0x32, 0x3a, 0x01, 0x01, 0x2c,
-    0x58, 0x00, 0x03, 0x02, 0x32, 0x3a, 0x02, 0x00,
-    0x00, 0x02, 0x32, 0x3a, 0x59, 0x00, 0x00, 0x06,
-    0x0d, 0x2d, 0x2c, 0x32, 0x3a, 0x93, 0x00, 0x02,
-    0x32, 0x3a, 0x80, 0x12, 0x00, 0x0f, 0x01, 0x2c,
-    0x1f, 0x00, 0x23, 0x01, 0x2c, 0x3b, 0x00, 0x27,
-    0x01, 0x2c, 0x37, 0x00, 0x30, 0x01, 0x2c, 0x0e,
-    0x00, 0x0b, 0x01, 0x2c, 0x80, 0x0b, 0x00, 0x18,
-    0x01, 0x2c, 0x09, 0x00, 0x04, 0x01, 0x2c, 0x5f,
-    0x00, 0x1e, 0x01, 0x2c, 0xc0, 0x31, 0xef, 0x00,
-    0x00, 0x02, 0x1c, 0x25, 0x81, 0x3f, 0x00, 0x02,
-    0x0d, 0x1e, 0x1f, 0x29, 0x2b, 0x3e, 0x39, 0x38,
-    0x4a, 0x4b, 0x56, 0x3f, 0x87, 0x8f, 0x02, 0x0c,
-    0x1e, 0x1f, 0x29, 0x2b, 0x3e, 0x39, 0x38, 0x4a,
-    0x56, 0x3f, 0x87, 0x8f, 0x03, 0x0b, 0x1e, 0x1f,
-    0x29, 0x2b, 0x3e, 0x38, 0x4a, 0x56, 0x3f, 0x87,
-    0x8f, 0x80, 0x36, 0x00, 0x00, 0x02, 0x0b, 0x1e,
-    0x00, 0x00, 0x00, 0x02, 0x1e, 0x88, 0x39, 0x00,
-    0x00, 0x03, 0x3b, 0x41, 0x5a, 0x80, 0x1f, 0x00,
-    0x00, 0x02, 0x10, 0x37, 0xc0, 0x13, 0xa1, 0x00,
-    0x00, 0x02, 0x04, 0x8b, 0x09, 0x00, 0x00, 0x02,
-    0x04, 0x8b, 0x46, 0x00, 0x01, 0x05, 0x0d, 0x2d,
-    0x2c, 0x32, 0x3a, 0x80, 0x99, 0x00, 0x04, 0x06,
-    0x0d, 0x2d, 0x2c, 0x32, 0x3a, 0x93, 0x09, 0x00,
-    0x00, 0x02, 0x32, 0x3a, 0x2c, 0x00, 0x01, 0x02,
-    0x32, 0x3a, 0x80, 0xdf, 0x00, 0x02, 0x02, 0x1b,
-    0x45, 0x03, 0x00, 0x2c, 0x03, 0x1b, 0x44, 0x45,
-    0x02, 0x00, 0x08, 0x02, 0x1b, 0x45, 0x81, 0x1f,
-    0x00, 0x1b, 0x02, 0x04, 0x19, 0x8f, 0x84, 0x00,
-    0x00, 0x02, 0x27, 0x88, 0x00, 0x00, 0x00, 0x02,
-    0x27, 0x88, 0x36, 0x00, 0x01, 0x02, 0x27, 0x88,
-    0xc0, 0x68, 0xe2, 0x00, 0x03, 0x01, 0x20, 0x96,
-    0x3b, 0x00, 0x11, 0x01, 0x2c, 0x9e, 0x5d, 0x00,
-    0x01, 0x01, 0x2c, 0xce, 0xcd, 0x2d, 0x00,
+static const uint8_t unicode_script_ext_table[789] = {
+    0x82, 0xc1, 0x00, 0x00, 0x01, 0x29, 0x01, 0x00,
+    0x00, 0x01, 0x29, 0x1c, 0x00, 0x0c, 0x01, 0x42,
+    0x80, 0x92, 0x00, 0x00, 0x02, 0x1c, 0x68, 0x00,
+    0x02, 0x1c, 0x26, 0x01, 0x02, 0x1c, 0x42, 0x00,
+    0x02, 0x1c, 0x26, 0x80, 0x80, 0x00, 0x00, 0x02,
+    0x05, 0x25, 0x80, 0x01, 0x00, 0x00, 0x04, 0x04,
+    0x2f, 0x84, 0x8e, 0x0d, 0x00, 0x00, 0x04, 0x04,
+    0x2f, 0x84, 0x8e, 0x00, 0x03, 0x04, 0x84, 0x8e,
+    0x01, 0x00, 0x00, 0x04, 0x04, 0x2f, 0x84, 0x8e,
+    0x1f, 0x00, 0x00, 0x08, 0x01, 0x04, 0x4d, 0x4e,
+    0x75, 0x2f, 0x7f, 0x84, 0x09, 0x00, 0x0a, 0x02,
+    0x04, 0x84, 0x09, 0x00, 0x09, 0x02, 0x04, 0x8e,
+    0x05, 0x00, 0x00, 0x02, 0x04, 0x84, 0x62, 0x00,
+    0x00, 0x02, 0x04, 0x2f, 0x81, 0xfb, 0x00, 0x00,
+    0x0d, 0x0b, 0x1e, 0x28, 0x2a, 0x2c, 0x3a, 0x42,
+    0x4c, 0x6d, 0x7a, 0x8b, 0x8d, 0x92, 0x00, 0x0c,
+    0x0b, 0x1e, 0x28, 0x2a, 0x2c, 0x3a, 0x42, 0x4c,
+    0x6d, 0x8b, 0x8d, 0x92, 0x10, 0x00, 0x00, 0x14,
+    0x0b, 0x1e, 0x1f, 0x2b, 0x50, 0x28, 0x2a, 0x2c,
+    0x3a, 0x4b, 0x4c, 0x5d, 0x6d, 0x40, 0x7e, 0x83,
+    0x8a, 0x8b, 0x8d, 0x92, 0x00, 0x15, 0x0b, 0x1e,
+    0x1f, 0x2b, 0x50, 0x28, 0x2a, 0x2c, 0x3a, 0x44,
+    0x4b, 0x4c, 0x5d, 0x6d, 0x40, 0x7e, 0x83, 0x8a,
+    0x8b, 0x8d, 0x92, 0x09, 0x04, 0x1e, 0x1f, 0x39,
+    0x4b, 0x75, 0x00, 0x09, 0x03, 0x0b, 0x15, 0x83,
+    0x75, 0x00, 0x09, 0x02, 0x2c, 0x5a, 0x75, 0x00,
+    0x09, 0x02, 0x2a, 0x3f, 0x80, 0x75, 0x00, 0x0d,
+    0x02, 0x28, 0x8b, 0x80, 0x71, 0x00, 0x09, 0x02,
+    0x3a, 0x5d, 0x82, 0xcf, 0x00, 0x09, 0x03, 0x15,
+    0x5b, 0x87, 0x80, 0x30, 0x00, 0x00, 0x02, 0x25,
+    0x42, 0x85, 0xb8, 0x00, 0x01, 0x04, 0x11, 0x30,
+    0x86, 0x85, 0x80, 0x4a, 0x00, 0x01, 0x02, 0x58,
+    0x73, 0x00, 0x00, 0x00, 0x02, 0x58, 0x73, 0x84,
+    0x49, 0x00, 0x00, 0x04, 0x0b, 0x1e, 0x28, 0x3a,
+    0x00, 0x01, 0x1e, 0x00, 0x04, 0x0b, 0x1e, 0x28,
+    0x3a, 0x00, 0x02, 0x1e, 0x28, 0x00, 0x01, 0x1e,
+    0x01, 0x02, 0x0b, 0x1e, 0x00, 0x02, 0x1e, 0x7a,
+    0x00, 0x02, 0x0b, 0x1e, 0x00, 0x02, 0x1e, 0x7a,
+    0x00, 0x06, 0x1e, 0x3a, 0x4c, 0x6d, 0x8b, 0x8d,
+    0x00, 0x01, 0x1e, 0x01, 0x02, 0x1e, 0x7a, 0x01,
+    0x01, 0x1e, 0x00, 0x02, 0x1e, 0x7a, 0x00, 0x02,
+    0x0b, 0x1e, 0x06, 0x01, 0x1e, 0x00, 0x02, 0x1e,
+    0x5d, 0x00, 0x02, 0x0b, 0x1e, 0x01, 0x01, 0x1e,
+    0x00, 0x02, 0x0b, 0x1e, 0x03, 0x01, 0x1e, 0x00,
+    0x08, 0x0b, 0x1e, 0x28, 0x3a, 0x5d, 0x6d, 0x8d,
+    0x92, 0x00, 0x02, 0x1e, 0x28, 0x00, 0x03, 0x1e,
+    0x28, 0x3a, 0x01, 0x02, 0x0b, 0x1e, 0x00, 0x01,
+    0x0b, 0x01, 0x02, 0x1e, 0x28, 0x00, 0x01, 0x5d,
+    0x80, 0x44, 0x00, 0x01, 0x01, 0x29, 0x81, 0xec,
+    0x00, 0x00, 0x02, 0x42, 0x58, 0x80, 0x3f, 0x00,
+    0x00, 0x03, 0x1e, 0x28, 0x42, 0x8c, 0xd1, 0x00,
+    0x00, 0x02, 0x1c, 0x26, 0x81, 0x3c, 0x00, 0x01,
+    0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x00,
+    0x05, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x01, 0x00,
+    0x00, 0x01, 0x2d, 0x00, 0x00, 0x09, 0x06, 0x0d,
+    0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x00, 0x00, 0x00,
+    0x05, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x07, 0x06,
+    0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x03, 0x05,
+    0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x09, 0x00, 0x03,
+    0x02, 0x0d, 0x2d, 0x01, 0x00, 0x00, 0x05, 0x0d,
+    0x2e, 0x2d, 0x33, 0x3b, 0x04, 0x02, 0x33, 0x3b,
+    0x00, 0x00, 0x00, 0x05, 0x0d, 0x2e, 0x2d, 0x33,
+    0x3b, 0x03, 0x00, 0x01, 0x03, 0x2d, 0x33, 0x3b,
+    0x01, 0x01, 0x2d, 0x58, 0x00, 0x03, 0x02, 0x33,
+    0x3b, 0x02, 0x00, 0x00, 0x02, 0x33, 0x3b, 0x59,
+    0x00, 0x00, 0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b,
+    0x97, 0x00, 0x02, 0x33, 0x3b, 0x80, 0x12, 0x00,
+    0x0f, 0x01, 0x2d, 0x1f, 0x00, 0x23, 0x01, 0x2d,
+    0x3b, 0x00, 0x27, 0x01, 0x2d, 0x37, 0x00, 0x30,
+    0x01, 0x2d, 0x0e, 0x00, 0x0b, 0x01, 0x2d, 0x32,
+    0x00, 0x00, 0x01, 0x2d, 0x57, 0x00, 0x18, 0x01,
+    0x2d, 0x09, 0x00, 0x04, 0x01, 0x2d, 0x5f, 0x00,
+    0x1e, 0x01, 0x2d, 0xc0, 0x31, 0xef, 0x00, 0x00,
+    0x02, 0x1c, 0x26, 0x81, 0x3f, 0x00, 0x02, 0x0e,
+    0x1e, 0x1f, 0x2a, 0x2c, 0x3f, 0x3a, 0x39, 0x4b,
+    0x4c, 0x57, 0x5d, 0x40, 0x8a, 0x92, 0x02, 0x0d,
+    0x1e, 0x1f, 0x2a, 0x2c, 0x3f, 0x3a, 0x39, 0x4b,
+    0x57, 0x5d, 0x40, 0x8a, 0x92, 0x03, 0x0b, 0x1e,
+    0x1f, 0x2a, 0x2c, 0x3f, 0x39, 0x4b, 0x57, 0x40,
+    0x8a, 0x92, 0x80, 0x36, 0x00, 0x00, 0x02, 0x0b,
+    0x1e, 0x00, 0x00, 0x00, 0x02, 0x1e, 0x8b, 0x39,
+    0x00, 0x00, 0x03, 0x3c, 0x42, 0x5b, 0x80, 0x1f,
+    0x00, 0x00, 0x02, 0x10, 0x38, 0xc0, 0x13, 0xa1,
+    0x00, 0x00, 0x02, 0x04, 0x8e, 0x09, 0x00, 0x00,
+    0x02, 0x04, 0x8e, 0x46, 0x00, 0x01, 0x05, 0x0d,
+    0x2e, 0x2d, 0x33, 0x3b, 0x80, 0x99, 0x00, 0x04,
+    0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x09,
+    0x00, 0x00, 0x02, 0x33, 0x3b, 0x2c, 0x00, 0x01,
+    0x02, 0x33, 0x3b, 0x80, 0xdf, 0x00, 0x02, 0x02,
+    0x1b, 0x46, 0x03, 0x00, 0x2c, 0x03, 0x1b, 0x45,
+    0x46, 0x02, 0x00, 0x08, 0x02, 0x1b, 0x46, 0x81,
+    0x1f, 0x00, 0x1b, 0x02, 0x04, 0x19, 0x8f, 0x84,
+    0x00, 0x00, 0x02, 0x28, 0x8b, 0x00, 0x00, 0x00,
+    0x02, 0x28, 0x8b, 0x36, 0x00, 0x01, 0x02, 0x28,
+    0x8b, 0x8c, 0x12, 0x00, 0x01, 0x02, 0x28, 0x8b,
+    0x00, 0x00, 0x00, 0x02, 0x28, 0x8b, 0xc0, 0x5c,
+    0x4b, 0x00, 0x03, 0x01, 0x20, 0x96, 0x3b, 0x00,
+    0x11, 0x01, 0x2d, 0x9e, 0x5d, 0x00, 0x01, 0x01,
+    0x2d, 0xce, 0xcd, 0x2d, 0x00,
 };
 
 static const uint8_t unicode_prop_Hyphen_table[28] = {
@@ -3462,7 +3501,7 @@ static const uint8_t unicode_prop_Other_Math_table[200] = {
     0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
 };
 
-static const uint8_t unicode_prop_Other_Alphabetic_table[389] = {
+static const uint8_t unicode_prop_Other_Alphabetic_table[396] = {
     0x43, 0x44, 0x80, 0x42, 0x69, 0x8d, 0x00, 0x01,
     0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c, 0x06, 0x8f,
     0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80,
@@ -3482,36 +3521,37 @@ static const uint8_t unicode_prop_Other_Alphabetic_table[389] = {
     0x81, 0xbc, 0x01, 0x86, 0x91, 0x80, 0xe2, 0x01,
     0x28, 0x81, 0x8f, 0x80, 0x40, 0xa2, 0x90, 0x8a,
     0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00, 0x0b, 0x96,
-    0x1b, 0x10, 0x03, 0x0f, 0x83, 0x8c, 0x84, 0x94,
-    0x81, 0x42, 0xc0, 0x80, 0x43, 0xb1, 0x81, 0x9d,
-    0x81, 0x9d, 0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40,
-    0xbb, 0x81, 0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88,
-    0x40, 0xdd, 0x84, 0xb8, 0x89, 0x81, 0x93, 0x40,
-    0x8a, 0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88,
-    0x09, 0xb8, 0x8a, 0xb1, 0x91, 0x40, 0xbb, 0x81,
-    0x40, 0xf2, 0x8d, 0x46, 0xc0, 0xb3, 0x48, 0xf5,
-    0x9f, 0x60, 0x78, 0x73, 0x87, 0xa1, 0x81, 0x41,
-    0x82, 0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xdf,
-    0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b, 0xe8,
-    0x8d, 0x8b, 0x07, 0x81, 0xe1, 0x00, 0x11, 0x0c,
-    0x80, 0xab, 0x24, 0x80, 0x40, 0xec, 0x87, 0x60,
-    0x4f, 0x32, 0x80, 0x48, 0x56, 0x84, 0x46, 0x85,
-    0x10, 0x0c, 0x83, 0x43, 0x13, 0x83, 0x42, 0xd7,
-    0x82, 0xb4, 0x8d, 0xbb, 0x80, 0xac, 0x88, 0xc6,
-    0x82, 0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf,
-    0x8c, 0xeb, 0x88, 0x08, 0x28, 0x40, 0x9f, 0x89,
-    0x96, 0x83, 0xb9, 0x31, 0x09, 0x81, 0x89, 0x80,
-    0x89, 0x81, 0x40, 0xd0, 0x8c, 0x02, 0xe9, 0x91,
-    0x40, 0xec, 0x31, 0x86, 0x9c, 0x81, 0xd1, 0x8e,
-    0x00, 0xe9, 0x8a, 0xe6, 0x8d, 0x41, 0x00, 0x8c,
-    0x41, 0xc7, 0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a,
+    0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c, 0x8b, 0x00,
+    0x89, 0x83, 0x46, 0x73, 0x81, 0x9d, 0x81, 0x9d,
+    0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40, 0xbb, 0x81,
+    0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88, 0x40, 0xdd,
+    0x84, 0xb8, 0x89, 0x81, 0x93, 0x40, 0x8a, 0x84,
+    0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09, 0xb8,
+    0x8a, 0xb1, 0x92, 0x41, 0xaf, 0x8d, 0x46, 0xc0,
+    0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73, 0x87,
+    0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96, 0x84,
+    0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80, 0xa5,
+    0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b, 0xa4,
+    0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac, 0x82,
+    0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24, 0x80,
+    0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80, 0x48,
+    0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0x43,
+    0x13, 0x83, 0x42, 0xd7, 0x82, 0xb4, 0x8d, 0xbb,
+    0x80, 0xac, 0x88, 0xc6, 0x82, 0xa3, 0x8b, 0x91,
+    0x81, 0xb8, 0x82, 0xaf, 0x8c, 0xeb, 0x88, 0x08,
+    0x28, 0x40, 0x9f, 0x89, 0x96, 0x83, 0xb9, 0x31,
+    0x09, 0x81, 0x89, 0x80, 0x89, 0x81, 0x40, 0xd0,
+    0x8c, 0x02, 0xe9, 0x91, 0x40, 0xec, 0x31, 0x86,
+    0x9c, 0x81, 0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6,
+    0x8d, 0x41, 0x00, 0x8c, 0x41, 0x97, 0x31, 0x2b,
+    0x80, 0x9b, 0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a,
     0xad, 0x8d, 0x41, 0x96, 0x38, 0x86, 0xd2, 0x95,
     0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x10, 0x02,
     0x80, 0xc1, 0x20, 0x08, 0x83, 0x41, 0x5b, 0x83,
-    0x60, 0x4c, 0x38, 0x86, 0x44, 0x19, 0xad, 0x60,
-    0x4d, 0x1e, 0x80, 0x60, 0x23, 0x60, 0x30, 0x90,
-    0x0e, 0x01, 0x04, 0x49, 0x1b, 0x80, 0x47, 0xe7,
-    0x99, 0x85, 0x99, 0x85, 0x99,
+    0x60, 0x50, 0x57, 0x00, 0xb6, 0x33, 0x60, 0x4d,
+    0x0a, 0x80, 0x60, 0x23, 0x60, 0x30, 0x90, 0x0e,
+    0x01, 0x04, 0x49, 0x1b, 0x80, 0x47, 0xe7, 0x99,
+    0x85, 0x99, 0x85, 0x99,
 };
 
 static const uint8_t unicode_prop_Other_Lowercase_table[51] = {
@@ -3529,15 +3569,15 @@ static const uint8_t unicode_prop_Other_Uppercase_table[15] = {
     0xcc, 0x5f, 0x99, 0x85, 0x99, 0x85, 0x99,
 };
 
-static const uint8_t unicode_prop_Other_Grapheme_Extend_table[59] = {
+static const uint8_t unicode_prop_Other_Grapheme_Extend_table[62] = {
     0x49, 0xbd, 0x80, 0x97, 0x80, 0x41, 0x65, 0x80,
     0x97, 0x80, 0xe5, 0x80, 0x97, 0x80, 0x40, 0xe9,
     0x80, 0x91, 0x81, 0xe6, 0x80, 0x97, 0x80, 0xf6,
-    0x80, 0x8e, 0x80, 0x52, 0x2b, 0x80, 0x50, 0x20,
-    0x81, 0x60, 0xcf, 0x6d, 0x81, 0x53, 0x9d, 0x80,
-    0x97, 0x80, 0x41, 0x57, 0x80, 0x8b, 0x80, 0x40,
-    0xf0, 0x80, 0x60, 0xbb, 0xb4, 0x07, 0x84, 0x6c,
-    0x2e, 0xac, 0xdf,
+    0x80, 0x8e, 0x80, 0x4d, 0x54, 0x80, 0x44, 0xd5,
+    0x80, 0x50, 0x20, 0x81, 0x60, 0xcf, 0x6d, 0x81,
+    0x53, 0x9d, 0x80, 0x97, 0x80, 0x41, 0x57, 0x80,
+    0x8b, 0x80, 0x40, 0xf0, 0x80, 0x60, 0xbb, 0xb4,
+    0x07, 0x84, 0x6c, 0x2e, 0xac, 0xdf,
 };
 
 static const uint8_t unicode_prop_Other_Default_Ignorable_Code_Point_table[32] = {
@@ -3590,7 +3630,7 @@ static const uint8_t unicode_prop_Changes_When_Casefolded1_table[33] = {
     0x84,
 };
 
-static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[438] = {
+static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[436] = {
     0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12,
     0x10, 0x82, 0x9f, 0x80, 0xcf, 0x01, 0x80, 0x8b,
     0x07, 0x80, 0xfb, 0x01, 0x01, 0x80, 0xa5, 0x80,
@@ -3621,31 +3661,31 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[438] = {
     0x80, 0x41, 0x2e, 0x80, 0xd2, 0x80, 0x8b, 0x40,
     0xd5, 0xa9, 0x80, 0xb4, 0x00, 0x82, 0xdf, 0x09,
     0x80, 0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf,
-    0x9e, 0x80, 0xa7, 0x87, 0xae, 0x80, 0xfe, 0x80,
-    0x40, 0xff, 0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1,
-    0x80, 0x40, 0x86, 0x81, 0x43, 0x61, 0x83, 0x60,
-    0x4d, 0x9f, 0x41, 0x0d, 0x08, 0x00, 0x81, 0x89,
-    0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9, 0xa5,
-    0x86, 0x8b, 0x24, 0x00, 0x97, 0x04, 0x00, 0x01,
-    0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf,
-    0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94,
-    0x81, 0x8b, 0x80, 0x92, 0x03, 0x1a, 0x00, 0x80,
-    0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40, 0x83,
-    0x15, 0x0d, 0x0d, 0x0a, 0x16, 0x06, 0x80, 0x88,
-    0x60, 0xbc, 0xa6, 0x83, 0x54, 0xb9, 0x86, 0x8d,
-    0x87, 0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6,
-    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
-    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
-    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41,
-    0x23, 0x81, 0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01,
-    0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28,
-    0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00,
-    0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03,
-    0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04,
-    0x80, 0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80,
-    0x9f, 0x99, 0x81, 0xa3, 0x80, 0xee, 0x82, 0x8c,
-    0xab, 0x83, 0x88, 0x31, 0x61, 0x05, 0xad, 0x42,
-    0x1d, 0x6b, 0x05, 0xe1, 0x4f, 0xff,
+    0x9e, 0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f,
+    0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0x40,
+    0x86, 0x81, 0x43, 0x61, 0x83, 0x60, 0x4d, 0x9f,
+    0x41, 0x0d, 0x08, 0x00, 0x81, 0x89, 0x00, 0x00,
+    0x09, 0x82, 0xc3, 0x81, 0xe9, 0xa5, 0x86, 0x8b,
+    0x24, 0x00, 0x97, 0x04, 0x00, 0x01, 0x01, 0x80,
+    0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5,
+    0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94, 0x81, 0x8b,
+    0x80, 0x92, 0x03, 0x1a, 0x00, 0x80, 0x40, 0x86,
+    0x08, 0x80, 0x9f, 0x99, 0x40, 0x83, 0x15, 0x0d,
+    0x0d, 0x0a, 0x16, 0x06, 0x80, 0x88, 0x60, 0xbc,
+    0xa6, 0x83, 0x54, 0xb9, 0x86, 0x8d, 0x87, 0xbf,
+    0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01, 0x08,
+    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
+    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
+    0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23, 0x81,
+    0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01, 0x00, 0x08,
+    0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00,
+    0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00,
+    0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
+    0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80, 0x9f, 0x99,
+    0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c, 0xab, 0x83,
+    0x88, 0x31, 0x61, 0x05, 0xad, 0x42, 0x1d, 0x6b,
+    0x05, 0xe1, 0x4f, 0xff,
 };
 
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
@@ -3673,7 +3713,7 @@ static const uint8_t unicode_prop_Deprecated_table[23] = {
     0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
 };
 
-static const uint8_t unicode_prop_Diacritic_table[332] = {
+static const uint8_t unicode_prop_Diacritic_table[350] = {
     0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81,
     0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
     0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0,
@@ -3685,10 +3725,11 @@ static const uint8_t unicode_prop_Diacritic_table[332] = {
     0x80, 0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xae,
     0x82, 0xbb, 0x80, 0x8f, 0x80, 0xfe, 0x80, 0xfe,
     0x80, 0xed, 0x80, 0x8f, 0x80, 0xec, 0x81, 0x8f,
-    0x80, 0xfb, 0x80, 0xfb, 0x28, 0x80, 0xf8, 0x84,
-    0xca, 0x81, 0x9a, 0x00, 0x00, 0x03, 0x81, 0xc1,
-    0x10, 0x81, 0xbd, 0x80, 0xef, 0x00, 0x81, 0xcb,
-    0x30, 0x80, 0x89, 0x81, 0x47, 0x2c, 0x8a, 0x88,
+    0x80, 0xfb, 0x80, 0xfb, 0x28, 0x80, 0xea, 0x80,
+    0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00, 0x03,
+    0x81, 0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef, 0x00,
+    0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80, 0x89,
+    0x81, 0x42, 0xc0, 0x82, 0x44, 0x68, 0x8a, 0x88,
     0x80, 0x41, 0x5a, 0x82, 0x41, 0x38, 0x39, 0x80,
     0xaf, 0x8d, 0xf5, 0x80, 0x8e, 0x80, 0xa5, 0x88,
     0xb5, 0x81, 0x40, 0x89, 0x81, 0xbf, 0x85, 0xd1,
@@ -3697,8 +3738,8 @@ static const uint8_t unicode_prop_Diacritic_table[332] = {
     0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81, 0x4c,
     0xef, 0x82, 0x41, 0x3c, 0x80, 0x41, 0xf9, 0x85,
     0xe8, 0x83, 0xde, 0x80, 0x60, 0x75, 0x71, 0x80,
-    0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81, 0xa4,
-    0x8a, 0xe5, 0x80, 0xee, 0x81, 0x40, 0xc9, 0x80,
+    0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81, 0x8d,
+    0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40, 0xc9, 0x80,
     0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80, 0xde, 0x80,
     0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94, 0x82, 0xc0,
     0x83, 0xb2, 0x80, 0xe3, 0x84, 0x40, 0x8b, 0x81,
@@ -3710,15 +3751,16 @@ static const uint8_t unicode_prop_Diacritic_table[332] = {
     0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80, 0x8f,
     0x80, 0x97, 0x32, 0x84, 0x40, 0xcc, 0x02, 0x80,
     0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80, 0xf5,
-    0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0xf8,
-    0x80, 0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80,
-    0x41, 0x01, 0x00, 0x81, 0xd0, 0x80, 0x60, 0x4d,
-    0x57, 0x84, 0x44, 0x99, 0x90, 0x60, 0x61, 0xc6,
-    0x12, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x57, 0x21,
-    0x86, 0xec, 0x10, 0x82,
+    0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0xa4,
+    0x80, 0xd2, 0x80, 0x91, 0x80, 0xd0, 0x80, 0x41,
+    0xa4, 0x80, 0x41, 0x01, 0x00, 0x81, 0xd0, 0x80,
+    0x60, 0x4d, 0x57, 0x84, 0xba, 0x86, 0x44, 0x57,
+    0x90, 0x60, 0x61, 0xc6, 0x12, 0x2f, 0x39, 0x86,
+    0x9d, 0x83, 0x4f, 0x81, 0x86, 0x41, 0xb4, 0x83,
+    0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
 };
 
-static const uint8_t unicode_prop_Extender_table[82] = {
+static const uint8_t unicode_prop_Extender_table[86] = {
     0x40, 0xb6, 0x80, 0x42, 0x17, 0x81, 0x43, 0x6d,
     0x80, 0x41, 0xb8, 0x80, 0x46, 0x4a, 0x80, 0xfe,
     0x80, 0x49, 0x42, 0x80, 0xb7, 0x80, 0x42, 0x62,
@@ -3728,8 +3770,8 @@ static const uint8_t unicode_prop_Extender_table[82] = {
     0x80, 0x95, 0x80, 0x40, 0x88, 0x80, 0xeb, 0x80,
     0x94, 0x81, 0x60, 0x54, 0x7a, 0x80, 0x53, 0xeb,
     0x80, 0x42, 0x67, 0x82, 0x44, 0xce, 0x80, 0x60,
-    0x50, 0xa8, 0x81, 0x44, 0x9b, 0x81, 0x60, 0x79,
-    0x61, 0x82,
+    0x50, 0xa8, 0x81, 0x44, 0x9b, 0x08, 0x80, 0x60,
+    0x71, 0x57, 0x81, 0x48, 0x05, 0x82,
 };
 
 static const uint8_t unicode_prop_Hex_Digit_table[12] = {
@@ -3749,7 +3791,7 @@ static const uint8_t unicode_prop_Ideographic_table[58] = {
     0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82,
     0x43, 0xc4, 0x59, 0xb5, 0xc9, 0x60, 0x51, 0xef,
     0x60, 0x59, 0x0f, 0x41, 0x6d, 0x81, 0xe9, 0x60,
-    0x75, 0x25, 0x57, 0xf1, 0x8d, 0x42, 0xf2, 0x60,
+    0x75, 0x25, 0x57, 0xf7, 0x87, 0x42, 0xf2, 0x60,
     0x26, 0x7c, 0x41, 0x8b, 0x60, 0x4d, 0x03, 0x60,
     0xa6, 0xd6, 0xa8, 0x50, 0x34, 0x8a, 0x40, 0xdd,
     0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e,
@@ -3854,12 +3896,12 @@ static const uint8_t unicode_prop_Terminal_Punctuation_table[237] = {
     0x80, 0xaa, 0x8a, 0x00, 0x40, 0xea, 0x81, 0xb5,
     0x8e, 0x9e, 0x80, 0x41, 0x04, 0x81, 0x44, 0xf3,
     0x81, 0x40, 0xab, 0x03, 0x85, 0x41, 0x36, 0x81,
-    0x43, 0x14, 0x87, 0x43, 0x03, 0x81, 0xfb, 0x82,
+    0x43, 0x14, 0x87, 0x43, 0x04, 0x80, 0xfb, 0x82,
     0xc6, 0x81, 0x40, 0x9c, 0x12, 0x80, 0xa6, 0x19,
     0x81, 0x41, 0x39, 0x81, 0x41, 0x61, 0x83, 0x40,
     0xad, 0x08, 0x82, 0x40, 0xda, 0x84, 0xbd, 0x81,
     0x43, 0xbb, 0x81, 0x88, 0x82, 0x4d, 0xe3, 0x80,
-    0x8c, 0x03, 0x80, 0x89, 0x00, 0x80, 0x41, 0xb1,
+    0x8c, 0x03, 0x80, 0x89, 0x00, 0x81, 0x41, 0xb0,
     0x81, 0x60, 0x74, 0xfa, 0x81, 0x41, 0x0c, 0x82,
     0x40, 0xe2, 0x84, 0x41, 0x7d, 0x81, 0xd5, 0x81,
     0xde, 0x80, 0x40, 0x96, 0x82, 0x40, 0x92, 0x82,
@@ -3924,7 +3966,7 @@ static const uint8_t unicode_prop_Bidi_Mirrored_table[171] = {
     0x80, 0xb8, 0x80,
 };
 
-static const uint8_t unicode_prop_Emoji_table[227] = {
+static const uint8_t unicode_prop_Emoji_table[236] = {
     0xa2, 0x05, 0x04, 0x89, 0xee, 0x03, 0x80, 0x5f,
     0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95,
     0x80, 0xd9, 0x85, 0x8e, 0x81, 0x41, 0x6e, 0x81,
@@ -3950,10 +3992,11 @@ static const uint8_t unicode_prop_Emoji_table[227] = {
     0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01, 0x19,
     0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88, 0x04,
     0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05, 0x02,
-    0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x8c, 0x2a, 0x00,
-    0x0a, 0x01, 0x86, 0x42, 0x15, 0xaa, 0x02, 0x05,
-    0x80, 0xa9, 0x0b, 0x10, 0x80, 0xa6, 0x8c, 0x89,
-    0x2a, 0x8c, 0xaf,
+    0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x08, 0x89, 0x2a,
+    0x00, 0x0a, 0x01, 0x87, 0x40, 0xe4, 0x8b, 0x41,
+    0x20, 0xad, 0x80, 0x89, 0x80, 0xaa, 0x03, 0x82,
+    0xa8, 0x0d, 0x82, 0x9c, 0x81, 0xb2, 0xef, 0x1b,
+    0x14, 0x82, 0x8c, 0x85,
 };
 
 static const uint8_t unicode_prop_Emoji_Component_table[28] = {
@@ -3967,18 +4010,18 @@ static const uint8_t unicode_prop_Emoji_Modifier_table[4] = {
     0x61, 0xf3, 0xfa, 0x84,
 };
 
-static const uint8_t unicode_prop_Emoji_Modifier_Base_table[61] = {
+static const uint8_t unicode_prop_Emoji_Modifier_Base_table[63] = {
     0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
     0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
-    0x82, 0xf4, 0x09, 0x8a, 0x94, 0x1b, 0x00, 0x88,
-    0x10, 0x1a, 0x02, 0xa1, 0x80, 0x40, 0xc8, 0x0b,
+    0x82, 0xf4, 0x09, 0x8a, 0x94, 0x92, 0x10, 0x1a,
+    0x02, 0x30, 0x00, 0x97, 0x80, 0x40, 0xc8, 0x0b,
     0x80, 0x94, 0x03, 0x81, 0x40, 0xad, 0x12, 0x84,
     0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a, 0x80,
-    0x42, 0x4a, 0x20, 0x0d, 0x80, 0x88, 0x89, 0x11,
-    0xf5, 0x08, 0x81, 0x96, 0x8c,
+    0x42, 0x41, 0x07, 0x3d, 0x80, 0x88, 0x89, 0x0a,
+    0xf5, 0x08, 0x08, 0x80, 0x90, 0x10, 0x8c,
 };
 
-static const uint8_t unicode_prop_Emoji_Presentation_table[134] = {
+static const uint8_t unicode_prop_Emoji_Presentation_table[143] = {
     0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
     0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
     0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
@@ -3993,9 +4036,10 @@ static const uint8_t unicode_prop_Emoji_Presentation_table[134] = {
     0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80,
     0x40, 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91,
     0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
-    0xc5, 0x28, 0x12, 0x97, 0x0e, 0x85, 0x42, 0x15,
-    0xaa, 0x02, 0x05, 0x80, 0xa9, 0x0b, 0x10, 0x80,
-    0xa6, 0x8c, 0x89, 0x2a, 0x8c, 0xaf,
+    0xc5, 0x28, 0x12, 0x08, 0x94, 0x0e, 0x86, 0x40,
+    0xe4, 0x8b, 0x41, 0x20, 0xad, 0x80, 0x89, 0x80,
+    0xaa, 0x03, 0x82, 0xa8, 0x0d, 0x82, 0x9c, 0x81,
+    0xb2, 0xef, 0x1b, 0x14, 0x82, 0x8c, 0x85,
 };
 
 static const uint8_t unicode_prop_Extended_Pictographic_table[152] = {
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 6f5b7ee9a9..8ec55ee2fe 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -266,9 +266,7 @@ DEF(Symbol_operatorNeg, "Symbol.operatorNeg")
 DEF(Symbol_operatorNot, "Symbol.operatorNot")
 DEF(Symbol_operatorInc, "Symbol.operatorInc")
 DEF(Symbol_operatorDec, "Symbol.operatorDec")
-DEF(Symbol_operatorMathDiv, "Symbol.operatorMathDiv")
 DEF(Symbol_operatorMathMod, "Symbol.operatorMathMod")
-DEF(Symbol_operatorMathPow, "Symbol.operatorMathPow")
 #endif
 
 #endif /* DEF */
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 4d248b60fe..268ef0472e 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -487,6 +487,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
         JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
     }
     ret = JS_Eval(ctx, str, len, "<evalScript>", JS_EVAL_TYPE_GLOBAL);
+    JS_FreeCString(ctx, str);
     if (--eval_script_recurse == 0) {
         /* remove the interrupt handler */
         JS_SetInterruptHandler(JS_GetRuntime(ctx), NULL, NULL);
@@ -1409,20 +1410,20 @@ static JSValue js_os_setTimeout(JSContext *ctx, JSValueConst this_val,
     JSOSTimer *th;
     JSValue obj;
 
-    if (JS_ToInt64(ctx, &delay, argv[0]))
-        return JS_EXCEPTION;
-    func = argv[1];
+    func = argv[0];
     if (!JS_IsFunction(ctx, func))
         return JS_ThrowTypeError(ctx, "not a function");
+    if (JS_ToInt64(ctx, &delay, argv[1]))
+        return JS_EXCEPTION;
     obj = JS_NewObjectClass(ctx, js_os_timer_class_id);
     if (JS_IsException(obj))
         return obj;
     th = js_mallocz(ctx, sizeof(*th));
-    th->has_object = TRUE;
     if (!th) {
         JS_FreeValue(ctx, obj);
         return JS_EXCEPTION;
     }
+    th->has_object = TRUE;
     th->timeout = get_time_ms() + delay;
     th->func = JS_DupValue(ctx, func);
     list_add_tail(&th->link, &os_timers);
@@ -1448,8 +1449,12 @@ static JSClassDef js_os_timer_class = {
 
 static void call_handler(JSContext *ctx, JSValueConst func)
 {
-    JSValue ret;
-    ret = JS_Call(ctx, func, JS_UNDEFINED, 0, NULL);
+    JSValue ret, func1;
+    /* 'func' might be destroyed when calling itself (if it frees the
+       handler), so must take extra care */
+    func1 = JS_DupValue(ctx, func);
+    ret = JS_Call(ctx, func1, JS_UNDEFINED, 0, NULL);
+    JS_FreeValue(ctx, func1);
     if (JS_IsException(ret))
         js_std_dump_error(ctx);
     JS_FreeValue(ctx, ret);
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 9606455cca..8ee82f4525 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -2649,8 +2649,9 @@ JSValue JS_AtomToString(JSContext *ctx, JSAtom atom)
     return __JS_AtomToValue(ctx, atom, TRUE);
 }
 
-/* return TRUE if the atom is a uint32 and return its value */
-static BOOL JS_AtomGetUint32(JSContext *ctx, uint32_t *pval, JSAtom atom)
+/* return TRUE if the atom is an array index (i.e. 0 <= index <=
+   2^32-2 and return its value */
+static BOOL JS_AtomIsArrayIndex(JSContext *ctx, uint32_t *pval, JSAtom atom)
 {
     if (__JS_AtomIsTaggedInt(atom)) {
         *pval = __JS_AtomToUInt32(atom);
@@ -2663,71 +2664,7 @@ static BOOL JS_AtomGetUint32(JSContext *ctx, uint32_t *pval, JSAtom atom)
         assert(atom < rt->atom_size);
         p = rt->atom_array[atom];
         if (p->atom_type == JS_ATOM_TYPE_STRING &&
-            is_num_string(&val, p)) {
-            *pval = val;
-            return TRUE;
-        } else {
-            *pval = 0;
-            return FALSE;
-        }
-    }
-}
-
-/* return TRUE if the string is a number n with 0 <= n <= 2^53-1 */
-static inline BOOL is_integer_index_string(uint64_t *pval, const JSString *p)
-{
-    uint64_t n;
-    int c, i, len;
-
-    len = p->len;
-    if (len == 0 || len > 16)
-        return FALSE;
-    if (p->is_wide_char)
-        c = p->u.str16[0];
-    else
-        c = p->u.str8[0];
-    if (is_num(c)) {
-        if (c == '0') {
-            if (len != 1)
-                return FALSE;
-            n = 0;
-        } else {
-            n = c - '0';
-            for(i = 1; i < len; i++) {
-                if (p->is_wide_char)
-                    c = p->u.str16[i];
-                else
-                    c = p->u.str8[i];
-                if (!is_num(c))
-                    return FALSE;
-                n = n * 10 + (c - '0');
-                if (n >= ((uint64_t)1 << 53))
-                    return FALSE;
-            }
-        }
-        *pval = n;
-        return TRUE;
-    } else {
-        return FALSE;
-    }
-}
-
-/* return TRUE if the atom is an integer index (i.e. 0 <= index <=
-   2^53-1 and return its value */
-static BOOL JS_AtomIsIntegerIndex(JSContext *ctx, uint64_t *pval, JSAtom atom)
-{
-    if (__JS_AtomIsTaggedInt(atom)) {
-        *pval = __JS_AtomToUInt32(atom);
-        return TRUE;
-    } else {
-        JSRuntime *rt = ctx->rt;
-        JSAtomStruct *p;
-        uint64_t val;
-
-        assert(atom < rt->atom_size);
-        p = rt->atom_array[atom];
-        if (p->atom_type == JS_ATOM_TYPE_STRING &&
-            is_integer_index_string(&val, p)) {
+            is_num_string(&val, p) && val != -1) {
             *pval = val;
             return TRUE;
         } else {
@@ -3236,6 +3173,26 @@ static int string_get(const JSString *p, int idx) {
     return p->is_wide_char ? p->u.str16[idx] : p->u.str8[idx];
 }
 
+static int string_getc(const JSString *p, int *pidx)
+{
+    int idx, c, c1;
+    idx = *pidx;
+    if (p->is_wide_char) {
+        c = p->u.str16[idx++];
+        if (c >= 0xd800 && c < 0xdc00 && idx < p->len) {
+            c1 = p->u.str16[idx];
+            if (c1 >= 0xdc00 && c1 < 0xe000) {
+                c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+                idx++;
+            }
+        }
+    } else {
+        c = p->u.str8[idx++];
+    }
+    *pidx = idx;
+    return c;
+}
+
 static int string_buffer_write8(StringBuffer *s, const uint8_t *p, int len)
 {
     int i;
@@ -6472,11 +6429,11 @@ static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
     JSContext *ctx = opaque;
     JSAtom atom1 = ((const JSPropertyEnum *)p1)->atom;
     JSAtom atom2 = ((const JSPropertyEnum *)p2)->atom;
-    uint64_t v1, v2;
+    uint32_t v1, v2;
     BOOL atom1_is_integer, atom2_is_integer;
 
-    atom1_is_integer = JS_AtomIsIntegerIndex(ctx, &v1, atom1);
-    atom2_is_integer = JS_AtomIsIntegerIndex(ctx, &v2, atom2);
+    atom1_is_integer = JS_AtomIsArrayIndex(ctx, &v1, atom1);
+    atom2_is_integer = JS_AtomIsArrayIndex(ctx, &v2, atom2);
     assert(atom1_is_integer && atom2_is_integer);
     if (v1 < v2)
         return -1;
@@ -6515,7 +6472,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
     uint32_t num_keys_count, str_keys_count, sym_keys_count, atom_count;
     uint32_t num_index, str_index, sym_index, exotic_count;
     BOOL is_enumerable, is_string, num_sorted;
-    uint64_t num_key;
+    uint32_t num_key;
 
     /* clear pointer for consistency in case of failure */
     *ptab = NULL;
@@ -6545,7 +6502,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                         return -1;
                     }
                 }
-                if (JS_AtomIsIntegerIndex(ctx, &num_key, atom)) {
+                if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                     num_keys_count++;
                 } else if (is_string) {
                     str_keys_count++;
@@ -6597,7 +6554,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                             tab_exotic[i].is_enumerable = is_enumerable;
                         }
                         if (!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) {
-                            if (JS_AtomIsIntegerIndex(ctx, &num_key, atom)) {
+                            if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                                 num_keys_count++;
                             } else if (is_string) {
                                 str_keys_count++;
@@ -6634,7 +6591,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
             is_string = JS_AtomIsString(ctx, atom);
             if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
                 ((flags >> is_string) & 1) != 0) {
-                if (JS_AtomIsIntegerIndex(ctx, &num_key, atom)) {
+                if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                     j = num_index++;
                     num_sorted = FALSE;
                 } else if (is_string) {
@@ -6668,7 +6625,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                 is_string = JS_AtomIsString(ctx, atom);
                 if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
                     ((flags >> is_string) & 1) != 0) {
-                    if (JS_AtomIsIntegerIndex(ctx, &num_key, atom)) {
+                    if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                         j = num_index++;
                         num_sorted = FALSE;
                     } else if (is_string) {
@@ -7146,7 +7103,7 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
     if (p->is_exotic) {
         if (p->fast_array) {
             uint32_t idx;
-            if (JS_AtomGetUint32(ctx, &idx, atom) &&
+            if (JS_AtomIsArrayIndex(ctx, &idx, atom) &&
                 idx < p->u.array.count) {
                 if (p->class_id == JS_CLASS_ARRAY ||
                     p->class_id == JS_CLASS_ARGUMENTS) {
@@ -7256,8 +7213,7 @@ static int set_array_length(JSContext *ctx, JSObject *p, JSProperty *prop,
                 for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count;
                     i++, pr++) {
                     if (pr->atom != JS_ATOM_NULL &&
-                        JS_AtomGetUint32(ctx, &idx, pr->atom) &&
-                        idx != 0xffffffff) {
+                        JS_AtomIsArrayIndex(ctx, &idx, pr->atom)) {
                         if (idx >= cur_len &&
                             !(pr->flags & JS_PROP_CONFIGURABLE)) {
                             cur_len = idx + 1;
@@ -7268,8 +7224,7 @@ static int set_array_length(JSContext *ctx, JSObject *p, JSProperty *prop,
                 for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count;
                     i++, pr++) {
                     if (pr->atom != JS_ATOM_NULL &&
-                        JS_AtomGetUint32(ctx, &idx, pr->atom) &&
-                        idx != 0xffffffff) {
+                        JS_AtomIsArrayIndex(ctx, &idx, pr->atom)) {
                         if (idx >= cur_len) {
                             /* remove the property */
                             delete_property(ctx, p, pr->atom);
@@ -7861,14 +7816,14 @@ static int JS_CreateProperty(JSContext *ctx, JSObject *p,
                     } else {
                         goto convert_to_array;
                     }
-                } else if (JS_AtomGetUint32(ctx, &idx, prop) && idx != 0xffffffff) {
+                } else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
                     /* convert the fast array to normal array */
                 convert_to_array:
                     if (convert_fast_array_to_array(ctx, p))
                         return -1;
                     goto generic_array;
                 }
-            } else if (JS_AtomGetUint32(ctx, &idx, prop) && idx != 0xffffffff) {
+            } else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
                 JSProperty *plen;
                 JSShapeProperty *pslen;
             generic_array:
@@ -9081,11 +9036,11 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
                    radix == 0 && (flags & ATOD_ACCEPT_BIN_OCT)) {
             p += 2;
             radix = 2;
-        } else if ((p[1] >= '0' && p[1] <= '7') &&
+        } else if ((p[1] >= '0' && p[1] <= '9') &&
                    radix == 0 && (flags & ATOD_ACCEPT_LEGACY_OCTAL)) {
             int i;
-            for (i = 2; (p[i] >= '0' && p[i] <= '7') ||
-                (p[i] == sep && is_digit((uint8_t)p[i + 1])); i++)
+            sep = 256;
+            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
                 continue;
             if (p[i] == '8' || p[i] == '9')
                 goto no_prefix;
@@ -10400,8 +10355,8 @@ static JSValue JS_ToQuotedString(JSContext *ctx, JSValueConst val1)
 
     if (string_buffer_putc8(b, '\"'))
         goto fail;
-    for(i = 0; i < p->len; i++) {
-        c = string_get(p, i);
+    for(i = 0; i < p->len; ) {
+        c = string_getc(p, &i);
         switch(c) {
         case '\t':
             c = 't';
@@ -10427,12 +10382,12 @@ static JSValue JS_ToQuotedString(JSContext *ctx, JSValueConst val1)
                 goto fail;
             break;
         default:
-            if (c < 32) {
+            if (c < 32 || (c >= 0xd800 && c < 0xe000)) {
                 snprintf(buf, sizeof(buf), "\\u%04x", c);
                 if (string_buffer_puts8(b, buf))
                     goto fail;
             } else {
-                if (string_buffer_putc16(b, c))
+                if (string_buffer_putc(b, c))
                     goto fail;
             }
             break;
@@ -10465,12 +10420,19 @@ static __attribute__((unused)) void JS_DumpObject(JSRuntime *rt, JSObject *p)
     BOOL is_first = TRUE;
 
     /* XXX: should encode atoms with special characters */
-    printf("%14p %4d %3d%c %14p %10s ",
+    sh = p->shape; /* the shape can be NULL while freeing an object */
+    printf("%14p %4d ",
            (void *)p,
-           p->header.ref_count,
-           p->shape->header.ref_count,
-           " *"[p->shape->is_hashed],
-           (void *)p->shape->proto,
+           p->header.ref_count);
+    if (sh) {
+        printf("%3d%c %14p ",
+               sh->header.ref_count,
+               " *"[sh->is_hashed],
+               (void *)sh->proto);
+    } else {
+        printf("%3s  %14s ", "-", "-");
+    }
+    printf("%10s ",
            JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), rt->class_array[p->class_id].class_name));
     if (p->is_exotic && p->fast_array) {
         printf("[ ");
@@ -10495,31 +10457,32 @@ static __attribute__((unused)) void JS_DumpObject(JSRuntime *rt, JSObject *p)
         printf(" ] ");
     }
 
-    printf("{ ");
-    sh = p->shape;
-    for(i = 0, prs = get_shape_prop(sh); i < sh->prop_count; i++, prs++) {
-        if (prs->atom != JS_ATOM_NULL) {
-            pr = &p->prop[i];
-            if (!is_first)
-                printf(", ");
-            printf("%s: ",
-                   JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), prs->atom));
-            if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
-                printf("[getset %p %p]", (void *)pr->u.getset.getter,
-                       (void *)pr->u.getset.setter);
-            } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
-                printf("[varref %p]", (void *)pr->u.var_ref);
-            } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                printf("[autoinit %p %p]", (void *)pr->u.init.init_func,
-                       (void *)pr->u.init.opaque);
-            } else {
-                JS_DumpValueShort(rt, pr->u.value);
+    if (sh) {
+        printf("{ ");
+        for(i = 0, prs = get_shape_prop(sh); i < sh->prop_count; i++, prs++) {
+            if (prs->atom != JS_ATOM_NULL) {
+                pr = &p->prop[i];
+                if (!is_first)
+                    printf(", ");
+                printf("%s: ",
+                       JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), prs->atom));
+                if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
+                    printf("[getset %p %p]", (void *)pr->u.getset.getter,
+                           (void *)pr->u.getset.setter);
+                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
+                    printf("[varref %p]", (void *)pr->u.var_ref);
+                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
+                    printf("[autoinit %p %p]", (void *)pr->u.init.init_func,
+                           (void *)pr->u.init.opaque);
+                } else {
+                    JS_DumpValueShort(rt, pr->u.value);
+                }
+                is_first = FALSE;
             }
-            is_first = FALSE;
         }
+        printf(" }");
     }
-    printf(" }");
-
+    
     if (js_class_has_bytecode(p->class_id)) {
         JSFunctionBytecode *b = p->u.func.function_bytecode;
         JSVarRef **var_refs;
@@ -10974,23 +10937,19 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
         op_name = JS_ATOM_Symbol_operatorMul;
         break;
     case OP_div:
+    case OP_math_div:
         op_name = JS_ATOM_Symbol_operatorDiv;
         break;
     case OP_mod:
         op_name = JS_ATOM_Symbol_operatorMod;
         break;
     case OP_pow:
+    case OP_math_pow:
         op_name = JS_ATOM_Symbol_operatorPow;
         break;
-    case OP_math_div:
-        op_name = JS_ATOM_Symbol_operatorMathDiv;
-        break;
     case OP_math_mod:
         op_name = JS_ATOM_Symbol_operatorMathMod;
         break;
-    case OP_math_pow:
-        op_name = JS_ATOM_Symbol_operatorMathPow;
-        break;
     case OP_shl:
         op_name = JS_ATOM_Symbol_operatorShl;
         break;
@@ -11517,7 +11476,8 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                                 BF_RNDZ) & BF_ST_INVALID_OP;
                 bf_delete(rem);
             } else {
-                bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+                bf_div(r, a, b, 53, bf_set_exp_bits(11) |
+                       BF_RNDN | BF_FLAG_SUBNORMAL);
                 goto float64_result;
             }
             break;
@@ -11541,50 +11501,44 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             if (b->sign) {
                 if (is_legacy) {
                     ret = BF_ST_INVALID_OP;
-                } else {
-                    bf_set_ui(r, 1);
-                    if (bf_cmpu(a, r) <= 0) {
-                        goto do_int_pow;
-                    } else if (op == OP_math_pow) {
-                    op_fallback:
-                        bf_delete(r);
-                        if (a == &a_s)
-                            bf_delete(a);
-                        if (b == &b_s)
-                            bf_delete(b);
-                    op_fallback2:
-                        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
-                        JS_FreeValue(ctx, op1);
-                        JS_FreeValue(ctx, op2);
-                        if (ret < 0) {
-                            goto exception;
-                        } else if (ret == 0) {
-                            JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
-                            goto exception;
-                        }
-                        sp[-2] = res;
-                        return 0;
-                    } else {
-                        double dr;
-                        bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
-                               BF_RNDN | BF_FLAG_SUBNORMAL);
-                    float64_result:
-                        bf_get_float64(r, &dr, BF_RNDN);
-                        bf_delete(r);
-                        if (a == &a_s)
-                            bf_delete(a);
-                        if (b == &b_s)
-                            bf_delete(b);
-                        JS_FreeValue(ctx, op1);
-                        JS_FreeValue(ctx, op2);
-                        sp[-2] = __JS_NewFloat64(ctx, dr);
-                        return 0;
+                } else if (op == OP_math_pow) {
+                op_fallback:
+                    bf_delete(r);
+                    if (a == &a_s)
+                        bf_delete(a);
+                    if (b == &b_s)
+                        bf_delete(b);
+                op_fallback2:
+                    ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+                    JS_FreeValue(ctx, op1);
+                    JS_FreeValue(ctx, op2);
+                    if (ret < 0) {
+                        goto exception;
+                    } else if (ret == 0) {
+                        JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
+                        goto exception;
                     }
+                    sp[-2] = res;
+                    return 0;
+                } else {
+                    double dr;
+                    bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
+                           BF_RNDN | BF_FLAG_SUBNORMAL);
+                float64_result:
+                    bf_get_float64(r, &dr, BF_RNDN);
+                    bf_delete(r);
+                    if (a == &a_s)
+                        bf_delete(a);
+                    if (b == &b_s)
+                        bf_delete(b);
+                    JS_FreeValue(ctx, op1);
+                    JS_FreeValue(ctx, op2);
+                    sp[-2] = __JS_NewFloat64(ctx, dr);
+                    return 0;
                 }
             } else {
-            do_int_pow:
                 ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUICKS) &
-                    (BF_ST_OVERFLOW | BF_ST_DIVIDE_ZERO);
+                    BF_ST_OVERFLOW;
             }
             break;
         default:
@@ -13155,7 +13109,7 @@ static int js_arguments_define_own_property(JSContext *ctx,
     uint32_t idx;
     p = JS_VALUE_GET_OBJ(this_obj);
     /* convert to normal array when redefining an existing numeric field */
-    if (p->fast_array && JS_AtomGetUint32(ctx, &idx, prop) &&
+    if (p->fast_array && JS_AtomIsArrayIndex(ctx, &idx, prop) &&
         idx < p->u.array.count) {
         if (convert_fast_array_to_array(ctx, p))
             return -1;
@@ -13736,6 +13690,18 @@ static JSValue js_array_iterator_next(JSContext *ctx, JSValueConst this_val,
 static JSValue js_create_array_iterator(JSContext *ctx, JSValueConst this_val,
                                         int argc, JSValueConst *argv, int magic);
 
+static BOOL js_is_fast_array(JSContext *ctx, JSValueConst obj)
+{
+    /* Try and handle fast arrays explicitly */
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(obj);
+        if (p->class_id == JS_CLASS_ARRAY && p->fast_array) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
 /* Access an Array's internal JSValue array if available */
 static BOOL js_get_fast_array(JSContext *ctx, JSValueConst obj,
                               JSValue **arrpp, uint32_t *countp)
@@ -14132,7 +14098,7 @@ static int js_op_define_class(JSContext *ctx, JSValue *sp,
     return -1;
 }
 
-static void close_var_refs(JSContext *ctx, JSStackFrame *sf)
+static void close_var_refs(JSRuntime *rt, JSStackFrame *sf)
 {
     struct list_head *el, *el1;
     JSVarRef *var_ref;
@@ -14142,9 +14108,9 @@ static void close_var_refs(JSContext *ctx, JSStackFrame *sf)
         var_ref = list_entry(el, JSVarRef, link);
         var_idx = var_ref->var_idx;
         if (var_ref->is_arg)
-            var_ref->value = JS_DupValue(ctx, sf->arg_buf[var_idx]);
+            var_ref->value = JS_DupValueRT(rt, sf->arg_buf[var_idx]);
         else
-            var_ref->value = JS_DupValue(ctx, sf->var_buf[var_idx]);
+            var_ref->value = JS_DupValueRT(rt, sf->var_buf[var_idx]);
         var_ref->pvalue = &var_ref->value;
         var_ref->link.prev = NULL; /* the reference is no longer to a
                                       local variable */
@@ -14205,6 +14171,9 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     arg_buf = argv;
 
     arg_count = p->u.cfunc.length;
+    /* better to always check stack overflow */
+    if (js_check_stack_overflow(ctx, sizeof(arg_buf[0]) * arg_count))
+        return JS_ThrowStackOverflow(ctx);
 
     if (unlikely(argc < arg_count)) {
         /* ensure that at least argc_count arguments are readable */
@@ -14317,6 +14286,8 @@ static JSValue js_call_bound_function(JSContext *ctx, JSValueConst func_obj,
     p = JS_VALUE_GET_OBJ(func_obj);
     bf = p->u.bound_function;
     arg_count = bf->argc + argc;
+    if (js_check_stack_overflow(ctx, sizeof(JSValue) * arg_count))
+        return JS_ThrowStackOverflow(ctx);
     arg_buf = alloca(sizeof(JSValue) * arg_count);
     for(i = 0; i < bf->argc; i++) {
         arg_buf[i] = bf->argv[i];
@@ -16011,8 +15982,14 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     var_buf[idx] = JS_NewInt32(ctx, r);
                     sp--;
                 } else if (JS_VALUE_GET_TAG(ops[0]) == JS_TAG_STRING) {
-                    ops[0] = JS_ConcatString(ctx, ops[0], ops[1]);
                     sp--;
+                    ops[1] = JS_ToPrimitiveFree(ctx, ops[1], HINT_NONE);
+                    if (JS_IsException(ops[1])) {
+                        goto exception;
+                    }
+                    /* XXX: should not modify the variable in case of
+                       exception */
+                    ops[0] = JS_ConcatString(ctx, ops[0], ops[1]);
                     if (JS_IsException(ops[0])) {
                         var_buf[idx] = JS_UNDEFINED;
                         goto exception;
@@ -16020,11 +15997,17 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     var_buf[idx] = ops[0];
                 } else {
                 add_loc_slow:
+                    /* XXX: should not modify the variable in case of
+                       exception */
+                    sp--;
+                    /* In case of exception, js_add_slow frees ops[0]
+                       and ops[1]. */
                     /* XXX: change API */
-                    if (js_add_slow(ctx, ops + 2))
+                    if (js_add_slow(ctx, ops + 2)) {
+                        var_buf[idx] = JS_UNDEFINED;
                         goto exception;
+                    }
                     var_buf[idx] = ops[0];
-                    sp--;
                 }
             }
             BREAK;
@@ -16739,7 +16722,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     done:
         if (unlikely(!list_empty(&sf->var_ref_list))) {
             /* variable references reference the stack: must close them */
-            close_var_refs(ctx, sf);
+            close_var_refs(ctx->rt, sf);
         }
         /* free the local variables and stack */
         for(pval = local_buf; pval < sp; pval++) {
@@ -16957,6 +16940,10 @@ static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
     JSValue *sp;
 
     sf = &s->frame;
+
+    /* close the closure variables. */
+    close_var_refs(rt, sf);
+    
     if (sf->arg_buf) {
         /* cannot free the function if it is running */
         assert(sf->cur_sp != NULL);
@@ -16969,13 +16956,6 @@ static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
     JS_FreeValueRT(rt, s->this_val);
 }
 
-/* close the closure variables */
-static void async_func_detach(JSContext *ctx, JSAsyncFunctionState *s)
-{
-    JSStackFrame *sf = &s->frame;
-    close_var_refs(ctx, sf);
-}
-
 static JSValue async_func_resume(JSContext *ctx, JSAsyncFunctionState *s)
 {
     JSValue func_obj;
@@ -17022,11 +17002,7 @@ static void js_generator_finalizer(JSRuntime *rt, JSValue obj)
 
 static void free_generator_stack(JSContext *ctx, JSGeneratorData *s)
 {
-    if (s->state != JS_GENERATOR_STATE_COMPLETED) {
-        /* detach the closures variables */
-        async_func_detach(ctx, &s->func_state);
-        free_generator_stack_rt(ctx->rt, s);
-    }
+    free_generator_stack_rt(ctx->rt, s);
 }
 
 static void js_generator_mark(JSRuntime *rt, JSValueConst val,
@@ -17245,8 +17221,6 @@ static void js_async_function_terminate(JSRuntime *rt, JSContext *ctx,
                                         JSAsyncFunctionData *s)
 {
     if (s->is_active) {
-        if (ctx)
-            async_func_detach(ctx, &s->func_state);
         async_func_free(rt, &s->func_state);
         s->is_active = FALSE;
     }
@@ -17624,7 +17598,6 @@ static void js_async_generator_complete(JSContext *ctx,
 {
     if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED) {
         s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
-        async_func_detach(ctx, &s->func_state);
         async_func_free(ctx->rt, &s->func_state);
     }
 }
@@ -18324,20 +18297,6 @@ int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const
     return -1;
 }
 
-int __attribute__((format(printf, 3, 4))) js_parse_error1(JSParseState *s, JSErrorEnum error_num,
-                                                          const char *fmt, ...)
-{
-    JSContext *ctx = s->ctx;
-    va_list ap;
-
-    va_start(ap, fmt);
-    JS_ThrowError(ctx, error_num, fmt, ap);
-    va_end(ap);
-
-    build_backtrace(ctx, ctx->current_exception, s->filename, s->line_num, NULL);
-    return -1;
-}
-
 static int js_parse_expect(JSParseState *s, int tok)
 {
     if (s->token.val != tok) {
@@ -18574,6 +18533,7 @@ static inline BOOL token_is_pseudo_keyword(JSParseState *s, JSAtom atom) {
         !s->token.u.ident.has_escape;
 }
 
+#if 0
 /* return TRUE if a regexp literal is allowed after this token */
 static BOOL is_regexp_allowed(JSParseState *s)
 {
@@ -18597,6 +18557,7 @@ static BOOL is_regexp_allowed(JSParseState *s)
         return TRUE;
     }
 }
+#endif
 
 static __exception int js_parse_regexp(JSParseState *s)
 {
@@ -18770,9 +18731,21 @@ static __exception int next_token(JSParseState *s)
                     p += 2;
                     break;
                 }
-                if (*p == '\n')
+                if (*p == '\n') {
                     s->line_num++;
-                p++;
+                    s->got_lf = TRUE; /* considered as LF for ASI */
+                    p++;
+                } else if (*p == '\r') {
+                    s->got_lf = TRUE; /* considered as LF for ASI */
+                    p++;
+                } else if (*p >= 0x80) {
+                    c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+                    if (c == CP_LS || c == CP_PS) {
+                        s->got_lf = TRUE; /* considered as LF for ASI */
+                    }
+                } else {
+                    p++;
+                }
             }
             goto redo;
         } else if (p[1] == '/') {
@@ -18794,12 +18767,16 @@ static __exception int next_token(JSParseState *s)
                 }
             }
             goto redo;
-        } else if (is_regexp_allowed(s)) {
+        }
+#if 0
+        else if (is_regexp_allowed(s)) {
             s->buf_ptr = p;
             if (js_parse_regexp(s))
                 goto fail;
             p = s->buf_ptr;
-        } else if (p[1] == '=') {
+        }
+#endif
+        else if (p[1] == '=') {
             p += 2;
             s->token.val = TOK_DIV_ASSIGN;
         } else {
@@ -19208,7 +19185,9 @@ static __exception int next_token(JSParseState *s)
                     /* <PS> and <LS> are not JSONWhitespace */
                     goto def_token;
                 } else {
-                    goto line_terminator;
+                    /* XXX: should avoid incrementing line_number, but
+                       needed to handle HTML comments */
+                    goto line_terminator; 
                 }
             default:
                 if (lre_is_space(c)) {
@@ -20161,6 +20140,8 @@ static __exception int js_parse_seek_token(JSParseState *s, const JSParsePos *sp
 #define SKIP_HAS_ELLIPSIS  (1 << 1)
 
 /* XXX: improve speed with early bailout */
+/* XXX: no longer works if regexps are present. Could use previous
+   regexp parsing heuristics to handle most cases */
 static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_terminator)
 {
     char state[256];
@@ -20169,7 +20150,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
     int tok = TOK_EOF;
     int bits = 0;
 
-    /* protect fom underflow */
+    /* protect from underflow */
     state[level++] = 0;
 
     js_parse_get_pos(s, &pos);
@@ -20382,7 +20363,8 @@ static __exception int js_parse_class_default_ctor(JSParseState *s,
     const char *str;
     int ret, line_num;
     JSParseFunctionEnum func_type;
-
+    const uint8_t *saved_buf_end;
+    
     js_parse_get_pos(s, &pos);
     if (has_super) {
         str = "(...a){super(...a);}";
@@ -20392,13 +20374,16 @@ static __exception int js_parse_class_default_ctor(JSParseState *s,
         func_type = JS_PARSE_FUNC_CLASS_CONSTRUCTOR;
     }
     line_num = s->token.line_num;
+    saved_buf_end = s->buf_end;
     s->buf_ptr = (uint8_t *)str;
+    s->buf_end = (uint8_t *)(str + strlen(str));
     ret = next_token(s);
     if (!ret) {
         ret = js_parse_function_decl2(s, func_type, JS_FUNC_NORMAL,
                                       JS_ATOM_NULL, (uint8_t *)str,
                                       line_num, JS_PARSE_EXPORT_NONE, pfd);
     }
+    s->buf_end = saved_buf_end;
     ret |= js_parse_seek_token(s, &pos);
     return ret;
 }
@@ -20832,12 +20817,11 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
         if (tok == TOK_FOR) {
             return js_parse_error(s, "invalid for in/of left hand-side");
         } else if (tok == TOK_INC || tok == TOK_DEC) {
-            /* Firefox issues a SyntaxError for this */
-            return js_parse_error1(s, JS_REFERENCE_ERROR, "invalid increment/decrement operand");
+            return js_parse_error(s, "invalid increment/decrement operand");
         } else if (tok == '[' || tok == '{') {
             return js_parse_error(s, "invalid destructuring target");
         } else {
-            return js_parse_error1(s, JS_REFERENCE_ERROR, "invalid assignment left-hand side");
+            return js_parse_error(s, "invalid assignment left-hand side");
         }
     }
     /* remove the last opcode */
@@ -21054,7 +21038,8 @@ static JSAtom js_parse_destructing_var(JSParseState *s, int tok, int is_arg)
 }
 
 static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
-                                        int hasval, int has_ellipsis)
+                                        int hasval, int has_ellipsis,
+                                        BOOL allow_initializer)
 {
     int label_parse, label_assign, label_done, label_lvalue, depth_lvalue;
     int start_addr, assign_addr;
@@ -21167,7 +21152,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                         emit_op(s, OP_get_field2);
                         emit_u32(s, prop_name);
                     }
-                    if (js_parse_destructing_element(s, tok, is_arg, TRUE, -1))
+                    if (js_parse_destructing_element(s, tok, is_arg, TRUE, -1, TRUE))
                         return -1;
                     if (s->token.val == '}')
                         break;
@@ -21391,7 +21376,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                     emit_u8(s, 0);
                     emit_op(s, OP_drop);
                 }
-                if (js_parse_destructing_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS))
+                if (js_parse_destructing_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 var_name = JS_ATOM_NULL;
@@ -21482,7 +21467,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
     } else {
         return js_parse_error(s, "invalid assignment syntax");
     }
-    if (s->token.val == '=') {
+    if (s->token.val == '=' && allow_initializer) {
         label_done = emit_goto(s, OP_goto, -1);
         if (next_token(s))
             return -1;
@@ -21576,12 +21561,21 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         if (next_token(s))
             return -1;
         break;
-    case TOK_REGEXP:
+        
+    case TOK_DIV_ASSIGN:
+        s->buf_ptr -= 2;
+        goto parse_regexp;
+    case '/':
+        s->buf_ptr--;
+    parse_regexp:
         {
             JSValue str;
             int ret;
             if (!s->ctx->compile_regexp)
                 return js_parse_error(s, "RegExp are not supported");
+            /* the previous token is '/' or '/=', so no need to free */
+            if (js_parse_regexp(s))
+                return -1;
             ret = emit_push_const(s, s->token.u.regexp.body, 0);
             str = s->ctx->compile_regexp(s->ctx, s->token.u.regexp.body,
                                          s->token.u.regexp.flags);
@@ -21699,7 +21693,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         {
             int skip_bits;
             if (js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
-                if (js_parse_destructing_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS))
+                if (js_parse_destructing_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 if (s->token.val == '{') {
@@ -22219,7 +22213,6 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
     if (exponentiation_flag) {
 #ifdef CONFIG_BIGNUM
         if (s->token.val == TOK_POW || s->token.val == TOK_MATH_POW) {
-            int val = s->token.val;
             /* Extended exponentiation syntax rules: we extend the ES7
                grammar in order to have more intuitive semantics:
                -2**2 evaluates to -4. */
@@ -22233,10 +22226,10 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
                 return -1;
             if (js_parse_unary(s, 1))
                 return -1;
-            if (val == TOK_POW)
-                emit_op(s, OP_pow);
-            else
+            if (s->cur_func->js_mode & JS_MODE_MATH)
                 emit_op(s, OP_math_pow);
+            else
+                emit_op(s, OP_pow);
         }
 #else
         if (s->token.val == TOK_POW) {
@@ -22641,7 +22634,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                 OP_mul, OP_div, OP_mod, OP_add, OP_sub,
                 OP_shl, OP_sar, OP_shr, OP_and, OP_xor, OP_or,
 #ifdef CONFIG_BIGNUM
-                OP_math_pow,
+                OP_pow,
 #endif
                 OP_pow,
             };
@@ -22652,6 +22645,8 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                     op = OP_math_div;
                 else if (op == OP_mod)
                     op = OP_math_mod;
+                else if (op == OP_pow)
+                    op = OP_math_pow;
             }
 #endif
             emit_op(s, op);
@@ -22945,7 +22940,7 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
             if ((s->token.val == '[' || s->token.val == '{')
             &&  js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
                 emit_op(s, OP_undefined);
-                if (js_parse_destructing_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS))
+                if (js_parse_destructing_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 return js_parse_error(s, "variable name expected");
@@ -23027,13 +23022,14 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
     JSContext *ctx = s->ctx;
     JSFunctionDef *fd = s->cur_func;
     JSAtom var_name;
-    BOOL has_initializer, is_for_of;
+    BOOL has_initializer, is_for_of, has_destructuring;
     int tok, tok1, opcode, scope, block_scope_level;
     int label_next, label_expr, label_cont, label_body, label_break;
     int pos_next, pos_expr;
     BlockEnv break_entry;
 
     has_initializer = FALSE;
+    has_destructuring = FALSE;
     is_for_of = FALSE;
     block_scope_level = fd->scope_level;
     label_cont = new_label(s);
@@ -23073,8 +23069,9 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
 
         if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
             if (s->token.val == '[' || s->token.val == '{') {
-                if (js_parse_destructing_element(s, tok, 0, TRUE, -1))
+                if (js_parse_destructing_element(s, tok, 0, TRUE, -1, FALSE))
                     return -1;
+                has_destructuring = TRUE;
             } else {
                 return js_parse_error(s, "variable name expected");
             }
@@ -23101,7 +23098,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
         int skip_bits;
         if ((s->token.val == '[' || s->token.val == '{')
         &&  ((tok1 = js_parse_skip_parens_token(s, &skip_bits, FALSE)) == TOK_IN || tok1 == TOK_OF)) {
-            if (js_parse_destructing_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS))
+            if (js_parse_destructing_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                 return -1;
         } else {
             int lvalue_label;
@@ -23173,7 +23170,8 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
         if (is_async)
             return js_parse_error(s, "'for await' loop should be used with 'of'");
         if (has_initializer &&
-            (tok != TOK_VAR || (fd->js_mode & JS_MODE_STRICT))) {
+            (tok != TOK_VAR || (fd->js_mode & JS_MODE_STRICT) ||
+             has_destructuring)) {
         initializer_error:
             return js_parse_error(s, "a declaration in the head of a for-%s loop can't have an initializer",
                                   is_for_of ? "of" : "in");
@@ -23798,7 +23796,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                     if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
                         if (s->token.val == '[' || s->token.val == '{') {
                             /* XXX: TOK_LET is not completely correct */
-                            if (js_parse_destructing_element(s, TOK_LET, 0, TRUE, -1))
+                            if (js_parse_destructing_element(s, TOK_LET, 0, TRUE, -1, TRUE))
                                 goto fail;
                         } else {
                             js_parse_error(s, "identifier expected");
@@ -28070,18 +28068,28 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                 }
             }
             goto no_change;
+#endif
         case OP_push_atom_value:
             if (OPTIMIZE) {
                 JSAtom atom = get_u32(bc_buf + pos + 1);
+                /* remove push/drop pairs generated by the parser */
+                if (code_match(&cc, pos_next, OP_drop, -1)) {
+                    JS_FreeAtom(ctx, atom);
+                    if (cc.line_num >= 0) line_num = cc.line_num;
+                    pos_next = cc.pos;
+                    break;
+                }
+#if SHORT_OPCODES
                 if (atom == JS_ATOM_empty_string) {
                     JS_FreeAtom(ctx, atom);
                     add_pc2line_info(s, bc_out.size, line_num);
                     dbuf_putc(&bc_out, OP_push_empty_string);
                     break;
                 }
+#endif
             }
             goto no_change;
-#endif
+
         case OP_to_propkey:
         case OP_to_propkey2:
             if (OPTIMIZE) {
@@ -29074,7 +29082,8 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
     if ((fd->js_mode & JS_MODE_STRICT)
     ||  !fd->has_simple_parameter_list
     ||  (fd->func_type == JS_PARSE_FUNC_METHOD && fd->func_kind == JS_FUNC_ASYNC)
-    ||  fd->func_type == JS_PARSE_FUNC_ARROW) {
+    ||  fd->func_type == JS_PARSE_FUNC_ARROW
+    ||  fd->func_type == JS_PARSE_FUNC_METHOD) {
         for (idx = 0; idx < fd->arg_count; idx++) {
             name = fd->args[idx].var_name;
             if (name != JS_ATOM_NULL) {
@@ -29296,7 +29305,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     emit_op(s, OP_get_arg);
                     emit_u16(s, idx);
                 }
-                if (js_parse_destructing_element(s, TOK_VAR, 1, TRUE, -1))
+                if (js_parse_destructing_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
                     goto fail;
                 /* Close var object: necessary if direct eval call
                    occurred in the assignment expression or if any
@@ -29553,11 +29562,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             }
         } else {
             if (!s->cur_func->is_global_var) {
-                /* define_var should not fail since there is no scope chain
-                   XXX: maybe pass a different token to ensure no failure?
-                 */
                 int var_idx = define_var(s, s->cur_func, func_name, TOK_VAR);
 
+                if (var_idx < 0)
+                    goto fail;
                 /* the variable will be assigned at the top of the function */
                 if (!add_hoisted_def(ctx, s->cur_func, idx, JS_ATOM_NULL, var_idx, FALSE))
                     goto fail;
@@ -34374,11 +34382,13 @@ static JSValue js_array_slice(JSContext *ctx, JSValueConst this_val,
     k = start;
     final = start + count;
     n = 0;
+    /* The fast array test on arr ensures that
+       JS_CreateDataPropertyUint32() won't modify obj in case arr is
+       an exotic object */
     /* Special case fast arrays */
-    if (js_get_fast_array(ctx, obj, &arrp, &count32)) {
+    if (js_get_fast_array(ctx, obj, &arrp, &count32) &&
+        js_is_fast_array(ctx, arr)) {
         /* XXX: should share code with fast array constructor */
-        /* XXX: this may crash if the new array has a custom property
-           handler that modifies the original array */
         for (; k < final && k < count32; k++, n++) {
             if (JS_CreateDataPropertyUint32(ctx, arr, n, JS_DupValue(ctx, arrp[k]), JS_PROP_THROW) < 0)
                 goto exception;
@@ -34712,7 +34722,7 @@ static JSValue js_array_sort(JSContext *ctx, JSValueConst this_val,
     return obj;
 
 exception:
-    for (n = 0; n < pos; n++) {
+    for (; n < pos; n++) {
         JS_FreeValue(ctx, array[n].val);
         if (array[n].str)
             JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, array[n].str));
@@ -35813,26 +35823,6 @@ static JSValue js_string_charAt(JSContext *ctx, JSValueConst this_val,
     return ret;
 }
 
-static int string_getc(JSString *p, int *pidx)
-{
-    int idx, c, c1;
-    idx = *pidx;
-    if (p->is_wide_char) {
-        c = p->u.str16[idx++];
-        if (c >= 0xd800 && c < 0xdc00 && idx < p->len) {
-            c1 = p->u.str16[idx];
-            if (c1 >= 0xdc00 && c1 < 0xe000) {
-                c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
-                idx++;
-            }
-        }
-    } else {
-        c = p->u.str8[idx++];
-    }
-    *pidx = idx;
-    return c;
-}
-
 static JSValue js_string_codePointAt(JSContext *ctx, JSValueConst this_val,
                                      int argc, JSValueConst *argv)
 {
@@ -39180,7 +39170,10 @@ static JSValue json_parse_value(JSParseState *s)
                 {
                     int v;
                     v = JS_VALUE_GET_INT(val);
-                    val = JS_NewInt64(ctx, -(int64_t)v);
+                    if (v == 0 && !is_bignum_mode(s->ctx))
+                        val = __JS_NewFloat64(ctx, -0.0);
+                    else
+                        val = JS_NewInt64(ctx, -(int64_t)v);
                 }
                 break;
             }
@@ -41202,15 +41195,13 @@ static void delete_weak_ref(JSRuntime *rt, JSMapRecord *mr)
     *pmr = mr1->next_weak_ref;
 }
 
-static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr,
-                              BOOL from_reset_weak)
+static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
 {
     if (mr->empty)
         return;
     list_del(&mr->hash_link);
     if (s->is_weak) {
-        if (!from_reset_weak)
-            delete_weak_ref(rt, mr);
+        delete_weak_ref(rt, mr);
     } else {
         JS_FreeValueRT(rt, mr->key);
     }
@@ -41240,12 +41231,26 @@ static void map_decref_record(JSRuntime *rt, JSMapRecord *mr)
 static void reset_weak_ref(JSRuntime *rt, JSObject *p)
 {
     JSMapRecord *mr, *mr_next;
-    mr = p->first_weak_ref;
-    while (mr != NULL) {
+    JSMapState *s;
+    
+    /* first pass to remove the records from the WeakMap/WeakSet
+       lists */
+    for(mr = p->first_weak_ref; mr != NULL; mr = mr->next_weak_ref) {
+        s = mr->map;
+        assert(s->is_weak);
+        assert(!mr->empty); /* no iterator on WeakMap/WeakSet */
+        list_del(&mr->hash_link);
+        list_del(&mr->link);
+    }
+    
+    /* second pass to free the values to avoid modifying the weak
+       reference list while traversing it. */
+    for(mr = p->first_weak_ref; mr != NULL; mr = mr_next) {
         mr_next = mr->next_weak_ref;
-        map_delete_record(rt, mr->map, mr, TRUE);
-        mr = mr_next;
+        JS_FreeValueRT(rt, mr->value);
+        js_free_rt(rt, mr);
     }
+
     p->first_weak_ref = NULL; /* fail safe */
 }
 
@@ -41255,13 +41260,11 @@ static JSValue js_map_set(JSContext *ctx, JSValueConst this_val,
     JSMapState *s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
     JSMapRecord *mr;
     JSValueConst key, value;
-    BOOL is_weak;
 
     if (!s)
         return JS_EXCEPTION;
-    is_weak = magic & MAGIC_WEAK;
     key = map_normalize_key(ctx, argv[0]);
-    if (is_weak && !JS_IsObject(key))
+    if (s->is_weak && !JS_IsObject(key))
         return JS_ThrowTypeErrorNotAnObject(ctx);
     if (magic & MAGIC_SET)
         value = JS_UNDEFINED;
@@ -41323,7 +41326,7 @@ static JSValue js_map_delete(JSContext *ctx, JSValueConst this_val,
     mr = map_find_record(ctx, s, key);
     if (!mr)
         return JS_FALSE;
-    map_delete_record(ctx->rt, s, mr, FALSE);
+    map_delete_record(ctx->rt, s, mr);
     return JS_TRUE;
 }
 
@@ -41338,7 +41341,7 @@ static JSValue js_map_clear(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     list_for_each_safe(el, el1, &s->records) {
         mr = list_entry(el, JSMapRecord, link);
-        map_delete_record(ctx->rt, s, mr, FALSE);
+        map_delete_record(ctx->rt, s, mr);
     }
     return JS_UNDEFINED;
 }
@@ -42240,6 +42243,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
     JSValue result_promise, resolving_funcs[2], iter, item, next_promise, ret;
     JSValue next_method = JS_UNDEFINED, values = JS_UNDEFINED;
     JSValue resolve_element_env = JS_UNDEFINED, resolve_element;
+    JSValue promise_resolve = JS_UNDEFINED;
     JSValueConst then_args[2], resolve_element_data[5];
     BOOL done;
     int index, is_zero;
@@ -42276,6 +42280,11 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                                          JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
             goto fail_reject;
         
+        promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+        if (JS_IsException(promise_resolve) ||
+            check_function(ctx, promise_resolve))
+            goto fail_reject1;
+        
         index = 0;
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
@@ -42285,8 +42294,8 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             if (done)
                 break;
-            next_promise = JS_Invoke(ctx, this_val, JS_ATOM_resolve, 1,
-                                     (JSValueConst *)&item);
+            next_promise = JS_Call(ctx, promise_resolve, 
+                                   this_val, 1, (JSValueConst *)&item);
             JS_FreeValue(ctx, item);
             if (JS_IsException(next_promise)) {
             fail_reject1:
@@ -42332,6 +42341,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
         }
     }
  done:
+    JS_FreeValue(ctx, promise_resolve);
     JS_FreeValue(ctx, resolve_element_env);
     JS_FreeValue(ctx, values);
     JS_FreeValue(ctx, next_method);
@@ -42350,6 +42360,7 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
 {
     JSValue result_promise, resolving_funcs[2], iter, item, next_promise, ret;
     JSValue next_method = JS_UNDEFINED;
+    JSValue promise_resolve = JS_UNDEFINED;
     BOOL done;
 
     if (!JS_IsObject(this_val))
@@ -42373,6 +42384,11 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(next_method))
             goto fail_reject;
 
+        promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+        if (JS_IsException(promise_resolve) ||
+            check_function(ctx, promise_resolve))
+            goto fail_reject1;
+
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
                access, but not on 'value' access */
@@ -42381,8 +42397,8 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             if (done)
                 break;
-            next_promise = JS_Invoke(ctx, this_val, JS_ATOM_resolve, 1,
-                                     (JSValueConst *)&item);
+            next_promise = JS_Call(ctx, promise_resolve,
+                                   this_val, 1, (JSValueConst *)&item);
             JS_FreeValue(ctx, item);
             if (JS_IsException(next_promise)) {
             fail_reject1:
@@ -42396,6 +42412,7 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
         }
     }
  done:
+    JS_FreeValue(ctx, promise_resolve);
     JS_FreeValue(ctx, next_method);
     JS_FreeValue(ctx, iter);
     JS_FreeValue(ctx, resolving_funcs[0]);
@@ -43480,15 +43497,15 @@ static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
         switch(fmt) {
         case 0:
             pos += snprintf(buf + pos, sizeof(buf) - pos,
-                            "%.3s, %02d %.3s %04d ",
+                            "%.3s, %02d %.3s %0*d ",
                             day_names + wd * 3, d,
-                            month_names + mon * 3, y);
+                            month_names + mon * 3, 4 + (y < 0), y);
             break;
         case 1:
             pos += snprintf(buf + pos, sizeof(buf) - pos,
-                            "%.3s %.3s %02d %04d",
+                            "%.3s %.3s %02d %0*d",
                             day_names + wd * 3,
-                            month_names + mon * 3, d, y);
+                            month_names + mon * 3, d, 4 + (y < 0), y);
             if (part == 3) {
                 buf[pos++] = ' ';
             }
@@ -43506,7 +43523,7 @@ static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
             break;
         case 3:
             pos += snprintf(buf + pos, sizeof(buf) - pos,
-                            "%02d/%02d/%04d", mon + 1, d, y);
+                            "%02d/%02d/%0*d", mon + 1, d, 4 + (y < 0), y);
             if (part == 3) {
                 buf[pos++] = ',';
                 buf[pos++] = ' ';
@@ -44889,7 +44906,12 @@ static void JS_AddIntrinsicBasicObjects(JSContext *ctx)
     add_shape_property(ctx, &ctx->array_shape, NULL,
                        JS_ATOM_length, JS_PROP_WRITABLE | JS_PROP_LENGTH);
 
-    assert(ctx->rt->atom_count == JS_ATOM_END);
+    /* XXX: could test it on first context creation to ensure that no
+       new atoms are created in JS_AddIntrinsicBasicObjects(). It is
+       necessary to avoid useless renumbering of atoms after
+       JS_EvalBinary() if it is done just after
+       JS_AddIntrinsicBasicObjects(). */
+    //    assert(ctx->rt->atom_count == JS_ATOM_END);
 }
 
 void JS_AddIntrinsicBaseObjects(JSContext *ctx)
@@ -44965,7 +44987,7 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     {
         /* initialize Array.prototype[Symbol.unscopables] */
         char const unscopables[] = "copyWithin" "\0" "entries" "\0" "fill" "\0" "find" "\0"
-            "findIndex" "\0" "includes" "\0" "keys" "\0" "values" "\0";
+            "findIndex" "\0" "flat" "\0" "flatMap" "\0" "includes" "\0" "keys" "\0" "values" "\0";
         const char *p = unscopables;
         obj1 = JS_NewObjectProto(ctx, JS_NULL);
         for(p = unscopables; *p; p += strlen(p) + 1) {
@@ -47683,9 +47705,9 @@ static JSValue js_atomics_wait(JSContext *ctx,
     }
 }
 
-static JSValue js_atomics_wake(JSContext *ctx,
-                               JSValueConst this_obj,
-                               int argc, JSValueConst *argv)
+static JSValue js_atomics_notify(JSContext *ctx,
+                                 JSValueConst this_obj,
+                                 int argc, JSValueConst *argv)
 {
     struct list_head *el, *el1, waiter_list;
     int32_t count, n, *ptr;
@@ -47738,7 +47760,7 @@ static const JSCFunctionListEntry js_atomics_funcs[] = {
     JS_CFUNC_DEF("store", 3, js_atomics_store ),
     JS_CFUNC_DEF("isLockFree", 1, js_atomics_isLockFree ),
     JS_CFUNC_DEF("wait", 4, js_atomics_wait ),
-    JS_CFUNC_DEF("wake", 3, js_atomics_wake ),
+    JS_CFUNC_DEF("notify", 3, js_atomics_notify ),
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "Atomics", JS_PROP_CONFIGURABLE ),
 };
 
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index ca3636741d..4cb62b5f8a 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -586,6 +586,15 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
     return (JSValue)v;
 }
 
+static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
+{
+    if (JS_VALUE_HAS_REF_COUNT(v)) {
+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+        p->ref_count++;
+    }
+    return (JSValue)v;
+}
+
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
 int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val);
 static int inline JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)

From 4048b421f08f8ee46ee4052df9fa1a5e635d8d81 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Jul 2019 16:22:29 +0000
Subject: [PATCH 004/185] added c++ patch

---
 quickjs/cplusplus.patch | 54 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 quickjs/cplusplus.patch

diff --git a/quickjs/cplusplus.patch b/quickjs/cplusplus.patch
new file mode 100644
index 0000000000..159dd92f88
--- /dev/null
+++ b/quickjs/cplusplus.patch
@@ -0,0 +1,54 @@
+diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
+index 60cd0e7..4cb62b5 100644
+--- a/quickjs/quickjs.h
++++ b/quickjs/quickjs.h
+@@ -201,8 +201,13 @@ typedef struct JSValue {
+ #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
+ #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
+ 
++#ifdef __cplusplus
++#define JS_MKVAL(tag, val) JSValue{ JSValueUnion{.int32 = val}, tag }
++#define JS_MKPTR(tag, p) JSValue{ JSValueUnion{.ptr = p}, tag }
++#else
+ #define JS_MKVAL(tag, val) (JSValue){ .u.int32 = val, tag }
+ #define JS_MKPTR(tag, p) (JSValue){ .u.ptr = p, tag }
++#endif
+ 
+ #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
+ 
+@@ -555,7 +560,7 @@ void __JS_FreeValue(JSContext *ctx, JSValue v);
+ static inline void JS_FreeValue(JSContext *ctx, JSValue v)
+ {
+     if (JS_VALUE_HAS_REF_COUNT(v)) {
+-        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
++        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         if (--p->ref_count <= 0) {
+             __JS_FreeValue(ctx, v);
+         }
+@@ -565,7 +570,7 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v);
+ static inline void JS_FreeValueRT(JSRuntime *rt, JSValue v)
+ {
+     if (JS_VALUE_HAS_REF_COUNT(v)) {
+-        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
++        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         if (--p->ref_count <= 0) {
+             __JS_FreeValueRT(rt, v);
+         }
+@@ -575,7 +580,7 @@ static inline void JS_FreeValueRT(JSRuntime *rt, JSValue v)
+ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
+ {
+     if (JS_VALUE_HAS_REF_COUNT(v)) {
+-        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
++        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         p->ref_count++;
+     }
+     return (JSValue)v;
+@@ -584,7 +589,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
+ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
+ {
+     if (JS_VALUE_HAS_REF_COUNT(v)) {
+-        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
++        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         p->ref_count++;
+     }
+     return (JSValue)v;

From 497c5be1dae048c007775331cd6e9a0a18bc2037 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Jul 2019 16:30:51 +0000
Subject: [PATCH 005/185] basic readme file

---
 readme.txt | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 readme.txt

diff --git a/readme.txt b/readme.txt
new file mode 100644
index 0000000000..2b3118454e
--- /dev/null
+++ b/readme.txt
@@ -0,0 +1,19 @@
+QuickJS wrapper for C++.
+
+
+* Status
++ conversions between int32_t, std::string, bool, double and JSValue
++ basic support for classes
++ basic support for modules
++ automatic function wrapping and unwrapping
+- exception interop
+- tests for memory leaks
+
+* Installation
+QuickJSPP is header-only - C++17 or later is required. QuickJS needs to be compiled. Sample CMake files are provided.
+
+* Notes
+A small patch for C++ support is applied to quickjs.h.
+
+* License
+QuickJSPP is licensed under CC0 (https://creativecommons.org/publicdomain/zero/1.0/). 

From 53f6b4e0baac0c3232a152fa7342b760043b7d17 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Jul 2019 13:42:51 +0000
Subject: [PATCH 006/185] added allocator, fixed memory leaks

---
 quickjspp.hpp | 143 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 102 insertions(+), 41 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index fc4c6bd064..cc1c961380 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -15,23 +15,57 @@ extern "C" {
 
 namespace qjs {
 
+
+    template <typename T>
+    struct allocator
+    {
+        JSRuntime * rt;
+        using value_type = T;
+        using propagate_on_container_move_assignment = std::true_type;
+        using propagate_on_container_copy_assignment = std::true_type;
+
+        constexpr allocator(JSRuntime * rt) noexcept : rt{rt}
+        {}
+
+        allocator(JSContext * ctx) noexcept : rt{JS_GetRuntime(ctx)}
+        {}
+
+        template <class U>
+        constexpr allocator(const allocator<U>& other) noexcept : rt{other.rt}
+        {}
+
+        [[nodiscard]] T * allocate(std::size_t n)
+        {
+            if(auto p = static_cast<T *>(js_malloc_rt(rt, n * sizeof(T)))) return p;
+            throw std::bad_alloc();
+        }
+
+        void deallocate(T * p, std::size_t) noexcept
+        { js_free_rt(rt, p); }
+
+        template <class U>
+        bool operator == (const allocator<U>& other) const { return rt == other.rt; }
+        template <class U>
+        bool operator != (const allocator<U>& other) const { return rt != other.rt; }
+    };
+
     namespace detail {
         class exception {};
 
         template <typename R>
         struct js_traits
         {
-            //static R unwrap(JSContext * ctx, JSValue v);
-            //static JSValue wrap(JSContext * ctx, R value)
+            //static R unwrap(JSContext * ctx, JSValueConst v);
+            //static JSValue wrap(JSContext * ctx, R value);
         };
 
         // identity
         template <>
         struct js_traits<JSValue>
         {
-            static JSValue unwrap(JSContext * ctx, JSValue v) noexcept
+            static JSValue unwrap(JSContext * ctx, JSValueConst v) noexcept
             {
-                return v;
+                return JS_DupValue(ctx, v);
             }
 
             static JSValue wrap(JSContext * ctx, JSValue v) noexcept
@@ -103,7 +137,7 @@ namespace qjs {
             using Base = std::string_view;
             JSContext * ctx = nullptr;
 
-            friend struct js_traits<js_string>;
+            friend struct js_traits<std::string_view>;
             js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx) {}
         public:
 
@@ -120,7 +154,7 @@ namespace qjs {
         };
 
         template <>
-        struct js_traits<js_string>
+        struct js_traits<std::string_view>
         {
             static js_string unwrap(JSContext * ctx, JSValueConst v)
             {
@@ -131,7 +165,7 @@ namespace qjs {
                 return js_string{ctx, ptr, (std::size_t)plen};
             }
 
-            static JSValue wrap(JSContext * ctx, js_string str) noexcept
+            static JSValue wrap(JSContext * ctx, std::string_view str) noexcept
             {
                 return JS_NewStringLen(ctx, str.data(), (int)str.size());
             }
@@ -142,7 +176,7 @@ namespace qjs {
         {
             static std::string unwrap(JSContext * ctx, JSValueConst v)
             {
-                auto str_view = js_traits<js_string>::unwrap(ctx, v);
+                auto str_view = js_traits<std::string_view>::unwrap(ctx, v);
                 return std::string{str_view.data(), str_view.size()};
             }
 
@@ -152,6 +186,30 @@ namespace qjs {
             }
         };
 
+        // unwrap and free value
+        template <typename T>
+        T unwrap_free(JSContext * ctx, JSValue val)
+        {
+            if constexpr(std::is_same_v<T, void>)
+            {
+                JS_FreeValue(ctx, val);
+                return js_traits<T>::unwrap(ctx, val);
+            }
+            else
+            {
+                try
+                {
+                    T result = js_traits<std::decay_t<T>>::unwrap(ctx, val);
+                    JS_FreeValue(ctx, val);
+                    return result;
+                }
+                catch(...)
+                {
+                    JS_FreeValue(ctx, val);
+                    throw;
+                }
+            }
+        }
 
         template <class Tuple, std::size_t... I>
         Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
@@ -291,11 +349,12 @@ namespace qjs {
                         // destructor
                         [](JSRuntime * rt, JSValue obj) noexcept {
                             auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
-                            if(!pptr)
-                            {
-                                assert(false && "bad destructor");
-                            }
-                            delete pptr;
+                            assert(pptr);
+                            //delete pptr;
+                            auto alloc = allocator<std::shared_ptr<T>>{rt};
+                            using atraits = std::allocator_traits<decltype(alloc)>;
+                            atraits::destroy(alloc, pptr);
+                            atraits::deallocate(alloc, pptr, 1);
                         }
                 };
                 int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
@@ -313,7 +372,12 @@ namespace qjs {
                 {
                     return jsobj;
                 }
-                auto pptr = new std::shared_ptr<T>(std::move(ptr));
+                //auto pptr = new std::shared_ptr<T>(std::move(ptr));
+                auto alloc = allocator<std::shared_ptr<T>>{ctx};
+                using atraits = std::allocator_traits<decltype(alloc)>;
+                auto pptr = atraits::allocate(alloc, 1);
+                atraits::construct(alloc, pptr, std::move(ptr));
+
                 JS_SetOpaque(jsobj, pptr);
                 return jsobj;
             }
@@ -336,10 +400,12 @@ namespace qjs {
             alignas(std::max_align_t) char functor[];
 
             template <typename Functor>
-            static function * create(Functor&& f)
+            static function * create(JSRuntime * rt, Functor&& f)
             {
-                char * data = new char[sizeof(function) + sizeof(Functor)];
-                auto fptr = reinterpret_cast<function *>(data);
+                auto fptr = reinterpret_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
+                if(!fptr)
+                    throw std::bad_alloc{};
+                new (fptr) function;
                 auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
                 new(functorptr) Functor(std::forward<Functor>(f));
                 fptr->destroyer = nullptr;
@@ -353,6 +419,8 @@ namespace qjs {
                 return fptr;
             }
         };
+        static_assert(std::is_trivially_destructible_v<function>);
+
 
         template <>
         struct js_traits<function>
@@ -364,15 +432,11 @@ namespace qjs {
                         name,
                         // destructor
                         [](JSRuntime * rt, JSValue obj) noexcept {
-                            auto pptr = reinterpret_cast<function *>(JS_GetOpaque(obj, QJSClassId));
-                            if(!pptr)
-                            {
-                                assert(false && "bad destructor");
-                            }
-                            if(pptr->destroyer)
-                                pptr->destroyer(pptr);
-                            auto cptr = reinterpret_cast<char *>(pptr);
-                            delete [] cptr;
+                            auto fptr = reinterpret_cast<function *>(JS_GetOpaque(obj, QJSClassId));
+                            assert(fptr);
+                            if(fptr->destroyer)
+                                fptr->destroyer(fptr);
+                            js_free_rt(rt, fptr);
                         },
                         nullptr, // mark
                         // call
@@ -441,7 +505,7 @@ namespace qjs {
             template <typename Value>
             operator Value() const
             {
-                return js_traits<Value>::unwrap(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
+                return unwrap_free<Value>(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
             }
 
             template <typename Value>
@@ -564,9 +628,10 @@ namespace qjs {
             JSContext * ctx;
             const char * name;
 
-            std::vector<std::pair<const char *, JSValue>> exports;
+            using nvp = std::pair<const char *, JSValue>;
+            std::vector<nvp, allocator<nvp>> exports;
         public:
-            Module(JSContext * ctx, const char * name) : ctx(ctx), name(name)
+            Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
             {
                 m = JS_NewCModule(ctx, name, [](JSContext * ctx, JSModuleDef * m) noexcept {
                     auto context = reinterpret_cast<Context *>(JS_GetContextOpaque(ctx));
@@ -608,18 +673,18 @@ namespace qjs {
             //Module(const Module&) = delete;
         };
 
-        std::vector<Module> modules;
+        std::vector<Module, allocator<Module>> modules;
     private:
         void init()
         {
             JS_SetContextOpaque(ctx, this);
-            detail::js_traits<detail::function>::register_class(ctx, "");
+            detail::js_traits<detail::function>::register_class(ctx, "C++ function");
         }
     public:
         Context(Runtime& rt) : Context(rt.rt)
         {}
 
-        Context(JSRuntime * rt)
+        Context(JSRuntime * rt) : modules{rt}
         {
             ctx = JS_NewContext(rt);
             if(!ctx)
@@ -627,7 +692,7 @@ namespace qjs {
             init();
         }
 
-        Context(JSContext * ctx) : ctx{ctx}
+        Context(JSContext * ctx) : ctx{ctx}, modules{ctx}
         {
             init();
         }
@@ -661,7 +726,7 @@ namespace qjs {
             detail::js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
         }
 
-        Value eval(std::string_view buffer, const char * filename = "eval", unsigned eval_flags = 0)
+        Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
         {
             JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
             //if(JS_IsException(v))
@@ -693,13 +758,9 @@ namespace qjs {
                     const int argc = sizeof...(Args);
                     JSValue argv[argc];
                     wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
-                    JSValue result;
-                    //if(JS_IsObject(argv[0])) // constexpr?
-                    //   result = JS_Call(ctx, fun_obj, argv[0], argc - 1, const_cast<JSValueConst*>(argv + 1));
-                    //else
-                    result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
+                    JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
                     for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
-                    return js_traits<R>::unwrap(jsfun_obj.ctx, result);
+                    return unwrap_free<R>(jsfun_obj.ctx, result);
                 };
             }
 
@@ -709,7 +770,7 @@ namespace qjs {
                 auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
                 if(JS_IsException(obj))
                     return JS_EXCEPTION;
-                auto fptr = function::create(std::forward<Functor>(functor));
+                auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
                 fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
                     assert(self);
                     auto f = reinterpret_cast<Functor *>(&self->functor);

From 4ba7a7ad577f2290c96d108689a9b4f6e879c977 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 28 Jul 2019 15:55:28 +0000
Subject: [PATCH 007/185] class member object support

---
 main.cpp      |  22 ++++++---
 quickjspp.hpp | 130 ++++++++++++++++++++++++++++++++++++--------------
 2 files changed, 109 insertions(+), 43 deletions(-)

diff --git a/main.cpp b/main.cpp
index 1924b1316e..f7e402fe06 100644
--- a/main.cpp
+++ b/main.cpp
@@ -17,12 +17,12 @@ int32_t f(int32_t x)
 
 class test
 {
+public:
     bool b;
     int32_t i;
     double d;
     std::shared_ptr<test> spt;
     std::string s;
-public:
 
     test(int32_t i, TYPES) : i(i)
     { printf("ctor!\n"); }
@@ -67,7 +67,7 @@ int main(int argc, char ** argv)
         obj["vb"] = true;
         obj["vd"] = 56.0;
         obj["vs"] = std::string{"test string"};
-        obj.add<int, int>("lambda", [](int x) -> int { return x * x; });
+        obj.add("lambda", [](int x) -> int { return x * x; });
 
         obj.add<&test::fi>("fi");
         obj.add<&test::fb>("fb");
@@ -77,6 +77,12 @@ int main(int argc, char ** argv)
         obj.add<&test::f>("f");
         obj.add<&test::fstatic>("fstatic");
 
+        obj.add<&test::i>("i");
+        obj.add<&test::b>("b");
+        obj.add<&test::d>("d");
+        obj.add<&test::s>("s");
+        obj.add<&test::spt>("spt");
+
         context.registerClass<test>("test_class", std::move(obj));
     }
 
@@ -110,10 +116,14 @@ int main(int argc, char ** argv)
     {
         auto xxx = context.eval("var t = new test.TestSimple(12);"
                                 "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"
-                                "q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
-                                "q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
-                                "q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs);"
-                                "q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\");"
+                                "q.b = true;"
+                                "q.d = 456.789;"
+                                "q.s = \"STRING\";"
+                                "q.spt = t;"
+                                "console.log(q.b === q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
+                                "console.log(q.d === q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
+                                "console.log(q.s === q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs));"
+                                "console.log(q.spt === q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));" // false
                                 "q.fi(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
         assert(xxx.cast<int>() == 18);
         auto yyy = context.eval("q.fi.bind(t)(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
diff --git a/quickjspp.hpp b/quickjspp.hpp
index cc1c961380..6b25e3f697 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -234,7 +234,9 @@ namespace qjs {
                     return JS_UNDEFINED;
                 } else
                 {
-                    return js_traits<std::decay_t<R>>::wrap(ctx, std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv)));
+                    return js_traits<std::decay_t<R>>::wrap(ctx,
+                                                            std::apply(std::forward<Callable>(f),
+                                                                       unwrap_args<Args...>(ctx, argv)));
                 }
             }
             catch(exception)
@@ -243,6 +245,29 @@ namespace qjs {
             }
         }
 
+        template <typename R, typename FirstArg, typename... Args, typename Callable>
+        JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
+        {
+            try
+            {
+                if constexpr(std::is_same_v<R, void>)
+                {
+                    std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
+                            unwrap_args<Args...>(ctx, argv)));
+                    return JS_UNDEFINED;
+                } else
+                {
+                    return js_traits<std::decay_t<R>>::wrap(ctx,
+                                                            std::apply(std::forward<Callable>(f),
+                                                                       std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
+                                                                                      unwrap_args<Args...>(ctx, argv))));
+                }
+            }
+            catch(exception)
+            {
+                return JS_EXCEPTION;
+            }
+        }
 
         template <class Tuple, std::size_t... I>
         void wrap_args_impl(JSContext * ctx, JSValue * argv, Tuple tuple, std::index_sequence<I...>)
@@ -255,22 +280,25 @@ namespace qjs {
         {
             wrap_args_impl(ctx, argv, std::make_tuple(std::forward<Args>(args)...), std::make_index_sequence<sizeof...(Args)>());
         }
-        // free function
 
-        template <auto F>
+        template <auto F, bool PassThis = false /* pass this as the first argument */>
         struct fwrapper
         {
             const char * name = nullptr;
         };
 
-        template <typename R, typename... Args, R (* F)(Args...)>
-        struct js_traits<fwrapper<F>>
+        // free function
+        template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
+        struct js_traits<fwrapper<F, PassThis>>
         {
-            static JSValue wrap(JSContext * ctx, fwrapper<F> fw)
+            static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
             {
                 return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                                JSValueConst * argv) noexcept -> JSValue {
-                    return wrap_call<R, Args...>(ctx, F, argv);
+                    if constexpr(PassThis)
+                        return wrap_this_call<R, Args...>(ctx, F, this_value, argv);
+                    else
+                        return wrap_call<R, Args...>(ctx, F, argv);
                 }, fw.name, sizeof...(Args));
 
             }
@@ -281,31 +309,11 @@ namespace qjs {
         template <typename R, class T, typename... Args, R (T::*F)(Args...)>
         struct js_traits<fwrapper<F>>
         {
-            static JSValue wrap(JSContext * ctx, fwrapper<F> fw)
+            static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
             {
                 return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                                JSValueConst * argv) noexcept -> JSValue {
-                    //if(argc < sizeof...(Args))
-                    //return JS_EXCEPTION;
-                    try
-                    {
-                        const auto& this_sp = js_traits<std::shared_ptr<T>>::unwrap(ctx, this_value);
-
-                        if constexpr (std::is_same_v<R, void>)
-                        {
-                            std::apply(F, std::tuple_cat(std::make_tuple(this_sp.get()),
-                                                         detail::unwrap_args<Args...>(ctx, argv)));
-                            return JS_UNDEFINED;
-                        } else
-                            return js_traits<std::decay_t<R>>::wrap(ctx,
-                                                      std::apply(F, std::tuple_cat(std::make_tuple(this_sp.get()),
-                                                                                   detail::unwrap_args<Args...>(ctx,
-                                                                                                                argv)))
-                            );
-                    } catch(detail::exception)
-                    {
-                        return JS_EXCEPTION;
-                    }
+                    return wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
                 }, fw.name, sizeof...(Args));
 
             }
@@ -324,7 +332,7 @@ namespace qjs {
         template <class T, typename... Args>
         struct js_traits<ctor_wrapper<T, Args...>>
         {
-            static JSValue wrap(JSContext * ctx, ctor_wrapper<T, Args...> cw)
+            static JSValue wrap(JSContext * ctx, ctor_wrapper<T, Args...> cw) noexcept
             {
                 return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                                 JSValueConst * argv) noexcept -> JSValue {
@@ -517,6 +525,28 @@ namespace qjs {
             }
         };
 
+
+
+        // class member variable getter/setter
+        template <auto M>
+        struct get_set
+        {};
+
+        template <class T, typename R, R T::*M>
+        struct get_set<M>
+        {
+            static const R& get(const std::shared_ptr<T>& ptr)
+            {
+                return *ptr.*M;
+            }
+
+            static R& set(const std::shared_ptr<T>& ptr, R value)
+            {
+                return *ptr.*M = std::move(value);
+            }
+
+        };
+
     }
 
     class Value
@@ -576,21 +606,44 @@ namespace qjs {
         }
 
 
+        // add("f", []() {...});
+        template <typename Function>
+        Value& add(const char * name, Function&& f)
+        {
+            (*this)[name] = detail::js_traits<decltype(std::function{std::forward<Function>(f)})>::wrap(ctx, std::forward<Function>(f));
+            return *this;
+        }
+
+        // add<&f>("f");
+        // add<&T::f>("f");
         template <auto F>
-        Value& add(const char * name)
+        std::enable_if_t<!std::is_member_object_pointer_v<decltype(F)>, Value&>
+        add(const char * name)
         {
             (*this)[name] = detail::fwrapper<F>{name};
             return *this;
         }
 
-        template <typename R, typename... Args, typename Function>
-        //std::enable_if_t<std::is_invocable_r<R, Function, Args...>::value, Value&>
-                Value& add(const char * name, Function&& f)
-        {
-            (*this)[name] = detail::js_traits<std::function<R (Args...)>>::wrap(ctx, std::forward<Function>(f));
+        // add<&T::member>("member");
+        template <auto M>
+        std::enable_if_t<std::is_member_object_pointer_v<decltype(M)>, Value&>
+        add(const char * name)
+        {
+            auto prop = JS_NewAtom(ctx, name);
+            using fgetter = detail::fwrapper<detail::get_set<M>::get, true>;
+            using fsetter = detail::fwrapper<detail::get_set<M>::set, true>;
+            int ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                    detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                    detail::js_traits<fsetter>::wrap(ctx, fsetter{name}),
+                                    JS_PROP_WRITABLE // ?
+                    );
+            JS_FreeAtom(ctx, prop);
+            if(ret < 0)
+                throw detail::exception{};
             return *this;
         }
 
+
     };
 
 
@@ -620,6 +673,7 @@ namespace qjs {
     public:
         JSContext * ctx;
 
+    private:
         class Module
         {
             friend class Context;
@@ -670,7 +724,9 @@ namespace qjs {
                 return add(name, detail::js_traits<T>::wrap(ctx, std::move(value)));
             }
 
-            //Module(const Module&) = delete;
+            Module(const Module&) = delete;
+            Module(Module&&)  = default;
+            //Module& operator=(Module&&) = default;
         };
 
         std::vector<Module, allocator<Module>> modules;

From 9680868cb7c4c40f0eeee511f35587c5c22a9615 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 30 Jul 2019 15:51:06 +0000
Subject: [PATCH 008/185] update quickjs to 2019-07-28

---
 main.cpp                 |    2 +-
 quickjs/VERSION          |    2 +-
 quickjs/libbf.c          |    5 +-
 quickjs/libregexp.c      |    3 +-
 quickjs/quickjs-atom.h   |    4 +
 quickjs/quickjs-libc.c   |    2 +-
 quickjs/quickjs-opcode.h |    6 +-
 quickjs/quickjs.c        | 1157 ++++++++++++++++++++++++++++++--------
 quickjs/quickjs.h        |    3 +-
 9 files changed, 932 insertions(+), 252 deletions(-)

diff --git a/main.cpp b/main.cpp
index f7e402fe06..8618f5af5d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -142,7 +142,7 @@ int main(int argc, char ** argv)
     }
 
     if(filename)
-    context.evalFile(filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_SHEBANG);
+    context.evalFile(filename, JS_EVAL_TYPE_MODULE);
 
     JSMemoryUsage mem;
     JS_ComputeMemoryUsage(rt, &mem);
diff --git a/quickjs/VERSION b/quickjs/VERSION
index 51e58f773f..6b45bd0759 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-07-21
+2019-07-28
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index e848c38d48..de800365fb 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -2522,11 +2522,12 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
                    radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
             p += 2;
             radix = 2;
-        } else if ((p[1] >= '0' && p[1] <= '7') &&
+        } else if ((p[1] >= '0' && p[1] <= '9') &&
                    radix == 0 && (flags & BF_ATOF_LEGACY_OCTAL)) {
             int i;
             /* the separator is not allowed in legacy octal literals */
-            for (i = 2; (p[i] >= '0' && p[i] <= '7'); i++)
+            sep = 256;
+            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
                 continue;
             if (p[i] == '8' || p[i] == '9')
                 goto no_prefix;
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index 61177efab1..ad1e6bf065 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -2511,7 +2511,8 @@ int main(int argc, char **argv)
         printf("usage: %s regexp input\n", argv[0]);
         exit(1);
     }
-    bc = lre_compile(&len, error_msg, sizeof(error_msg), argv[1], 0, 0, NULL);
+    bc = lre_compile(&len, error_msg, sizeof(error_msg), argv[1],
+                     strlen(argv[1]), 0, NULL);
     if (!bc) {
         fprintf(stderr, "error: %s\n", error_msg);
         exit(1);
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 8ec55ee2fe..b0708aa9be 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -158,6 +158,8 @@ DEF(revoke, "revoke")
 DEF(async, "async")
 DEF(exec, "exec")
 DEF(groups, "groups")
+DEF(status, "status")
+DEF(reason, "reason")
 #ifdef CONFIG_BIGNUM
 DEF(bigint, "bigint")
 DEF(bigfloat, "bigfloat")
@@ -214,6 +216,7 @@ DEF(Map_Iterator, "Map Iterator")
 DEF(Set_Iterator, "Set Iterator")
 DEF(Array_Iterator, "Array Iterator")
 DEF(String_Iterator, "String Iterator")
+DEF(RegExp_String_Iterator, "RegExp String Iterator")
 DEF(Generator, "Generator")
 DEF(Proxy, "Proxy")
 DEF(Promise, "Promise")
@@ -236,6 +239,7 @@ DEF(InternalError, "InternalError")
 DEF(Symbol_toPrimitive, "Symbol.toPrimitive")
 DEF(Symbol_iterator, "Symbol.iterator")
 DEF(Symbol_match, "Symbol.match")
+DEF(Symbol_matchAll, "Symbol.matchAll")
 DEF(Symbol_replace, "Symbol.replace")
 DEF(Symbol_search, "Symbol.search")
 DEF(Symbol_split, "Symbol.split")
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 268ef0472e..df6a36ab1c 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -336,7 +336,7 @@ static JSValue js_loadScript(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     }
     ret = JS_Eval(ctx, (char *)buf, buf_len, filename,
-                  JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_SHEBANG);
+                  JS_EVAL_TYPE_GLOBAL);
     js_free(ctx, buf);
     JS_FreeCString(ctx, filename);
     return ret;
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 44fcc83c7d..d7318682bf 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -75,11 +75,8 @@ DEF(     push_false, 1, 0, 1, none)
 DEF(      push_true, 1, 0, 1, none)
 DEF(         object, 1, 0, 1, none)
 DEF(     var_object, 1, 0, 1, none)
-DEF(      this_func, 1, 0, 1, none) /* only used at the start of a function */
-DEF(      arguments, 2, 0, 1, none) /* only used at the start of a function */
+DEF( special_object, 2, 0, 1, u8) /* only used at the start of a function */
 DEF(           rest, 3, 0, 1, u16) /* only used at the start of a function */
-DEF(     new_target, 1, 0, 1, none) /* only used at the start of a function */
-DEF(    home_object, 1, 0, 1, none) /* only used at the start of a function */
 
 DEF(           drop, 1, 1, 0, none) /* a -> */
 DEF(            nip, 1, 2, 1, none) /* a b -> b */
@@ -120,6 +117,7 @@ DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern a
                                        bytecode string */
 DEF( get_super_ctor, 1, 1, 1, none)
 DEF(      get_super, 1, 1, 1, none)
+DEF(         import, 1, 1, 1, none) /* dynamic module import */
 
 DEF(      check_var, 5, 0, 1, atom) /* check if a variable exists */
 DEF(  get_var_undef, 5, 0, 1, atom) /* push undefined if the variable does not exist */
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 8ee82f4525..d3e89b52e1 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -157,6 +157,7 @@ enum {
     JS_CLASS_SET_ITERATOR,      /* u.map_iterator_data */
     JS_CLASS_ARRAY_ITERATOR,    /* u.array_iterator_data */
     JS_CLASS_STRING_ITERATOR,   /* u.array_iterator_data */
+    JS_CLASS_REGEXP_STRING_ITERATOR,   /* u.regexp_string_iterator_data */
     JS_CLASS_GENERATOR,         /* u.generator_data */
     JS_CLASS_PROXY,             /* u.proxy_data */
     JS_CLASS_PROMISE,           /* u.promise_data */
@@ -337,6 +338,7 @@ struct JSContext {
     JSValue function_proto;
     JSValue function_ctor;
     JSValue regexp_ctor;
+    JSValue promise_ctor;
     JSValue native_error_proto[JS_NATIVE_ERROR_COUNT];
     JSValue iterator_proto;
     JSValue async_iterator_proto;
@@ -567,7 +569,8 @@ typedef struct JSExportEntry {
         int req_module_idx; /* module for indirect export */
     } u;
     JSExportTypeEnum export_type;
-    JSAtom local_name; /* not used for local export after compilation */
+    JSAtom local_name; /* '*' if export ns from. not used for local
+                          export after compilation */
     JSAtom export_name; /* exported variable name */
 } JSExportEntry;
 
@@ -605,9 +608,14 @@ struct JSModuleDef {
     JSValue module_ns;
     JSValue func_obj; /* only used for JS modules */
     JSModuleInitFunc *init_func; /* only used for C modules */
-    BOOL resolved;
-    BOOL instantiated;
-    BOOL evaluated;
+    BOOL resolved : 8;
+    BOOL instantiated : 8;
+    BOOL evaluated : 8;
+    BOOL eval_mark : 8; /* temporary use during js_evaluate_module() */
+    /* true if evaluation yielded an exception. It is saved in
+       eval_exception */
+    BOOL eval_has_exception : 8; 
+    JSValue eval_exception;
 };
 
 typedef struct JSJobEntry {
@@ -697,6 +705,7 @@ struct JSObject {
         struct JSMapState *map_state;   /* JS_CLASS_MAP..JS_CLASS_WEAKSET */
         struct JSMapIteratorData *map_iterator_data; /* JS_CLASS_MAP_ITERATOR, JS_CLASS_SET_ITERATOR */
         struct JSArrayIteratorData *array_iterator_data; /* JS_CLASS_ARRAY_ITERATOR, JS_CLASS_STRING_ITERATOR */
+        struct JSRegExpStringIteratorData *regexp_string_iterator_data; /* JS_CLASS_REGEXP_STRING_ITERATOR */
         struct JSGeneratorData *generator_data; /* JS_CLASS_GENERATOR */
         struct JSProxyData *proxy_data; /* JS_CLASS_PROXY */
         struct JSPromiseData *promise_data; /* JS_CLASS_PROMISE */
@@ -843,6 +852,9 @@ static void js_map_iterator_mark(JSRuntime *rt, JSValueConst val,
 static void js_array_iterator_finalizer(JSRuntime *rt, JSValue val);
 static void js_array_iterator_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
+static void js_regexp_string_iterator_finalizer(JSRuntime *rt, JSValue val);
+static void js_regexp_string_iterator_mark(JSRuntime *rt, JSValueConst val,
+                                JS_MarkFunc *mark_func);
 static void js_generator_finalizer(JSRuntime *rt, JSValue obj);
 static void js_generator_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
@@ -930,6 +942,7 @@ static JSValue JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                const char *input, size_t input_len,
                                const char *filename, int flags, int scope_idx);
 static void js_free_module_def(JSContext *ctx, JSModuleDef *m);
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier);
 static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref);
 static JSValue js_new_promise_capability(JSContext *ctx,
                                          JSValue *resolving_funcs,
@@ -938,6 +951,8 @@ static __exception int perform_promise_then(JSContext *ctx,
                                             JSValueConst promise,
                                             JSValueConst *resolve_reject,
                                             JSValueConst *cap_resolving_funcs);
+static JSValue js_promise_resolve(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv, int magic);
 static int js_string_compare(JSContext *ctx,
                              const JSString *p1, const JSString *p2);
 static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val);
@@ -1193,6 +1208,7 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Set_Iterator, js_map_iterator_finalizer, js_map_iterator_mark }, /* JS_CLASS_SET_ITERATOR */
     { JS_ATOM_Array_Iterator, js_array_iterator_finalizer, js_array_iterator_mark }, /* JS_CLASS_ARRAY_ITERATOR */
     { JS_ATOM_String_Iterator, js_array_iterator_finalizer, js_array_iterator_mark }, /* JS_CLASS_STRING_ITERATOR */
+    { JS_ATOM_RegExp_String_Iterator, js_regexp_string_iterator_finalizer, js_regexp_string_iterator_mark }, /* JS_CLASS_STRING_ITERATOR */
     { JS_ATOM_Generator, js_generator_finalizer, js_generator_mark }, /* JS_CLASS_GENERATOR */
 };
 
@@ -1748,6 +1764,8 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
 #endif
     for(i = 0; i < rt->class_count; i++)
         ctx->class_proto[i] = JS_NULL;
+    ctx->regexp_ctor = JS_NULL;
+    ctx->promise_ctor = JS_NULL;
     init_list_head(&ctx->loaded_modules);
 
     JS_AddIntrinsicBasicObjects(ctx);
@@ -1881,6 +1899,7 @@ void JS_FreeContext(JSContext *ctx)
     js_free_rt(rt, ctx->class_proto);
     JS_FreeValue(ctx, ctx->iterator_proto);
     JS_FreeValue(ctx, ctx->async_iterator_proto);
+    JS_FreeValue(ctx, ctx->promise_ctor);
     JS_FreeValue(ctx, ctx->regexp_ctor);
     JS_FreeValue(ctx, ctx->function_ctor);
     JS_FreeValue(ctx, ctx->function_proto);
@@ -10827,6 +10846,19 @@ static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
     return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
 }
 
+static JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
+        return val;
+    } else {
+        bf_t a_s, *a;
+        a = JS_ToBigIntFree(ctx, &a_s, val);
+        if (!a)
+            return JS_EXCEPTION;
+        return JS_NewBigInt2(ctx, a, TRUE);
+    }
+}
+
 /* free the bf_t allocated by JS_ToBigInt */
 static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf)
 {
@@ -14331,6 +14363,15 @@ static inline __exception int js_poll_interrupts(JSContext *ctx)
     }
 }
 
+/* argument of OP_special_object */
+typedef enum {
+    OP_SPECIAL_OBJECT_ARGUMENTS,
+    OP_SPECIAL_OBJECT_MAPPED_ARGUMENTS,
+    OP_SPECIAL_OBJECT_THIS_FUNC,
+    OP_SPECIAL_OBJECT_NEW_TARGET,
+    OP_SPECIAL_OBJECT_HOME_OBJECT,
+} OPSpecialObjectEnum;
+
 #define FUNC_RET_AWAIT      0
 #define FUNC_RET_YIELD      1
 #define FUNC_RET_YIELD_STAR 2
@@ -14563,20 +14604,40 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             if (unlikely(JS_IsException(sp[-1])))
                 goto exception;
             BREAK;
-        CASE(OP_this_func):
-            *sp++ = JS_DupValue(ctx, sf->cur_func);
-            BREAK;
-        CASE(OP_arguments):
+        CASE(OP_special_object):
             {
-                int mapped = *pc++;
-                if (mapped) {
+                int arg = *pc++;
+                switch(arg) {
+                case OP_SPECIAL_OBJECT_ARGUMENTS:
+                    *sp++ = js_build_arguments(ctx, argc, (JSValueConst *)argv);
+                    if (unlikely(JS_IsException(sp[-1])))
+                        goto exception;
+                    break;
+                case OP_SPECIAL_OBJECT_MAPPED_ARGUMENTS:
                     *sp++ = js_build_mapped_arguments(ctx, argc, (JSValueConst *)argv,
                                                       sf, min_int(argc, b->arg_count));
-                } else {
-                    *sp++ = js_build_arguments(ctx, argc, (JSValueConst *)argv);
+                    if (unlikely(JS_IsException(sp[-1])))
+                        goto exception;
+                    break;
+                case OP_SPECIAL_OBJECT_THIS_FUNC:
+                    *sp++ = JS_DupValue(ctx, sf->cur_func);
+                    break;
+                case OP_SPECIAL_OBJECT_NEW_TARGET:
+                    *sp++ = JS_DupValue(ctx, new_target);
+                    break;
+                case OP_SPECIAL_OBJECT_HOME_OBJECT:
+                    {
+                        JSObject *p1;
+                        p1 = p->u.func.home_object;
+                        if (unlikely(!p1))
+                            *sp++ = JS_UNDEFINED;
+                        else
+                            *sp++ = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p1));
+                    }
+                    break;
+                default:
+                    abort();
                 }
-                if (unlikely(JS_IsException(sp[-1])))
-                    goto exception;
             }
             BREAK;
         CASE(OP_rest):
@@ -14588,19 +14649,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     goto exception;
             }
             BREAK;
-        CASE(OP_new_target):
-            *sp++ = JS_DupValue(ctx, new_target);
-            BREAK;
-        CASE(OP_home_object):
-            {
-                JSObject *p1;
-                p1 = p->u.func.home_object;
-                if (unlikely(!p1))
-                    *sp++ = JS_UNDEFINED;
-                else
-                    *sp++ = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p1));
-            }
-            BREAK;
 
         CASE(OP_drop):
             JS_FreeValue(ctx, sp[-1]);
@@ -14962,6 +15010,17 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             }
             BREAK;
 
+        CASE(OP_import):
+            {
+                JSValue val;
+                val = js_dynamic_import(ctx, sp[-1]);
+                if (JS_IsException(val))
+                    goto exception;
+                JS_FreeValue(ctx, sp[-1]);
+                sp[-1] = val;
+            }
+            BREAK;
+
         CASE(OP_check_var):
             {
                 int ret;
@@ -17311,20 +17370,11 @@ static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionData *s)
 
             /* await */
             JS_FreeValue(ctx, func_ret); /* not used */
-            promise = js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
-            if (JS_IsException(promise))
-                goto fail;
-            ret2 = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
-                           1, (JSValueConst *)&value);
-            JS_FreeValue(ctx, resolving_funcs[0]);
-            JS_FreeValue(ctx, resolving_funcs[1]);
+            promise = js_promise_resolve(ctx, ctx->promise_ctor,
+                                         1, (JSValueConst *)&value, 0);
             JS_FreeValue(ctx, value);
-            if (JS_IsException(ret2)) {
-                JS_FreeValue(ctx, promise);
+            if (JS_IsException(promise))
                 goto fail;
-            }
-            JS_FreeValue(ctx, ret2);
-
             if (js_async_function_resolve_create(ctx, s, resolving_funcs)) {
                 JS_FreeValue(ctx, promise);
                 goto fail;
@@ -17387,7 +17437,7 @@ static JSValue js_async_function_call(JSContext *ctx, JSValueConst func_obj,
     s->resolving_funcs[0] = JS_UNDEFINED;
     s->resolving_funcs[1] = JS_UNDEFINED;
 
-    promise = js_new_promise_capability(ctx, s->resolving_funcs, JS_UNDEFINED);
+    promise = JS_NewPromiseCapability(ctx, s->resolving_funcs);
     if (JS_IsException(promise))
         goto fail;
 
@@ -17515,21 +17565,13 @@ static int js_async_generator_await(JSContext *ctx,
                                     JSAsyncGeneratorData *s,
                                     JSValueConst value)
 {
-    JSValue promise, resolving_funcs[2], resolving_funcs1[2], ret2;
+    JSValue promise, resolving_funcs[2], resolving_funcs1[2];
     int i, res;
 
-    promise = js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
+    promise = js_promise_resolve(ctx, ctx->promise_ctor,
+                                 1, &value, 0);
     if (JS_IsException(promise))
         goto fail;
-    ret2 = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
-                   1, &value);
-    JS_FreeValue(ctx, resolving_funcs[0]);
-    JS_FreeValue(ctx, resolving_funcs[1]);
-    if (JS_IsException(ret2)) {
-        JS_FreeValue(ctx, promise);
-        goto fail;
-    }
-    JS_FreeValue(ctx, ret2);
 
     if (js_async_generator_resolve_function_create(ctx, JS_MKPTR(JS_TAG_OBJECT, s->generator),
                                                    resolving_funcs, FALSE)) {
@@ -17606,20 +17648,13 @@ static int js_async_generator_completed_return(JSContext *ctx,
                                                JSAsyncGeneratorData *s,
                                                JSValueConst value)
 {
-    JSValue promise, resolving_funcs[2], ret, resolving_funcs1[2];
+    JSValue promise, resolving_funcs[2], resolving_funcs1[2];
     int res;
 
-    promise = js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
+    promise = js_promise_resolve(ctx, ctx->promise_ctor,
+                                 1, (JSValueConst *)&value, 0);
     if (JS_IsException(promise))
         return -1;
-    ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED, 1, &value);
-    JS_FreeValue(ctx, resolving_funcs[0]);
-    JS_FreeValue(ctx, resolving_funcs[1]);
-    if (JS_IsException(ret)) {
-        JS_FreeValue(ctx, promise);
-        return -1;
-    }
-    JS_FreeValue(ctx, ret);
     if (js_async_generator_resolve_function_create(ctx,
                                                    JS_MKPTR(JS_TAG_OBJECT, s->generator),
                                                    resolving_funcs1,
@@ -17781,7 +17816,7 @@ static JSValue js_async_generator_next(JSContext *ctx, JSValueConst this_val,
     JSValue promise, resolving_funcs[2];
     JSAsyncGeneratorRequest *req;
 
-    promise = js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
     if (JS_IsException(promise))
         return JS_EXCEPTION;
     if (!s) {
@@ -19222,6 +19257,7 @@ static __exception int next_token(JSParseState *s)
 }
 
 /* only used for ':' and '=>', 'let' or 'function' look-ahead */
+/* XXX: handle all unicode cases */
 static int peek_token(JSParseState *s, BOOL no_line_terminator)
 {
     const uint8_t *p;
@@ -21756,6 +21792,19 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             return js_parse_error(s, "invalid use of 'super'");
         }
         break;
+    case TOK_IMPORT:
+        if (!accept_lparen)
+            return js_parse_error(s, "invalid use of 'import'");
+        if (next_token(s))
+            return -1;
+        if (js_parse_expect(s, '('))
+            return -1;
+        if (js_parse_assign_expr(s, TRUE))
+            return -1;
+        if (js_parse_expect(s, ')'))
+            return -1;
+        emit_op(s, OP_import);
+        break;
     default:
         return js_parse_error(s, "unexpected token in expression: '%.*s'",
                               (int)(s->buf_ptr - s->token.ptr), s->token.ptr);
@@ -22538,6 +22587,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                 label_throw = emit_goto(s, OP_if_true, -1);
 
                 /* return handling */
+                emit_op(s, OP_await);
                 emit_op(s, OP_async_iterator_get);
                 emit_u8(s, 0);
                 label_return1 = emit_goto(s, OP_if_true, -1);
@@ -22548,7 +22598,6 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                 emit_goto(s, OP_if_false, label_yield);
 
                 emit_label(s, label_return1);
-                emit_op(s, OP_await);
                 emit_op(s, OP_nip);
                 emit_op(s, OP_nip);
                 emit_op(s, OP_nip);
@@ -22586,7 +22635,6 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                 emit_op(s, OP_await);
                 emit_op(s, OP_yield);
                 label_next = emit_goto(s, OP_if_false, -1);
-                emit_op(s, OP_await);
                 emit_return(s, TRUE);
                 emit_label(s, label_next);
             }
@@ -22825,8 +22873,11 @@ static void emit_return(JSParseState *s, BOOL hasval)
         emit_label(s, label_return);
         emit_op(s, OP_return);
     } else if (s->cur_func->func_kind != JS_FUNC_NORMAL) {
-        if (!hasval)
+        if (!hasval) {
             emit_op(s, OP_undefined);
+        } else if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
+            emit_op(s, OP_await);
+        }
         emit_op(s, OP_return_async);
     } else {
         emit_op(s, hasval ? OP_return : OP_return_undef);
@@ -23965,7 +24016,6 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
     case TOK_ENUM:
     case TOK_EXPORT:
     case TOK_EXTENDS:
-    case TOK_IMPORT:
         js_unsupported_keyword(s, s->token.u.ident.atom);
         goto fail;
 
@@ -24006,6 +24056,7 @@ static JSModuleDef *js_new_module_def(JSContext *ctx, JSAtom name)
     m->module_name = name;
     m->module_ns = JS_UNDEFINED;
     m->func_obj = JS_UNDEFINED;
+    m->eval_exception = JS_UNDEFINED;
     list_add_tail(&m->link, &ctx->loaded_modules);
     return m;
 }
@@ -24041,6 +24092,7 @@ static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
 
     JS_FreeValue(ctx, m->module_ns);
     JS_FreeValue(ctx, m->func_obj);
+    JS_FreeValue(ctx, m->eval_exception);
     list_del(&m->link);
     js_free(ctx, m);
 }
@@ -24268,7 +24320,7 @@ static char *js_default_module_normalize_name(JSContext *ctx,
 
 /* return NULL in case of exception (e.g. module could not be loaded) */
 static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
-                                                    JSModuleDef *base_module,
+                                                    JSAtom base_module_name,
                                                     JSAtom module_name1)
 {
     JSRuntime *rt = ctx->rt;
@@ -24278,7 +24330,7 @@ static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
     const char *base_cname, *cname1;
     JSAtom module_name;
 
-    base_cname = JS_AtomToCString(ctx, base_module->module_name);
+    base_cname = JS_AtomToCString(ctx, base_module_name);
     if (!base_cname)
         return NULL;
     cname1 = JS_AtomToCString(ctx, module_name1);
@@ -24400,10 +24452,18 @@ static JSResolveResultEnum js_resolve_export1(JSContext *ctx,
             *pme = me;
             return JS_RESOLVE_RES_FOUND;
         } else {
+            /* indirect export */
             JSModuleDef *m1;
             m1 = m->req_module_entries[me->u.req_module_idx].module;
-            return js_resolve_export1(ctx, pmodule, pme, m1,
-                                      me->local_name, s);
+            if (me->local_name == JS_ATOM__star_) {
+                /* export ns from */
+                *pmodule = m;
+                *pme = me;
+                return JS_RESOLVE_RES_FOUND;
+            } else {
+                return js_resolve_export1(ctx, pmodule, pme, m1,
+                                          me->local_name, s);
+            }
         }
     } else {
         if (export_name != JS_ATOM_default) {
@@ -24498,10 +24558,20 @@ static void js_resolve_export_throw_error(JSContext *ctx,
 }
 
 
+typedef enum {
+    EXPORTED_NAME_AMBIGUOUS,
+    EXPORTED_NAME_NORMAL,
+    EXPORTED_NAME_NS,
+} ExportedNameEntryEnum;
+
 typedef struct ExportedNameEntry {
     JSAtom export_name;
-    JSExportEntry *me; /* NULL if not coming from the module */
-    JSVarRef *var_ref;
+    ExportedNameEntryEnum export_type;
+    union {
+        JSExportEntry *me; /* using when the list is built */
+        JSVarRef *var_ref; /* EXPORTED_NAME_NORMAL */
+        JSModuleDef *module; /* for EXPORTED_NAME_NS */
+    } u;
 } ExportedNameEntry;
 
 typedef struct GetExportNamesState {
@@ -24554,12 +24624,12 @@ static __exception int get_exported_names(JSContext *ctx,
             en->export_name = me->export_name;
             /* avoid a second lookup for simple module exports */
             if (from_star || me->export_type != JS_EXPORT_TYPE_LOCAL)
-                en->me = NULL;
+                en->u.me = NULL;
             else
-                en->me = me;
+                en->u.me = me;
         } else {
             en = &s->exported_names[j];
-            en->me = NULL;
+            en->u.me = NULL;
         }
     }
     for(i = 0; i < m->star_export_entries_count; i++) {
@@ -24605,6 +24675,23 @@ static int exported_names_cmp(const void *p1, const void *p2, void *opaque)
     return ret;
 }
 
+static JSValue js_get_module_ns(JSContext *ctx, JSModuleDef *m);
+
+static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
+                                 void *opaque)
+{
+    JSModuleDef *m = opaque;
+    JSValue val, this_val = JS_MKPTR(JS_TAG_OBJECT, p);
+    
+    val = js_get_module_ns(ctx, m);
+    if (JS_IsException(val))
+        return -1;
+    if (JS_DefinePropertyValue(ctx, this_val, atom, val,
+                               JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
+        return -1;
+    return 0;
+}
+
 static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
 {
     JSValue obj;
@@ -24631,8 +24718,8 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
         JSExportEntry *res_me;
         JSModuleDef *res_m;
 
-        if (en->me) {
-            res_me = en->me; /* fast case: no resolution needed */
+        if (en->u.me) {
+            res_me = en->u.me; /* fast case: no resolution needed */
             res_m = m;
             res = JS_RESOLVE_RES_FOUND;
         } else {
@@ -24644,14 +24731,20 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
                 js_resolve_export_throw_error(ctx, res, m, en->export_name);
                 goto fail;
             }
-            en->var_ref = NULL;
+            en->export_type = EXPORTED_NAME_AMBIGUOUS;
         } else {
-            if (res_me->u.local.var_ref) {
-                en->var_ref = res_me->u.local.var_ref;
+            if (res_me->local_name == JS_ATOM__star_) {
+                en->export_type = EXPORTED_NAME_NS;
+                en->u.module = res_m->req_module_entries[res_me->u.req_module_idx].module;
             } else {
-                JSObject *p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
-                p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
-                en->var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
+                en->export_type = EXPORTED_NAME_NORMAL;
+                if (res_me->u.local.var_ref) {
+                    en->u.var_ref = res_me->u.local.var_ref;
+                } else {
+                    JSObject *p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
+                    p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
+                    en->u.var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
+                }
             }
         }
     }
@@ -24662,15 +24755,29 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
 
     for(i = 0; i < s->exported_names_count; i++) {
         ExportedNameEntry *en = &s->exported_names[i];
-        JSVarRef *var_ref = en->var_ref;
-        if (var_ref != NULL) {
-            pr = add_property(ctx, p, en->export_name,
-                              JS_PROP_ENUMERABLE | JS_PROP_WRITABLE |
-                              JS_PROP_VARREF);
-            if (!pr)
+        switch(en->export_type) {
+        case EXPORTED_NAME_NORMAL:
+            {
+                JSVarRef *var_ref = en->u.var_ref;
+                pr = add_property(ctx, p, en->export_name,
+                                  JS_PROP_ENUMERABLE | JS_PROP_WRITABLE |
+                                  JS_PROP_VARREF);
+                if (!pr)
+                    goto fail;
+                var_ref->header.ref_count++;
+                pr->u.var_ref = var_ref;
+            }
+            break;
+        case EXPORTED_NAME_NS:
+            /* the exported namespace must be created on demand */
+            if (JS_DefineAutoInitProperty(ctx, obj,
+                                          en->export_name,
+                                          js_module_ns_autoinit,
+                                          en->u.module, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
                 goto fail;
-            var_ref->header.ref_count++;
-            pr->u.var_ref = var_ref;
+            break;
+        default:
+            break;
         }
     }
 
@@ -24688,6 +24795,18 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
     return JS_EXCEPTION;
 }
 
+static JSValue js_get_module_ns(JSContext *ctx, JSModuleDef *m)
+{
+    if (JS_IsUndefined(m->module_ns)) {
+        JSValue val;
+        val = js_build_module_ns(ctx, m);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        m->module_ns = val;
+    }
+    return JS_DupValue(ctx, m->module_ns);
+}
+
 /* Load all the required modules for module 'm' */
 static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
 {
@@ -24706,7 +24825,8 @@ static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
     /* resolve each requested module */
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        m1 = js_host_resolve_imported_module(ctx, m, rme->module_name);
+        m1 = js_host_resolve_imported_module(ctx, m->module_name,
+                                             rme->module_name);
         if (!m1)
             return -1;
         rme->module = m1;
@@ -24836,7 +24956,8 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     /* check the indirect exports */
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
-        if (me->export_type == JS_EXPORT_TYPE_INDIRECT) {
+        if (me->export_type == JS_EXPORT_TYPE_INDIRECT &&
+            me->local_name != JS_ATOM__star_) {
             JSResolveResultEnum ret;
             JSExportEntry *res_me;
             JSModuleDef *res_m, *m1;
@@ -24867,20 +24988,21 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
 
         for(i = 0; i < m->import_entries_count; i++) {
             mi = &m->import_entries[i];
+#ifdef DUMP_MODULE_RESOLVE
+            printf("import var_idx=%d name=", mi->var_idx);
+            print_atom(ctx, mi->import_name);
+            printf(": ");
+#endif
             m1 = m->req_module_entries[mi->req_module_idx].module;
             if (mi->import_name == JS_ATOM__star_) {
+                JSValue val;
                 /* name space import */
-                if (JS_IsUndefined(m1->module_ns)) {
-                    JSValue val;
-                    val = js_build_module_ns(ctx, m1);
-                    if (JS_IsException(val))
-                        goto fail;
-                    m1->module_ns = val;
-                }
-                set_value(ctx, &var_refs[mi->var_idx]->value,
-                          JS_DupValue(ctx, m1->module_ns));
+                val = js_get_module_ns(ctx, m1);
+                if (JS_IsException(val))
+                    goto fail;
+                set_value(ctx, &var_refs[mi->var_idx]->value, val);
 #ifdef DUMP_MODULE_RESOLVE
-                printf("import %d: namespace\n", mi->var_idx);
+                printf("namespace\n");
 #endif
             } else {
                 JSResolveResultEnum ret;
@@ -24894,16 +25016,36 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
                     js_resolve_export_throw_error(ctx, ret, m1, mi->import_name);
                     goto fail;
                 }
-                var_ref = res_me->u.local.var_ref;
-                if (!var_ref) {
-                    p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
-                    var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
-                }
-                var_ref->header.ref_count++;
-                var_refs[mi->var_idx] = var_ref;
+                if (res_me->local_name == JS_ATOM__star_) {
+                    JSValue val;
+                    JSModuleDef *m2;
+                    /* name space import from */
+                    m2 = res_m->req_module_entries[res_me->u.req_module_idx].module;
+                    val = js_get_module_ns(ctx, m2);
+                    if (JS_IsException(val))
+                        goto fail;
+                    var_ref = js_create_module_var(ctx, TRUE);
+                    if (!var_ref) {
+                        JS_FreeValue(ctx, val);
+                        goto fail;
+                    }
+                    set_value(ctx, &var_ref->value, val);
+                    var_refs[mi->var_idx] = var_ref;
 #ifdef DUMP_MODULE_RESOLVE
-                printf("import %d: %p\n", mi->var_idx, var_ref);
+                    printf("namespace from\n");
 #endif
+                } else {
+                    var_ref = res_me->u.local.var_ref;
+                    if (!var_ref) {
+                        p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
+                        var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
+                    }
+                    var_ref->header.ref_count++;
+                    var_refs[mi->var_idx] = var_ref;
+#ifdef DUMP_MODULE_RESOLVE
+                    printf("local export (var_ref=%p)\n", var_ref);
+#endif
+                }
             }
         }
 
@@ -24928,6 +25070,85 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     return -1;
 }
 
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+{
+    JSStackFrame *sf;
+    JSFunctionBytecode *b;
+    JSObject *p;
+    JSModuleDef *m;
+    JSAtom basename, filename;
+    JSValue promise, resolving_funcs[2];
+    JSValue specifierString, ret, func_obj, err, ns;
+    
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return promise;
+    
+    /* XXX: currently we just use the filename of the englobing
+       function. It does not work for eval(). Need to add a
+       ScriptOrModule info in JSFunctionBytecode */
+    sf = ctx->current_stack_frame;
+    assert(sf != NULL);
+    assert(JS_VALUE_GET_TAG(sf->cur_func) == JS_TAG_OBJECT);
+    p = JS_VALUE_GET_OBJ(sf->cur_func);
+    assert(js_class_has_bytecode(p->class_id));
+    b = p->u.func.function_bytecode;
+    if (!b->has_debug) {
+        JS_ThrowTypeError(ctx, "no function filename for import()");
+        goto exception;
+    }
+    basename = b->debug.filename;
+
+    specifierString = JS_ToString(ctx, specifier);
+    if (JS_IsException(specifierString))
+        goto exception;
+    filename = js_value_to_atom(ctx, specifierString);
+    JS_FreeValue(ctx, specifierString);
+    if (filename == JS_ATOM_NULL)
+        goto exception;
+                     
+    m = js_host_resolve_imported_module(ctx, basename, filename);
+    JS_FreeAtom(ctx, filename);
+    if (!m) {
+        goto exception;
+    }
+    
+    if (js_resolve_module(ctx, m) < 0) {
+        js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
+        goto exception;
+    }
+
+    /* Evaluate the module code */
+    func_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+    ret = JS_EvalFunction(ctx, func_obj, ctx->global_obj);
+    if (JS_IsException(ret))
+        goto exception;
+    JS_FreeValue(ctx, ret);
+
+    /* return the module namespace */
+    ns = js_get_module_ns(ctx, m);
+    if (JS_IsException(ret))
+        goto exception;
+
+    ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
+                   1, (JSValueConst *)&ns);
+    JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
+    JS_FreeValue(ctx, ns);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    return promise;
+
+ exception:
+    err = JS_GetException(ctx);
+    ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
+                   1, (JSValueConst *)&err);
+    JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
+    JS_FreeValue(ctx, err);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    return promise;
+}
+
 /* Run the <eval> function of the module and of all its requested
    modules. */
 static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
@@ -24936,17 +25157,32 @@ static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
     int i;
     JSValue ret_val;
 
-    if (m->evaluated)
-        return JS_UNDEFINED;
-    m->evaluated = TRUE;
+    if (m->eval_mark)
+        return JS_UNDEFINED; /* avoid cycles */
+
+    if (m->evaluated) {
+        /* if the module was already evaluated, rethrow the exception
+           it raised */
+        if (m->eval_has_exception) {
+            return JS_Throw(ctx, JS_DupValue(ctx, m->eval_exception));
+        } else {
+            return JS_UNDEFINED;
+        }
+    }
+
+    m->eval_mark = TRUE;
 
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        m1 = rme->module; /* already resolved */
-        ret_val = js_evaluate_module(ctx, m1);
-        if (JS_IsException(ret_val))
-            return ret_val;
-        JS_FreeValue(ctx, ret_val);
+        m1 = rme->module;
+        if (!m1->eval_mark) {
+            ret_val = js_evaluate_module(ctx, m1);
+            if (JS_IsException(ret_val)) {
+                m->eval_mark = FALSE;
+                return ret_val;
+            }
+            JS_FreeValue(ctx, ret_val);
+        }
     }
 
     if (m->init_func) {
@@ -24959,6 +25195,13 @@ static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
         ret_val = JS_CallFree(ctx, m->func_obj, JS_UNDEFINED, 0, NULL);
         m->func_obj = JS_UNDEFINED;
     }
+    if (JS_IsException(ret_val)) {
+        /* save the thrown exception value */
+        m->eval_has_exception = TRUE;
+        m->eval_exception = JS_DupValue(ctx, ctx->current_exception);
+    }
+    m->eval_mark = FALSE;
+    m->evaluated = TRUE;
     return ret_val;
 }
 
@@ -25035,6 +25278,7 @@ static __exception int js_parse_export(JSParseState *s)
                 if (next_token(s)) {
                 fail:
                     JS_FreeAtom(ctx, local_name);
+                fail1:
                     JS_FreeAtom(ctx, export_name);
                     return -1;
                 }
@@ -25070,15 +25314,41 @@ static __exception int js_parse_export(JSParseState *s)
         }
         break;
     case '*':
-        module_name = js_parse_from_clause(s);
-        if (module_name == JS_ATOM_NULL)
-            return -1;
-        idx = add_req_module_entry(ctx, m, module_name);
-        JS_FreeAtom(ctx, module_name);
-        if (idx < 0)
-            return -1;
-        if (add_star_export_entry(ctx, m, idx) < 0)
-            return -1;
+        if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+            /* export ns from */
+            if (next_token(s))
+                return -1;
+            if (!token_is_ident(s->token.val)) {
+                js_parse_error(s, "identifier expected");
+                return -1;
+            }
+            export_name = JS_DupAtom(ctx, s->token.u.ident.atom);
+            if (next_token(s))
+                goto fail1;
+            module_name = js_parse_from_clause(s);
+            if (module_name == JS_ATOM_NULL)
+                goto fail1;
+            idx = add_req_module_entry(ctx, m, module_name);
+            JS_FreeAtom(ctx, module_name);
+            if (idx < 0)
+                goto fail1;
+            me = add_export_entry(s, m, JS_ATOM__star_, export_name,
+                                  JS_EXPORT_TYPE_INDIRECT);
+            JS_FreeAtom(ctx, export_name);
+            if (!me)
+                return -1;
+            me->u.req_module_idx = idx;
+        } else {
+            module_name = js_parse_from_clause(s);
+            if (module_name == JS_ATOM_NULL)
+                return -1;
+            idx = add_req_module_entry(ctx, m, module_name);
+            JS_FreeAtom(ctx, module_name);
+            if (idx < 0)
+                return -1;
+            if (add_star_export_entry(ctx, m, idx) < 0)
+                return -1;
+        }
         break;
     case TOK_DEFAULT:
         if (s->token.val == TOK_CLASS) {
@@ -25285,7 +25555,10 @@ static __exception int js_parse_source_element(JSParseState *s)
     } else if (s->token.val == TOK_EXPORT && fd->module) {
         if (js_parse_export(s))
             return -1;
-    } else if (s->token.val == TOK_IMPORT && fd->module) {
+    } else if (s->token.val == TOK_IMPORT && fd->module &&
+               peek_token(s, FALSE) != '(') {
+        /* the peek_token is needed to avoid confusion with ImportCall
+           (dynamic import) */
         if (js_parse_import(s))
             return -1;
     } else {
@@ -27651,17 +27924,20 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
 
     /* initialize the 'home_object' variable if needed */
     if (s->home_object_var_idx >= 0) {
-        dbuf_putc(&bc_out, OP_home_object);
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_HOME_OBJECT);
         put_short_code(&bc_out, OP_put_loc, s->home_object_var_idx);
     }
     /* initialize the 'this.active_func' variable if needed */
     if (s->this_active_func_var_idx >= 0) {
-        dbuf_putc(&bc_out, OP_this_func);
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_THIS_FUNC);
         put_short_code(&bc_out, OP_put_loc, s->this_active_func_var_idx);
     }
     /* initialize the 'new.target' variable if needed */
     if (s->new_target_var_idx >= 0) {
-        dbuf_putc(&bc_out, OP_new_target);
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_NEW_TARGET);
         put_short_code(&bc_out, OP_put_loc, s->new_target_var_idx);
     }
     /* initialize the 'this' variable if needed. In a derived class
@@ -27678,17 +27954,18 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
     /* initialize the 'arguments' variable if needed */
     if (s->arguments_var_idx >= 0) {
         if ((s->js_mode & JS_MODE_STRICT) || !s->has_simple_parameter_list) {
-            dbuf_putc(&bc_out, OP_arguments);
-            dbuf_putc(&bc_out, 0);
+            dbuf_putc(&bc_out, OP_special_object);
+            dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_ARGUMENTS);
         } else {
-            dbuf_putc(&bc_out, OP_arguments);
-            dbuf_putc(&bc_out, 1);
+            dbuf_putc(&bc_out, OP_special_object);
+            dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_MAPPED_ARGUMENTS);
         }
         put_short_code(&bc_out, OP_put_loc, s->arguments_var_idx);
     }
     /* initialize a reference to the current function if needed */
     if (s->func_var_idx >= 0) {
-        dbuf_putc(&bc_out, OP_this_func);
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_THIS_FUNC);
         put_short_code(&bc_out, OP_put_loc, s->func_var_idx);
     }
     /* initialize the variable environment object if needed */
@@ -29697,6 +29974,28 @@ JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj, JSValueConst this_obj)
     return JS_EvalFunctionInternal(ctx, fun_obj, this_obj, NULL, NULL);
 }
 
+static void skip_shebang(JSParseState *s)
+{
+    const uint8_t *p = s->buf_ptr;
+    int c;
+
+    if (p[0] == '#' && p[1] == '!') {
+        p += 2;
+        while (p < s->buf_end) {
+            if (*p == '\n' || *p == '\r') {
+                break;
+            } else if (*p >= 0x80) {
+                c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+                if (c == CP_LS || c == CP_PS)
+                    break;
+            } else {
+                p++;
+            }
+        }
+        s->buf_ptr = p;
+    }
+}
+
 /* 'input' must be zero terminated i.e. input[input_len] = '\0'. */
 static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                  const char *input, size_t input_len,
@@ -29712,16 +30011,8 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
     JSModuleDef *m;
 
     js_parse_init(ctx, s, input, input_len, filename);
+    skip_shebang(s);
 
-    if (flags & JS_EVAL_FLAG_SHEBANG) {
-        const uint8_t *p = s->buf_ptr;
-        if (p[0] == '#' && p[1] == '!') {
-            p += 2;
-            while (*p != '\0' && *p != '\n')
-                p++;
-            s->buf_ptr = p;
-        }
-    }
     eval_type = flags & JS_EVAL_TYPE_MASK;
     m = NULL;
     if (eval_type == JS_EVAL_TYPE_DIRECT) {
@@ -32128,20 +32419,6 @@ static JSValue js_object___defineGetter__(JSContext *ctx, JSValueConst this_val,
     }
 }
 
-/* Note: corresponds to ECMA spec: CreateDataPropertyOrThrow() */
-static JSValue js_object___setOwnProperty(JSContext *ctx, JSValueConst this_val,
-                                          int argc, JSValueConst *argv)
-{
-    int ret;
-    ret = JS_DefinePropertyValueValue(ctx, argv[0], JS_DupValue(ctx, argv[1]),
-                                      JS_DupValue(ctx, argv[2]),
-                                      JS_PROP_C_W_E | JS_PROP_THROW);
-    if (ret < 0)
-        return JS_EXCEPTION;
-    else
-        return JS_NewBool(ctx, ret);
-}
-
 static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst this_val,
                                                   int argc, JSValueConst *argv, int magic)
 {
@@ -32605,7 +32882,89 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+static JSValue js_object_fromEntries(JSContext *ctx, JSValueConst this_val,
+                                     int argc, JSValueConst *argv)
+{
+    JSValue obj, iter, next_method = JS_UNDEFINED;
+    JSValueConst iterable;
+    BOOL done;
+
+    /*  RequireObjectCoercible() not necessary because it is tested in
+        JS_GetIterator() by JS_GetProperty() */
+    iterable = argv[0];
+
+    obj = JS_NewObject(ctx);
+    if (JS_IsException(obj))
+        return obj;
+    
+    iter = JS_GetIterator(ctx, iterable, FALSE);
+    if (JS_IsException(iter))
+        goto fail;
+    next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        goto fail;
+    
+    for(;;) {
+        JSValue key, value, item;
+        item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
+        if (JS_IsException(item))
+            goto fail;
+        if (done) {
+            JS_FreeValue(ctx, item);
+            break;
+        }
+        
+        key = JS_UNDEFINED;
+        value = JS_UNDEFINED;
+        if (!JS_IsObject(item)) {
+            JS_ThrowTypeErrorNotAnObject(ctx);
+            goto fail1;
+        }
+        key = JS_GetPropertyUint32(ctx, item, 0);
+        if (JS_IsException(key))
+            goto fail1;
+        value = JS_GetPropertyUint32(ctx, item, 1);
+        if (JS_IsException(value)) {
+            JS_FreeValue(ctx, key);
+            goto fail1;
+        }
+        if (JS_DefinePropertyValueValue(ctx, obj, key, value,
+                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0) {
+        fail1:
+            JS_FreeValue(ctx, item);
+            goto fail;
+        }
+        JS_FreeValue(ctx, item);
+    }
+    JS_FreeValue(ctx, next_method);
+    JS_FreeValue(ctx, iter);
+    return obj;
+ fail:
+    if (JS_IsObject(iter)) {
+        /* close the iterator object, preserving pending exception */
+        JS_IteratorClose(ctx, iter, TRUE);
+    }
+    JS_FreeValue(ctx, next_method);
+    JS_FreeValue(ctx, iter);
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
 #if 0
+/* Note: corresponds to ECMA spec: CreateDataPropertyOrThrow() */
+static JSValue js_object___setOwnProperty(JSContext *ctx, JSValueConst this_val,
+                                          int argc, JSValueConst *argv)
+{
+    int ret;
+    ret = JS_DefinePropertyValueValue(ctx, argv[0], JS_DupValue(ctx, argv[1]),
+                                      JS_DupValue(ctx, argv[2]),
+                                      JS_PROP_C_W_E | JS_PROP_THROW);
+    if (ret < 0)
+        return JS_EXCEPTION;
+    else
+        return JS_NewBool(ctx, ret);
+}
+
 static JSValue js_object___toObject(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv)
 {
@@ -32891,13 +33250,14 @@ static const JSCFunctionListEntry js_object_funcs[] = {
     //JS_CFUNC_DEF("__isObject", 1, js_object___isObject ),
     //JS_CFUNC_DEF("__isConstructor", 1, js_object___isConstructor ),
     //JS_CFUNC_DEF("__toObject", 1, js_object___toObject ),
-    JS_CFUNC_DEF("__setOwnProperty", 3, js_object___setOwnProperty ),
+    //JS_CFUNC_DEF("__setOwnProperty", 3, js_object___setOwnProperty ),
     //JS_CFUNC_DEF("__toPrimitive", 2, js_object___toPrimitive ),
     //JS_CFUNC_DEF("__toPropertyKey", 1, js_object___toPropertyKey ),
     //JS_CFUNC_DEF("__speciesConstructor", 2, js_object___speciesConstructor ),
     //JS_CFUNC_DEF("__isSameValueZero", 2, js_object___isSameValueZero ),
     //JS_CFUNC_DEF("__getObjectData", 1, js_object___getObjectData ),
     //JS_CFUNC_DEF("__setObjectData", 2, js_object___setObjectData ),
+    JS_CFUNC_DEF("fromEntries", 1, js_object_fromEntries ),
 };
 
 static const JSCFunctionListEntry js_object_proto_funcs[] = {
@@ -36053,10 +36413,11 @@ static JSValue js_string_includes(JSContext *ctx, JSValueConst this_val,
 static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv, int atom)
 {
-    // match(rx) and search(rx)
-    // atom is JS_ATOM_Symbol_match or JS_ATOM_Symbol_search
-    JSValueConst O = this_val, regexp = argv[0];
-    JSValue matcher, S, rx, result;
+    // match(rx), search(rx), matchAll(rx)
+    // atom is JS_ATOM_Symbol_match, JS_ATOM_Symbol_search, or JS_ATOM_Symbol_matchAll
+    JSValueConst O = this_val, regexp = argv[0], args[2];
+    JSValue matcher, S, rx, result, str;
+    int args_len;
 
     if (JS_IsUndefined(O) || JS_IsNull(O))
         return JS_ThrowTypeError(ctx, "cannot convert to object");
@@ -36072,8 +36433,19 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
     S = JS_ToString(ctx, O);
     if (JS_IsException(S))
         return JS_EXCEPTION;
-    rx = JS_CallConstructor(ctx, ctx->regexp_ctor, 1, &regexp);
+    args_len = 1;
+    args[0] = regexp;
+    str = JS_UNDEFINED;
+    if (atom == JS_ATOM_Symbol_matchAll) {
+        str = JS_NewString(ctx, "g");
+        if (JS_IsException(str))
+            goto fail;
+        args[args_len++] = (JSValueConst)str;
+    }
+    rx = JS_CallConstructor(ctx, ctx->regexp_ctor, args_len, args);
+    JS_FreeValue(ctx, str);
     if (JS_IsException(rx)) {
+    fail:
         JS_FreeValue(ctx, S);
         return JS_EXCEPTION;
     }
@@ -36997,6 +37369,7 @@ static const JSCFunctionListEntry js_string_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("endsWith", 1, js_string_includes, 2 ),
     JS_CFUNC_MAGIC_DEF("startsWith", 1, js_string_includes, 1 ),
     JS_CFUNC_MAGIC_DEF("match", 1, js_string_match, JS_ATOM_Symbol_match ),
+    JS_CFUNC_MAGIC_DEF("matchAll", 1, js_string_match, JS_ATOM_Symbol_matchAll ),
     JS_CFUNC_MAGIC_DEF("search", 1, js_string_match, JS_ATOM_Symbol_search ),
     JS_CFUNC_DEF("split", 2, js_string_split ),
     JS_CFUNC_DEF("substring", 2, js_string_substring ),
@@ -38560,6 +38933,156 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+typedef struct JSRegExpStringIteratorData {
+    JSValue iterating_regexp;
+    JSValue iterated_string;
+    BOOL global;
+    BOOL unicode;
+    BOOL done;
+} JSRegExpStringIteratorData;
+
+static void js_regexp_string_iterator_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(val);
+    JSRegExpStringIteratorData *it = p->u.regexp_string_iterator_data;
+    if (it) {
+        JS_FreeValueRT(rt, it->iterating_regexp);
+        JS_FreeValueRT(rt, it->iterated_string);
+        js_free_rt(rt, it);
+    }
+}
+
+static void js_regexp_string_iterator_mark(JSRuntime *rt, JSValueConst val,
+                                           JS_MarkFunc *mark_func)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(val);
+    JSRegExpStringIteratorData *it = p->u.regexp_string_iterator_data;
+    if (it) {
+        JS_MarkValue(rt, it->iterating_regexp, mark_func);
+        JS_MarkValue(rt, it->iterated_string, mark_func);
+    }
+}
+
+static JSValue js_regexp_string_iterator_next(JSContext *ctx,
+                                              JSValueConst this_val,
+                                              int argc, JSValueConst *argv,
+                                              BOOL *pdone, int magic)
+{
+    JSRegExpStringIteratorData *it;
+    JSValueConst R, S;
+    JSValue matchStr = JS_UNDEFINED, match = JS_UNDEFINED;
+    JSString *sp;
+
+    it = JS_GetOpaque2(ctx, this_val, JS_CLASS_REGEXP_STRING_ITERATOR);
+    if (!it)
+        goto exception;
+    if (it->done) {
+        *pdone = TRUE;
+        return JS_UNDEFINED;
+    }
+    R = it->iterating_regexp;
+    S = it->iterated_string;
+    match = JS_RegExpExec(ctx, R, S);
+    if (JS_IsException(match))
+        goto exception;
+    if (JS_IsNull(match)) {
+        it->done = TRUE;
+        *pdone = TRUE;
+        return JS_UNDEFINED;
+    } else if (it->global) {
+        matchStr = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, match, 0));
+        if (JS_IsException(matchStr))
+            goto exception;
+        if (JS_IsEmptyString(matchStr)) {
+            int64_t thisIndex, nextIndex;
+            if (JS_ToLengthFree(ctx, &thisIndex,
+                                JS_GetProperty(ctx, R, JS_ATOM_lastIndex)) < 0)
+                goto exception;
+            sp = JS_VALUE_GET_STRING(S);
+            nextIndex = string_advance_index(sp, thisIndex, it->unicode);
+            if (JS_SetProperty(ctx, R, JS_ATOM_lastIndex,
+                               JS_NewInt32(ctx, nextIndex)) < 0)
+                goto exception;
+        }
+        JS_FreeValue(ctx, matchStr);
+    } else {
+        it->done = TRUE;
+    }
+    *pdone = FALSE;
+    return match;
+ exception:
+    JS_FreeValue(ctx, match);
+    JS_FreeValue(ctx, matchStr);
+    *pdone = FALSE;
+    return JS_EXCEPTION;
+}
+
+static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
+                                         int argc, JSValueConst *argv)
+{
+    // [Symbol.matchAll](str)
+    JSValueConst R = this_val;
+    JSValue S, C, flags, matcher, iter;
+    JSValueConst args[2];
+    JSString *strp;
+    int64_t lastIndex;
+    JSRegExpStringIteratorData *it;
+    
+    if (!JS_IsObject(R))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+
+    C = JS_UNDEFINED;
+    flags = JS_UNDEFINED;
+    matcher = JS_UNDEFINED;
+    iter = JS_UNDEFINED;
+    
+    S = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(S))
+        goto exception;
+    C = JS_SpeciesConstructor(ctx, R, ctx->regexp_ctor);
+    if (JS_IsException(C))
+        goto exception;
+    flags = JS_ToStringFree(ctx, JS_GetProperty(ctx, R, JS_ATOM_flags));
+    if (JS_IsException(flags))
+        goto exception;
+    args[0] = R;
+    args[1] = flags;
+    matcher = JS_CallConstructor(ctx, C, 2, args);
+    if (JS_IsException(matcher))
+        goto exception;
+    if (JS_ToLengthFree(ctx, &lastIndex,
+                        JS_GetProperty(ctx, R, JS_ATOM_lastIndex)))
+        goto exception;
+    if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex,
+                       JS_NewInt32(ctx, lastIndex)) < 0)
+        goto exception;
+    
+    iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
+    if (JS_IsException(iter))
+        goto exception;
+    it = js_malloc(ctx, sizeof(*it));
+    if (!it)
+        goto exception;
+    it->iterating_regexp = matcher;
+    it->iterated_string = S;
+    strp = JS_VALUE_GET_STRING(flags);
+    it->global = string_indexof_char(strp, 'g', 0) >= 0;
+    it->unicode = string_indexof_char(strp, 'u', 0) >= 0;
+    it->done = FALSE;
+    JS_SetOpaque(iter, it);
+
+    JS_FreeValue(ctx, C);
+    JS_FreeValue(ctx, flags);
+    return iter;
+ exception:
+    JS_FreeValue(ctx, S);
+    JS_FreeValue(ctx, C);
+    JS_FreeValue(ctx, flags);
+    JS_FreeValue(ctx, matcher);
+    JS_FreeValue(ctx, iter);
+    return JS_EXCEPTION;
+}
+
 typedef struct ValueBuffer {
     JSContext *ctx;
     JSValue *arr;
@@ -39016,12 +39539,18 @@ static const JSCFunctionListEntry js_regexp_proto_funcs[] = {
     JS_CFUNC_DEF("toString", 0, js_regexp_toString ),
     JS_CFUNC_DEF("[Symbol.replace]", 2, js_regexp_Symbol_replace ),
     JS_CFUNC_DEF("[Symbol.match]", 1, js_regexp_Symbol_match ),
+    JS_CFUNC_DEF("[Symbol.matchAll]", 1, js_regexp_Symbol_matchAll ),
     JS_CFUNC_DEF("[Symbol.search]", 1, js_regexp_Symbol_search ),
     JS_CFUNC_DEF("[Symbol.split]", 2, js_regexp_Symbol_split ),
     //JS_CGETSET_DEF("__source", js_regexp_get___source, NULL ),
     //JS_CGETSET_DEF("__flags", js_regexp_get___flags, NULL ),
 };
 
+static const JSCFunctionListEntry js_regexp_string_iterator_proto_funcs[] = {
+    JS_ITERATOR_NEXT_DEF("next", 0, js_regexp_string_iterator_next, 0 ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "RegExp String Iterator", JS_PROP_CONFIGURABLE ),
+};
+
 void JS_AddIntrinsicRegExpCompiler(JSContext *ctx)
 {
     ctx->compile_regexp = js_compile_regexp;
@@ -39040,6 +39569,12 @@ void JS_AddIntrinsicRegExp(JSContext *ctx)
                                    ctx->class_proto[JS_CLASS_REGEXP]);
     ctx->regexp_ctor = JS_DupValue(ctx, obj);
     JS_SetPropertyFunctionList(ctx, obj, js_regexp_funcs, countof(js_regexp_funcs));
+
+    ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR] =
+        JS_NewObjectProto(ctx, ctx->iterator_proto);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR],
+                               js_regexp_string_iterator_proto_funcs,
+                               countof(js_regexp_string_iterator_proto_funcs));
 }
 
 /* JSON */
@@ -42124,6 +42659,11 @@ static JSValue js_new_promise_capability(JSContext *ctx,
     return JS_EXCEPTION;
 }
 
+JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs)
+{
+    return js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
+}
+
 static JSValue js_promise_resolve(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv, int magic)
 {
@@ -42157,6 +42697,7 @@ static JSValue js_promise_resolve(JSContext *ctx, JSValueConst this_val,
     return result_promise;
 }
 
+#if 0
 static JSValue js_promise___newPromiseCapability(JSContext *ctx,
                                                  JSValueConst this_val,
                                                  int argc, JSValueConst *argv)
@@ -42181,6 +42722,7 @@ static JSValue js_promise___newPromiseCapability(JSContext *ctx,
     JS_DefinePropertyValue(ctx, obj, JS_ATOM_reject, resolving_funcs[1], JS_PROP_C_W_E);
     return obj;
 }
+#endif
 
 static __exception int remainingElementsCount_add(JSContext *ctx,
                                                   JSValueConst resolve_element_env,
@@ -42207,22 +42749,47 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
                                               int magic,
                                               JSValue *func_data)
 {
+    int is_allSettled = magic & 1;
+    int is_reject = magic & 2;
     BOOL alreadyCalled = JS_ToBool(ctx, func_data[0]);
     JSValueConst values = func_data[2];
     JSValueConst resolve = func_data[3];
     JSValueConst resolve_element_env = func_data[4];
-    JSValue ret;
+    JSValue ret, obj;
     int is_zero, index;
-
+    
     if (JS_ToInt32(ctx, &index, func_data[1]))
         return JS_EXCEPTION;
     if (alreadyCalled)
         return JS_UNDEFINED;
     func_data[0] = JS_NewBool(ctx, TRUE);
 
+    if (is_allSettled) {
+        JSValue str;
+        
+        obj = JS_NewObject(ctx);
+        if (JS_IsException(obj))
+            return JS_EXCEPTION;
+        str = JS_NewString(ctx, is_reject ? "rejected" : "fulfilled");
+        if (JS_IsException(str))
+            goto fail1;
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_status,
+                                   str,
+                                   JS_PROP_C_W_E) < 0)
+            goto fail1;
+        if (JS_DefinePropertyValue(ctx, obj,
+                                   is_reject ? JS_ATOM_reason : JS_ATOM_value,
+                                   JS_DupValue(ctx, argv[0]),
+                                   JS_PROP_C_W_E) < 0) {
+        fail1:
+            JS_FreeValue(ctx, obj);
+            return JS_EXCEPTION;
+        }
+    } else {
+        obj = JS_DupValue(ctx, argv[0]);
+    }
     if (JS_DefinePropertyValueUint32(ctx, values, index,
-                                     JS_DupValue(ctx, argv[0]),
-                                     JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
+                                     obj, JS_PROP_C_W_E) < 0)
         return JS_EXCEPTION;
     
     is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
@@ -42237,15 +42804,16 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     return JS_UNDEFINED;
 }
 
+/* magic = 0: Promise.all 1: Promise.allSettled */
 static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
+                              int argc, JSValueConst *argv, int magic)
 {
     JSValue result_promise, resolving_funcs[2], iter, item, next_promise, ret;
     JSValue next_method = JS_UNDEFINED, values = JS_UNDEFINED;
-    JSValue resolve_element_env = JS_UNDEFINED, resolve_element;
+    JSValue resolve_element_env = JS_UNDEFINED, resolve_element, reject_element;
     JSValue promise_resolve = JS_UNDEFINED;
     JSValueConst then_args[2], resolve_element_data[5];
-    BOOL done;
+    BOOL done, is_allSettled = magic;
     int index, is_zero;
     
     if (!JS_IsObject(this_val))
@@ -42309,22 +42877,36 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
             resolve_element_data[4] = resolve_element_env;
             resolve_element =
                 JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
-                                    0, 5, resolve_element_data);
+                                    is_allSettled, 5, resolve_element_data);
             if (JS_IsException(resolve_element)) {
                 JS_FreeValue(ctx, next_promise);
                 goto fail_reject1;
             }
             
+            if (is_allSettled) {
+                reject_element =
+                    JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
+                                        is_allSettled | 2, 5, resolve_element_data);
+                if (JS_IsException(reject_element)) {
+                    JS_FreeValue(ctx, next_promise);
+                    goto fail_reject1;
+                }
+            } else {
+                reject_element = JS_DupValue(ctx, resolving_funcs[1]);
+            }
+
             if (remainingElementsCount_add(ctx, resolve_element_env, 1) < 0) {
                 JS_FreeValue(ctx, next_promise);
                 JS_FreeValue(ctx, resolve_element);
+                JS_FreeValue(ctx, reject_element);
                 goto fail_reject1;
             }
 
             then_args[0] = resolve_element;
-            then_args[1] = resolving_funcs[1];
+            then_args[1] = reject_element;
             ret = JS_InvokeFree(ctx, next_promise, JS_ATOM_then, 2, then_args);
             JS_FreeValue(ctx, resolve_element);
+            JS_FreeValue(ctx, reject_element);
             if (check_exception_free(ctx, ret))
                 goto fail_reject1;
             index++;
@@ -42605,9 +43187,10 @@ static JSValue js_promise_finally(JSContext *ctx, JSValueConst this_val,
 static const JSCFunctionListEntry js_promise_funcs[] = {
     JS_CFUNC_MAGIC_DEF("resolve", 1, js_promise_resolve, 0 ),
     JS_CFUNC_MAGIC_DEF("reject", 1, js_promise_resolve, 1 ),
-    JS_CFUNC_DEF("all", 1, js_promise_all ),
+    JS_CFUNC_MAGIC_DEF("all", 1, js_promise_all, 0 ),
+    JS_CFUNC_MAGIC_DEF("allSettled", 1, js_promise_all, 1 ),
     JS_CFUNC_DEF("race", 1, js_promise_race ),
-    JS_CFUNC_DEF("__newPromiseCapability", 1, js_promise___newPromiseCapability ),
+    //JS_CFUNC_DEF("__newPromiseCapability", 1, js_promise___newPromiseCapability ),
     JS_CGETSET_DEF("[Symbol.species]", js_get_this, NULL),
 };
 
@@ -42682,7 +43265,7 @@ static void js_async_from_sync_iterator_mark(JSRuntime *rt, JSValueConst val,
 static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
                                               JSValueConst sync_iter)
 {
-    JSValue async_iter, ret, next_method;
+    JSValue async_iter, next_method;
     JSAsyncFromSyncIteratorData *s;
 
     next_method = JS_GetProperty(ctx, sync_iter, JS_ATOM_next);
@@ -42702,10 +43285,7 @@ static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
     s->sync_iter = JS_DupValue(ctx, sync_iter);
     s->next_method = next_method;
     JS_SetOpaque(async_iter, s);
-
-    ret = JS_GetIterator(ctx, async_iter, TRUE);
-    JS_FreeValue(ctx, async_iter);
-    return ret;
+    return async_iter;
 }
 
 static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst this_val,
@@ -42717,7 +43297,7 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
     int done;
     int is_reject;
 
-    promise = js_new_promise_capability(ctx, resolving_funcs, JS_UNDEFINED);
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
     if (JS_IsException(promise))
         return JS_EXCEPTION;
     s = JS_GetOpaque(this_val, JS_CLASS_ASYNC_FROM_SYNC_ITERATOR);
@@ -42772,24 +43352,15 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
         return promise;
     }
     {
-        JSValue value_wrapper_resolving_funcs[2], value_wrapper_promise;
-        JSValue resolve_reject[2], ret;
+        JSValue value_wrapper_promise, resolve_reject[2];
         int res;
 
-        value_wrapper_promise =
-            js_new_promise_capability(ctx, value_wrapper_resolving_funcs, JS_UNDEFINED);
-        if (JS_IsException(value_wrapper_promise))
-            goto fail;
-
-        ret = JS_Call(ctx, value_wrapper_resolving_funcs[0], JS_UNDEFINED, 1,
-                      (JSValueConst *)&value);
-        JS_FreeValue(ctx, value_wrapper_resolving_funcs[0]);
-        JS_FreeValue(ctx, value_wrapper_resolving_funcs[1]);
-        if (JS_IsException(ret)) {
-            JS_FreeValue(ctx, value_wrapper_promise);
-            goto fail;
+        value_wrapper_promise = js_promise_resolve(ctx, ctx->promise_ctor,
+                                                   1, (JSValueConst *)&value, 0);
+        if (JS_IsException(value_wrapper_promise)) {
+            JS_FreeValue(ctx, value);
+            goto reject;
         }
-        JS_FreeValue(ctx, ret);
 
         resolve_reject[0] = js_async_from_async_iterator_unwrap_func_create(ctx, value, done);
         if (JS_IsException(resolve_reject[0])) {
@@ -42821,7 +43392,6 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
 }
 
 static const JSCFunctionListEntry js_async_from_sync_iterator_proto_funcs[] = {
-    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "Async-from-Sync Iterator", JS_PROP_CONFIGURABLE ),
     JS_CFUNC_MAGIC_DEF("next", 1, js_async_from_sync_iterator_next, GEN_MAGIC_NEXT ),
     JS_CFUNC_MAGIC_DEF("return", 1, js_async_from_sync_iterator_next, GEN_MAGIC_RETURN ),
     JS_CFUNC_MAGIC_DEF("throw", 1, js_async_from_sync_iterator_next, GEN_MAGIC_THROW ),
@@ -42877,6 +43447,7 @@ void JS_AddIntrinsicPromise(JSContext *ctx)
                                countof(js_promise_proto_funcs));
     obj1 = JS_NewCFunction2(ctx, js_promise_constructor, "Promise", 1,
                             JS_CFUNC_constructor, 0);
+    ctx->promise_ctor = JS_DupValue(ctx, obj1);
     JS_SetPropertyFunctionList(ctx, obj1,
                                js_promise_funcs,
                                countof(js_promise_funcs));
@@ -47428,7 +47999,7 @@ typedef enum AtomicsOpEnum {
 static void *js_atomics_get_ptr(JSContext *ctx,
                                 int *psize_log2, JSClassID *pclass_id,
                                 JSValueConst obj, JSValueConst idx_val,
-                                BOOL is_int32_array)
+                                BOOL is_waitable)
 {
     JSObject *p;
     JSTypedArray *ta;
@@ -47441,11 +48012,20 @@ static void *js_atomics_get_ptr(JSContext *ctx,
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         goto fail;
     p = JS_VALUE_GET_OBJ(obj);
-    if (is_int32_array)
+#ifdef CONFIG_BIGNUM
+    if (is_waitable)
+        err = (p->class_id != JS_CLASS_INT32_ARRAY &&
+               p->class_id != JS_CLASS_BIG_INT64_ARRAY);
+    else
+        err = !(p->class_id >= JS_CLASS_INT8_ARRAY &&
+                p->class_id <= JS_CLASS_BIG_UINT64_ARRAY);
+#else
+    if (is_waitable)
         err = (p->class_id != JS_CLASS_INT32_ARRAY);
     else
         err = !(p->class_id >= JS_CLASS_INT8_ARRAY &&
                 p->class_id <= JS_CLASS_UINT32_ARRAY);
+#endif
     if (err) {
     fail:
         JS_ThrowTypeError(ctx, "integer TypedArray expected");
@@ -47478,7 +48058,11 @@ static JSValue js_atomics_op(JSContext *ctx,
                              int argc, JSValueConst *argv, int op)
 {
     int size_log2;
+#ifdef CONFIG_BIGNUM
+    uint64_t v, a, rep_val;
+#else
     uint32_t v, a, rep_val;
+#endif
     void *ptr;
     JSValue ret;
     JSClassID class_id;
@@ -47490,16 +48074,34 @@ static JSValue js_atomics_op(JSContext *ctx,
     rep_val = 0;
     if (op == ATOMICS_OP_LOAD) {
         v = 0;
-    } else {
-        if (JS_ToUint32(ctx, &v, argv[2]))
-            return JS_EXCEPTION;
-        if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
-            if (JS_ToUint32(ctx, &rep_val, argv[3]))
+    } else
+#ifdef CONFIG_BIGNUM
+   if (size_log2 == 3) {
+            int64_t v64;
+            if (JS_ToBigInt64(ctx, &v64, argv[2]))
                 return JS_EXCEPTION;
-        }
-    }
-    switch(op | (size_log2 << 3)) {
-
+            v = v64;
+            if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
+                if (JS_ToBigInt64(ctx, &v64, argv[3]))
+                    return JS_EXCEPTION;
+                rep_val = v64;
+            }
+   } else
+#endif
+   {
+       uint32_t v32;
+       if (JS_ToUint32(ctx, &v32, argv[2]))
+           return JS_EXCEPTION;
+       v = v32;
+       if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
+           if (JS_ToUint32(ctx, &v32, argv[3]))
+               return JS_EXCEPTION;
+           rep_val = v32;
+       }
+   }
+   switch(op | (size_log2 << 3)) {
+            
+#ifdef CONFIG_BIGNUM
 #define OP(op_name, func_name)                          \
     case ATOMICS_OP_ ## op_name | (0 << 3):             \
        a = func_name((_Atomic(uint8_t) *)ptr, v);       \
@@ -47509,8 +48111,22 @@ static JSValue js_atomics_op(JSContext *ctx,
         break;                                          \
     case ATOMICS_OP_ ## op_name | (2 << 3):             \
         a = func_name((_Atomic(uint32_t) *)ptr, v);     \
+        break;                                          \
+    case ATOMICS_OP_ ## op_name | (3 << 3):             \
+        a = func_name((_Atomic(uint64_t) *)ptr, v);     \
         break;
-
+#else
+#define OP(op_name, func_name)                          \
+    case ATOMICS_OP_ ## op_name | (0 << 3):             \
+       a = func_name((_Atomic(uint8_t) *)ptr, v);       \
+       break;                                           \
+    case ATOMICS_OP_ ## op_name | (1 << 3):             \
+        a = func_name((_Atomic(uint16_t) *)ptr, v);     \
+        break;                                          \
+    case ATOMICS_OP_ ## op_name | (2 << 3):             \
+        a = func_name((_Atomic(uint32_t) *)ptr, v);     \
+        break;
+#endif
         OP(ADD, atomic_fetch_add)
         OP(AND, atomic_fetch_and)
         OP(OR, atomic_fetch_or)
@@ -47528,7 +48144,12 @@ static JSValue js_atomics_op(JSContext *ctx,
     case ATOMICS_OP_LOAD | (2 << 3):
         a = atomic_load((_Atomic(uint32_t) *)ptr);
         break;
-
+#ifdef CONFIG_BIGNUM
+    case ATOMICS_OP_LOAD | (3 << 3):
+        a = atomic_load((_Atomic(uint64_t) *)ptr);
+        break;
+#endif
+        
     case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
         {
             uint8_t v1 = v;
@@ -47550,9 +48171,19 @@ static JSValue js_atomics_op(JSContext *ctx,
             a = v1;
         }
         break;
+#ifdef CONFIG_BIGNUM
+    case ATOMICS_OP_COMPARE_EXCHANGE | (3 << 3):
+        {
+            uint64_t v1 = v;
+            atomic_compare_exchange_strong((_Atomic(uint64_t) *)ptr, &v1, rep_val);
+            a = v1;
+        }
+        break;
+#endif
     default:
         abort();
     }
+
     switch(class_id) {
     case JS_CLASS_INT8_ARRAY:
         a = (int8_t)a;
@@ -47573,6 +48204,14 @@ static JSValue js_atomics_op(JSContext *ctx,
     case JS_CLASS_UINT32_ARRAY:
         ret = JS_NewUint32(ctx, a);
         break;
+#ifdef CONFIG_BIGNUM
+    case JS_CLASS_BIG_INT64_ARRAY:
+        ret = JS_NewBigInt64(ctx, a);
+        break;
+    case JS_CLASS_BIG_UINT64_ARRAY:
+        ret = JS_NewBigUint64(ctx, a);
+        break;
+#endif
     default:
         abort();
     }
@@ -47584,33 +48223,48 @@ static JSValue js_atomics_store(JSContext *ctx,
                                 int argc, JSValueConst *argv)
 {
     int size_log2;
-    uint32_t v;
     void *ptr;
     JSValue ret;
 
     ptr = js_atomics_get_ptr(ctx, &size_log2, NULL, argv[0], argv[1], FALSE);
     if (!ptr)
         return JS_EXCEPTION;
-    /* XXX: spec, would be simpler to return the written value */
-    ret = JS_ToIntegerFree(ctx, JS_DupValue(ctx, argv[2]));
-    if (JS_IsException(ret))
-        return ret;
-    if (JS_ToUint32(ctx, &v, ret)) {
-        JS_FreeValue(ctx, ret);
-        return JS_EXCEPTION;
-    }
-    switch(size_log2) {
-    case 0:
-        atomic_store((_Atomic(uint8_t) *)ptr, v);
-        break;
-    case 1:
-        atomic_store((_Atomic(uint16_t) *)ptr, v);
-        break;
-    case 2:
-        atomic_store((_Atomic(uint32_t) *)ptr, v);
-        break;
-    default:
-        abort();
+#ifdef CONFIG_BIGNUM
+    if (size_log2 == 3) {
+        int64_t v64;
+        ret = JS_ToBigIntValueFree(ctx, JS_DupValue(ctx, argv[2]));
+        if (JS_IsException(ret))
+            return ret;
+        if (JS_ToBigInt64(ctx, &v64, ret)) {
+            JS_FreeValue(ctx, ret);
+            return JS_EXCEPTION;
+        }
+        atomic_store((_Atomic(uint64_t) *)ptr, v64);
+    } else
+#endif
+    {
+        uint32_t v;
+        /* XXX: spec, would be simpler to return the written value */
+        ret = JS_ToIntegerFree(ctx, JS_DupValue(ctx, argv[2]));
+        if (JS_IsException(ret))
+            return ret;
+        if (JS_ToUint32(ctx, &v, ret)) {
+            JS_FreeValue(ctx, ret);
+            return JS_EXCEPTION;
+        }
+        switch(size_log2) {
+        case 0:
+            atomic_store((_Atomic(uint8_t) *)ptr, v);
+            break;
+        case 1:
+            atomic_store((_Atomic(uint16_t) *)ptr, v);
+            break;
+        case 2:
+            atomic_store((_Atomic(uint32_t) *)ptr, v);
+            break;
+        default:
+            abort();
+        }
     }
     return ret;
 }
@@ -47622,7 +48276,11 @@ static JSValue js_atomics_isLockFree(JSContext *ctx,
     int v, ret;
     if (JS_ToInt32Sat(ctx, &v, argv[0]))
         return JS_EXCEPTION;
-    ret = (v == 1 || v == 2 || v == 4);
+    ret = (v == 1 || v == 2 || v == 4
+#ifdef CONFIG_BIGNUM
+           || v == 8
+#endif
+           );
     return JS_NewBool(ctx, ret);
 }
 
@@ -47641,18 +48299,29 @@ static JSValue js_atomics_wait(JSContext *ctx,
                                JSValueConst this_obj,
                                int argc, JSValueConst *argv)
 {
-    int32_t v, *ptr;
+    int64_t v;
+    int32_t v32;
+    void *ptr;
     int64_t timeout;
     struct timespec ts;
     JSAtomicsWaiter waiter_s, *waiter;
-    int ret;
+    int ret, size_log2, res;
     double d;
 
-    ptr = js_atomics_get_ptr(ctx, NULL, NULL, argv[0], argv[1], TRUE);
+    ptr = js_atomics_get_ptr(ctx, &size_log2, NULL, argv[0], argv[1], TRUE);
     if (!ptr)
         return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &v, argv[2]))
-        return JS_EXCEPTION;
+#ifdef CONFIG_BIGNUM
+    if (size_log2 == 3) {
+        if (JS_ToBigInt64(ctx, &v, argv[2]))
+            return JS_EXCEPTION;
+    } else
+#endif
+    {        
+        if (JS_ToInt32(ctx, &v32, argv[2]))
+            return JS_EXCEPTION;
+        v = v32;
+    }
     if (JS_ToFloat64(ctx, &d, argv[3]))
         return JS_EXCEPTION;
     if (isnan(d) || d > INT64_MAX)
@@ -47668,7 +48337,12 @@ static JSValue js_atomics_wait(JSContext *ctx,
        'ptr' value */
     /* XXX: use Linux futexes when available ? */
     pthread_mutex_lock(&js_atomics_mutex);
-    if (*ptr != v) {
+    if (size_log2 == 3) {
+        res = *(int64_t *)ptr != v;
+    } else {
+        res = *(int32_t *)ptr != v;
+    }
+    if (res) {
         pthread_mutex_unlock(&js_atomics_mutex);
         return JS_AtomToString(ctx, JS_ATOM_not_equal);
     }
@@ -47710,7 +48384,8 @@ static JSValue js_atomics_notify(JSContext *ctx,
                                  int argc, JSValueConst *argv)
 {
     struct list_head *el, *el1, waiter_list;
-    int32_t count, n, *ptr;
+    int32_t count, n;
+    void *ptr;
     JSAtomicsWaiter *waiter;
 
     ptr = js_atomics_get_ptr(ctx, NULL, NULL, argv[0], argv[1], TRUE);
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 4cb62b5f8a..6b863be360 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -278,7 +278,6 @@ static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
 #define JS_EVAL_TYPE_INDIRECT (3 << 0) /* indirect call (internal use) */
 #define JS_EVAL_TYPE_MASK     (3 << 0)
 
-#define JS_EVAL_FLAG_SHEBANG  (1 << 2) /* skip first line beginning with '#!' */
 #define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
 #define JS_EVAL_FLAG_STRIP    (1 << 4) /* force 'strip' mode */
 #define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5) /* internal use */
@@ -704,6 +703,8 @@ JSValue JS_NewArrayBufferCopy(JSContext *ctx, const uint8_t *buf, size_t len);
 void JS_DetachArrayBuffer(JSContext *ctx, JSValueConst obj);
 uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValueConst obj);
 
+JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
+
 /* return != 0 if the JS code needs to be interrupted */
 typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);

From b4f7f0a49da95e89eab5bcef8c13bdb9d944abbf Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 30 Jul 2019 16:06:48 +0000
Subject: [PATCH 009/185] support const class member functions

---
 main.cpp      | 12 ++++--------
 quickjspp.hpp | 12 ++++++++++++
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/main.cpp b/main.cpp
index 8618f5af5d..46445b404d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -8,10 +8,6 @@
 #include <cstring>
 #include <ctime>
 
-int32_t f(int32_t x)
-{
-    return x * x;
-};
 
 #define TYPES bool, int32_t, double, std::shared_ptr<test>, const std::shared_ptr<test>&, std::string, const std::string&
 
@@ -19,7 +15,7 @@ class test
 {
 public:
     bool b;
-    int32_t i;
+    mutable int32_t i;
     double d;
     std::shared_ptr<test> spt;
     std::string s;
@@ -35,9 +31,9 @@ class test
     ~test()
     { printf("dtor!\n"); }
 
-    int32_t fi(TYPES) { i++; return i; }
-    bool fb(TYPES) { i++; return b; }
-    double fd(TYPES) { i++; return d; }
+    int32_t fi(TYPES) const { i++; return i; }
+    bool fb(TYPES) noexcept { i++; return b; }
+    double fd(TYPES) const noexcept { i++; return d; }
     const std::shared_ptr<test>& fspt(TYPES) { i++; return spt; }
     const std::string& fs(TYPES) { i++; return s; }
     void f(TYPES) { i++; }
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 6b25e3f697..b7f63da42a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -319,6 +319,18 @@ namespace qjs {
             }
         };
 
+        template <typename R, class T, typename... Args, R (T::*F)(Args...) const>
+        struct js_traits<fwrapper<F>>
+        {
+            static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
+            {
+                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                               JSValueConst * argv) noexcept -> JSValue {
+                    return wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+                }, fw.name, sizeof...(Args));
+
+            }
+        };
 
         // class constructor
 

From f9b1acfb9bfd250192f6efe5613dead074278ec4 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 5 Aug 2019 13:04:42 +0300
Subject: [PATCH 010/185] dont define setter for const class member variable

---
 main.cpp      |  2 +-
 quickjspp.hpp | 36 ++++++++++++++++++++++++++----------
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/main.cpp b/main.cpp
index 46445b404d..002c340f25 100644
--- a/main.cpp
+++ b/main.cpp
@@ -16,7 +16,7 @@ class test
 public:
     bool b;
     mutable int32_t i;
-    double d;
+    const double d = 7.;
     std::shared_ptr<test> spt;
     std::string s;
 
diff --git a/quickjspp.hpp b/quickjspp.hpp
index b7f63da42a..8ac6cac051 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -5,13 +5,15 @@ extern "C" {
 #include "quickjs/quickjs-libc.h"
 }
 
-#include <algorithm>
-#include <tuple>
-#include <functional>
-#include <unordered_map>
+#include <vector>
+#include <string_view>
+#include <string>
 #include <cassert>
 #include <memory>
 #include <cstddef>
+#include <algorithm>
+#include <tuple>
+#include <functional>
 
 namespace qjs {
 
@@ -547,6 +549,8 @@ namespace qjs {
         template <class T, typename R, R T::*M>
         struct get_set<M>
         {
+            using is_const = std::is_const<R>;
+
             static const R& get(const std::shared_ptr<T>& ptr)
             {
                 return *ptr.*M;
@@ -643,12 +647,24 @@ namespace qjs {
         {
             auto prop = JS_NewAtom(ctx, name);
             using fgetter = detail::fwrapper<detail::get_set<M>::get, true>;
-            using fsetter = detail::fwrapper<detail::get_set<M>::set, true>;
-            int ret = JS_DefinePropertyGetSet(ctx, v, prop,
-                                    detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
-                                    detail::js_traits<fsetter>::wrap(ctx, fsetter{name}),
-                                    JS_PROP_WRITABLE // ?
-                    );
+            int ret;
+            if constexpr (detail::get_set<M>::is_const::value)
+            {
+                ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                              detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                              JS_UNDEFINED,
+                                              0 // ?
+                );
+            }
+            else
+            {
+                using fsetter = detail::fwrapper<detail::get_set<M>::set, true>;
+                ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                              detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                              detail::js_traits<fsetter>::wrap(ctx, fsetter{name}),
+                                              JS_PROP_WRITABLE // ?
+                );
+            }
             JS_FreeAtom(ctx, prop);
             if(ret < 0)
                 throw detail::exception{};

From cf61b2c735c53ae440fb59053cdff8372cb2ca0a Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 10 Aug 2019 13:33:44 +0300
Subject: [PATCH 011/185] fix crash if added module is not loaded

---
 quickjspp.hpp | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 8ac6cac051..aefdc72864 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -701,7 +701,7 @@ namespace qjs {
     public:
         JSContext * ctx;
 
-    private:
+    //private:
         class Module
         {
             friend class Context;
@@ -710,7 +710,7 @@ namespace qjs {
             JSContext * ctx;
             const char * name;
 
-            using nvp = std::pair<const char *, JSValue>;
+            using nvp = std::pair<const char *, Value>;
             std::vector<nvp, allocator<nvp>> exports;
         public:
             Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
@@ -719,13 +719,13 @@ namespace qjs {
                     auto context = reinterpret_cast<Context *>(JS_GetContextOpaque(ctx));
                     if(!context)
                         return -1;
-                    auto it = std::find_if(context->modules.cbegin(), context->modules.cend(),
+                    auto it = std::find_if(context->modules.begin(), context->modules.end(),
                                            [m](const Module& module) { return module.m == m; });
                     if(it == context->modules.end())
                         return -1;
                     for(const auto& e : it->exports)
                     {
-                        if(JS_SetModuleExport(ctx, m, e.first, e.second) != 0)
+                        if(JS_SetModuleExport(ctx, m, e.first, JS_DupValue(ctx, e.second.v)) != 0)
                             return -1;
                     }
                     return 0;
@@ -736,14 +736,17 @@ namespace qjs {
 
             Module& add(const char * name, JSValue value)
             {
-                exports.push_back({name, value});
+                exports.push_back({name, {ctx, value}});
                 JS_AddModuleExport(ctx, m, name);
                 return *this;
             }
 
             Module& add(const char * name, Value value)
             {
-                return add(name, value.release());
+                assert(value.ctx == ctx);
+                exports.push_back({name, std::move(value)});
+                JS_AddModuleExport(ctx, m, name);
+                return *this;
             }
 
             template <typename T>
@@ -785,6 +788,7 @@ namespace qjs {
 
         ~Context()
         {
+            modules.clear();
             JS_FreeContext(ctx);
         }
 

From f3f4d6a41a1df489dfc24a19391bfad236f99f1e Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 10 Aug 2019 10:37:54 +0000
Subject: [PATCH 012/185] add class and function register helpers to module

---
 quickjspp.hpp | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index aefdc72864..cf51a621d2 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -758,6 +758,75 @@ namespace qjs {
             Module(const Module&) = delete;
             Module(Module&&)  = default;
             //Module& operator=(Module&&) = default;
+
+
+            // function wrappers
+            template <auto F>
+            Module& function(const char * name)
+            {
+                return add(name, qjs::detail::fwrapper<F>{name});
+            }
+            template <typename F>
+            Module& function(const char * name, F&& f)
+            {
+                return add(name, detail::js_traits<decltype(std::function{std::forward<F>(f)})>::wrap(std::forward<F>(f)));
+            }
+
+            // class register wrapper
+        private:
+            template <class T>
+            class class_registrar
+            {
+                const char * name;
+                qjs::Value prototype;
+                qjs::Context::Module& module;
+                qjs::Context& context;
+            public:
+                explicit class_registrar(const char * name, qjs::Context::Module& module, qjs::Context& context) :
+                        name(name),
+                        prototype(context.newObject()),
+                        module(module),
+                        context(context)
+                {
+                }
+
+                class_registrar(const class_registrar&) = delete;
+
+                template <typename F>
+                class_registrar& fun(const char * name, F&& f)
+                {
+                    prototype.add(name, std::forward<F>(f));
+                    return *this;
+                }
+
+                template <auto F>
+                class_registrar& fun(const char * name)
+                {
+                    prototype.add<F>(name);
+                    return *this;
+                }
+
+                template <typename... Args>
+                class_registrar& constructor(const char * name = nullptr)
+                {
+                    if(!name)
+                        name = this->name;
+                    module.add(name, qjs::detail::ctor_wrapper<T, Args...>{name});
+                    return *this;
+                }
+
+                ~class_registrar()
+                {
+                    context.registerClass<T>(name, std::move(prototype));
+                }
+            };
+        public:
+            template <class T>
+            class_registrar<T> class_(const char * name)
+            {
+                return class_registrar<T>{name, *this, *reinterpret_cast<qjs::Context *>(JS_GetContextOpaque(ctx))};
+            }
+
         };
 
         std::vector<Module, allocator<Module>> modules;

From 8908c0a474e493ce77b71a5cae465246290d7378 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 10 Aug 2019 13:39:17 +0300
Subject: [PATCH 013/185] T * wrappers

---
 quickjspp.hpp | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index cf51a621d2..e91196022e 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -413,6 +413,37 @@ namespace qjs {
             }
         };
 
+        // T * - non-owning pointer
+        template <class T>
+        struct js_traits<T *>
+        {
+            static JSValue wrap(JSContext * ctx, T * ptr)
+            {
+                if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
+                    throw exception{};
+                auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
+                if(JS_IsException(jsobj))
+                {
+                    return jsobj;
+                }
+                //auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
+                auto alloc = allocator<std::shared_ptr<T>>{ctx};
+                using atraits = std::allocator_traits<decltype(alloc)>;
+                auto pptr = atraits::allocate(alloc, 1);
+                atraits::construct(alloc, pptr, ptr, [](T *){}); // shared_ptr with empty deleter
+
+                JS_SetOpaque(jsobj, pptr);
+                return jsobj;
+            }
+
+            static T * unwrap(JSContext * ctx, JSValueConst v)
+            {
+                auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, js_traits<std::shared_ptr<T>>::QJSClassId));
+                if(!ptr)
+                    throw exception{};
+                return ptr->get();
+            }
+        };
 
 
         struct function // std::function replacement

From 8d3f0883cfe5d065eb2dea9b9e69a2ffbb431d78 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 10 Aug 2019 19:19:57 +0300
Subject: [PATCH 014/185] update glue code

---
 main.cpp      | 92 ++++++++++++++++++++++++++++-----------------------
 quickjspp.hpp | 14 ++++++++
 2 files changed, 65 insertions(+), 41 deletions(-)

diff --git a/main.cpp b/main.cpp
index 002c340f25..a0417d3646 100644
--- a/main.cpp
+++ b/main.cpp
@@ -11,12 +11,24 @@
 
 #define TYPES bool, int32_t, double, std::shared_ptr<test>, const std::shared_ptr<test>&, std::string, const std::string&
 
-class test
+class base_test
+{
+public:
+    double base_field;
+
+    double base_method(double x)
+    {
+        std::swap(x, base_field);
+        return x;
+    }
+};
+
+class test : public base_test
 {
 public:
     bool b;
     mutable int32_t i;
-    const double d = 7.;
+    double d = 7.;
     std::shared_ptr<test> spt;
     std::string s;
 
@@ -44,7 +56,33 @@ class test
 
 void f(TYPES) {}
 
-
+void qjs_glue(qjs::Context::Module& m) {
+    m.function<&::f>("f"); // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+    m.class_<::base_test>("base_test")
+                    // implicit: .constructor<::base_test const &>()
+                    // implicit: .constructor<>()
+            .fun<&::base_test::base_method>("base_method") // (double)
+            .fun<&::base_test::base_field>("base_field") // double
+            ;
+
+    m.class_<::test>("test")
+            //.base<::base_test>()
+            .constructor<::int32_t, bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &>("Test")
+            .constructor<::int32_t>("TestSimple")
+            .fun<&::test::fi>("fi") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+            .fun<&::test::fb>("fb") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+            .fun<&::test::fd>("fd") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+            .fun<&::test::fspt>("fspt") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const&, ::std::string, ::std::string const &)
+            .fun<&::test::fs>("fs") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+            .fun<&::test::f>("f") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
+            .fun<&::test::fstatic>("fstatic") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test>const &, ::std::string, ::std::string const &)
+            .fun<&::test::b>("b") // bool
+            .fun<&::test::i>("i") // ::int32_t
+            .fun<&::test::d>("d") // double
+            .fun<&::test::spt>("spt") // ::std::shared_ptr<test>
+            .fun<&::test::s>("s") // ::std::string
+            ;
+} // qjs_glue
 int main(int argc, char ** argv)
 {
     JSRuntime * rt;
@@ -57,38 +95,7 @@ int main(int argc, char ** argv)
     Context context(runtime);
     ctx = context.ctx;
 
-    {
-        auto obj = context.newObject();
-        obj["vi"] = 54;
-        obj["vb"] = true;
-        obj["vd"] = 56.0;
-        obj["vs"] = std::string{"test string"};
-        obj.add("lambda", [](int x) -> int { return x * x; });
-
-        obj.add<&test::fi>("fi");
-        obj.add<&test::fb>("fb");
-        obj.add<&test::fd>("fd");
-        obj.add<&test::fs>("fs");
-        obj.add<&test::fspt>("fspt");
-        obj.add<&test::f>("f");
-        obj.add<&test::fstatic>("fstatic");
-
-        obj.add<&test::i>("i");
-        obj.add<&test::b>("b");
-        obj.add<&test::d>("d");
-        obj.add<&test::s>("s");
-        obj.add<&test::spt>("spt");
-
-        context.registerClass<test>("test_class", std::move(obj));
-    }
-
-
-    context.addModule("test")
-            //.add("obj", obj)
-            .add("Test", detail::ctor_wrapper<test, int32_t, TYPES>{"Test"})
-    .add("TestSimple", detail::ctor_wrapper<test, int32_t>{"TestSimple"});
-
-
+    qjs_glue(context.addModule("test"));
 
 
     /* loader for ES6 modules */
@@ -109,28 +116,31 @@ int main(int argc, char ** argv)
     context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
     const char * filename = argv[1];
 
+    try
     {
-        auto xxx = context.eval("var t = new test.TestSimple(12);"
+        auto xxx = context.eval("\"use strict\";"
+                                "var t = new test.TestSimple(12);"
                                 "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"
                                 "q.b = true;"
                                 "q.d = 456.789;"
                                 "q.s = \"STRING\";"
                                 "q.spt = t;"
+                                //"q.base_field = 105.5;"
                                 "console.log(q.b === q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
                                 "console.log(q.d === q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
                                 "console.log(q.s === q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs));"
+                                //"console.log(105.5 === q.base_method(5.1));"
+                                //"console.log(5.1 === q.base_field);"
                                 "console.log(q.spt === q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));" // false
                                 "q.fi(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
         assert(xxx.cast<int>() == 18);
         auto yyy = context.eval("q.fi.bind(t)(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
         assert(yyy.cast<int>() == 13);
-    }
-    try
-    {
+
         auto f = context.eval("q.fi.bind(q)").cast<std::function<int32_t(TYPES)>>();
-        int xxx = f(false, 1, 0., context.eval("q").cast<std::shared_ptr<test>>(),
+        int zzz = f(false, 1, 0., context.eval("q").cast<std::shared_ptr<test>>(),
                     context.eval("t").cast<std::shared_ptr<test>>(), "test string", std::string{"test"});
-        assert(xxx == 19);
+        assert(zzz == 19);
     }
     catch(detail::exception)
     {
diff --git a/quickjspp.hpp b/quickjspp.hpp
index e91196022e..3081eea4b6 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -846,6 +846,20 @@ namespace qjs {
                     return *this;
                 }
 
+                /* TODO: needs casting to base class
+                template <class B>
+                class_registrar& base()
+                {
+                    assert(detail::js_traits<std::shared_ptr<B>>::QJSClassId && "base class is not registered");
+                    auto base_proto = JS_GetClassProto(context.ctx, detail::js_traits<std::shared_ptr<B>>::QJSClassId);
+                    int err = JS_SetPrototype(context.ctx, prototype.v, base_proto);
+                    JS_FreeValue(context.ctx, base_proto);
+                    if(err < 0)
+                        throw detail::exception{};
+                    return *this;
+                }
+                 */
+
                 ~class_registrar()
                 {
                     context.registerClass<T>(name, std::move(prototype));

From 322442258c7b6d88f27faec0db6451dea11262cc Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 10 Aug 2019 19:21:28 +0300
Subject: [PATCH 015/185] add simple bindings generator based on pygccxml

---
 binding-generator/generator.py | 120 +++++++++++++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 binding-generator/generator.py

diff --git a/binding-generator/generator.py b/binding-generator/generator.py
new file mode 100644
index 0000000000..9bb74721c4
--- /dev/null
+++ b/binding-generator/generator.py
@@ -0,0 +1,120 @@
+
+# python3 generator.py -std=c++1z ../main.cpp
+# python3, castxml and pygccxml should be installed
+
+import os
+import sys
+
+# Find out the file location within the sources tree
+this_module_dir_path = os.path.abspath(
+    os.path.dirname(sys.modules[__name__].__file__))
+# Add pygccxml package to Python path
+#sys.path.append(os.path.join(this_module_dir_path, '..', '..'))
+
+
+from pygccxml import parser  # nopep8
+from pygccxml import declarations  # nopep8
+from pygccxml import utils  # nopep8
+
+# Find out the xml generator (gccxml or castxml)
+generator_path, generator_name = utils.find_xml_generator()
+
+flags = filter(lambda x: x.startswith("-"), sys.argv[1:])
+
+# Configure the xml generator
+config = parser.xml_generator_configuration_t(
+    xml_generator_path=generator_path,
+    xml_generator=generator_name,
+    cflags=" ".join(flags),
+   # start_with_declarations="test",
+   #compiler="gcc",
+)
+
+# Parsing source file
+
+filenames = list(filter(lambda x: not x.startswith("-"), sys.argv[1:]))
+full_filenames =  [os.path.abspath(filename) for filename in filenames ]
+
+decls = parser.parse(full_filenames, 
+                     config,
+                     compilation_mode=parser.COMPILATION_MODE.ALL_AT_ONCE 
+
+)
+global_ns = declarations.get_global_namespace(decls)
+
+write_hdrs = True
+
+if write_hdrs:
+    for filename in filenames:
+        print('#include "%s"' % filename)
+
+
+def get_prefix(member, duplicates):
+    p = []
+    try:
+        if member.name in duplicates:
+            p.append("overload")
+        if member.is_artificial:
+            p.append("implicit")
+        if member.access_type != "public":
+            p.append(member.access_type)
+    except AttributeError:
+        pass
+    if p == []:
+        duplicates.append(member.name)
+        return ""
+    return "// " + ", ".join(p) + ": "
+
+
+def get_arg_types(fn):
+    return ", ".join([x.decl_string for x in fn.argument_types])
+
+def get_addr(fn):
+    #return "static_cast<" + fn.decl_string + ">(&" + declarations.declaration_utils.full_name(fn) + ")"
+    return "&" + declarations.declaration_utils.full_name(fn)
+
+
+
+write_fn = True
+
+if write_fn:
+    print('void qjs_glue(qjs::Context::Module& m) {')
+
+dump_all = False
+
+# print free functions
+free_dups = []
+for fn in global_ns.free_functions(allow_empty=True):
+    if not dump_all and not fn.location.file_name in full_filenames:
+        continue
+
+    print('%sm.function<%s>("%s"); // (%s)' % (get_prefix(fn, free_dups), get_addr(fn), fn.name, get_arg_types(fn)))
+
+
+visited = []
+
+def dump_class(class_):
+    if class_ in visited:
+        return
+    visited.append(class_)
+    duplicates = []
+    print('m.class_<%s>("%s")' % (declarations.declaration_utils.full_name(class_), class_.name))
+    # print('\tbase classes   : ', repr([
+    for base in class_.bases:
+        print('\t//.base<%s>()' % declarations.declaration_utils.full_name(base.related_class));
+    for fn in class_.constructors(allow_empty=True):
+        print('\t%s.constructor<%s>()' % (get_prefix(fn, duplicates), get_arg_types(fn)))
+    for fn in class_.member_functions(allow_empty=True):
+        print('\t%s.fun<%s>("%s") // (%s)' % (get_prefix(fn, duplicates), get_addr(fn), fn.name, get_arg_types(fn)))
+    for fn in class_.variables(allow_empty=True):
+        print('\t%s.fun<%s>("%s") // %s' % (get_prefix(fn, duplicates), get_addr(fn), fn.name, fn.decl_type.decl_string))
+    print(';\n')
+    
+# Print all classes
+for class_ in global_ns.classes():
+    if not dump_all and not class_.location.file_name in full_filenames:
+        continue
+    dump_class(class_)
+
+if write_fn:
+    print('} // qjs_glue')

From 228130c463cf2679ba35a81f0e5607c2a275b7fa Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Aug 2019 17:06:34 +0300
Subject: [PATCH 016/185] std::vector support

---
 main.cpp      | 13 +++++++++----
 quickjspp.hpp | 31 +++++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/main.cpp b/main.cpp
index a0417d3646..61f26b0a6f 100644
--- a/main.cpp
+++ b/main.cpp
@@ -14,11 +14,11 @@
 class base_test
 {
 public:
-    double base_field;
+    std::vector<std::vector<int>> base_field;
 
-    double base_method(double x)
+    int base_method(int x)
     {
-        std::swap(x, base_field);
+        std::swap(x, base_field[0][0]);
         return x;
     }
 };
@@ -60,7 +60,7 @@ void qjs_glue(qjs::Context::Module& m) {
     m.function<&::f>("f"); // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
     m.class_<::base_test>("base_test")
                     // implicit: .constructor<::base_test const &>()
-                    // implicit: .constructor<>()
+            .constructor<>()
             .fun<&::base_test::base_method>("base_method") // (double)
             .fun<&::base_test::base_field>("base_field") // double
             ;
@@ -119,6 +119,11 @@ int main(int argc, char ** argv)
     try
     {
         auto xxx = context.eval("\"use strict\";"
+                                "var b = new test.base_test();"
+                                "b.base_field = [[5],[1,2,3,4],[6]];"
+                                "console.log(b.base_field[1][3] === 4);"
+                                "console.log(b.base_method() === 5);"
+
                                 "var t = new test.TestSimple(12);"
                                 "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"
                                 "q.b = true;"
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 3081eea4b6..40fbf35a48 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -983,6 +983,37 @@ namespace qjs {
             }
         };
 
+        // std::vector <-> Array
+        template <class T>
+        struct js_traits<std::vector<T>>
+        {
+            static JSValue wrap(JSContext * ctx, const std::vector<T>& arr)
+            {
+                auto jsarray = Value{ctx, JS_NewArray(ctx)};
+                if(JS_IsException(jsarray.v))
+                    throw detail::exception{};
+
+                for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
+                    jsarray[i] = arr[i];
+
+                return std::move(jsarray);
+            }
+
+            static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)
+            {
+                if(!JS_IsArray(ctx, jsarr))
+                    throw exception{};
+                Value jsarray {ctx, JS_DupValue(ctx, jsarr)};
+                std::vector<T> arr;
+                int32_t len = jsarray["length"];
+                arr.reserve((uint32_t)len);
+                for(uint32_t i = 0; i < (uint32_t)len; i++)
+                    arr.push_back(jsarray[i]);
+                return arr;
+            }
+        };
+
+
     }
 
 }
\ No newline at end of file

From feaaed01c3beed745c8b145df719a261d0cfd1e7 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Aug 2019 17:18:21 +0300
Subject: [PATCH 017/185] updated quickjs to 2019-08-10

---
 quickjs/VERSION          |    2 +-
 quickjs/libbf.c          |    4 +-
 quickjs/libbf.h          |    8 +-
 quickjs/quickjs-atom.h   |    8 +-
 quickjs/quickjs-libc.c   |  200 +++-
 quickjs/quickjs-opcode.h |   55 +-
 quickjs/quickjs.c        | 1907 +++++++++++++++++++++++++++++++-------
 quickjs/quickjs.h        |   28 +-
 quickjspp.hpp            |    6 +-
 9 files changed, 1824 insertions(+), 394 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 6b45bd0759..c88c1f0c71 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-07-28
+2019-08-10
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index de800365fb..cbabf9525d 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -2475,6 +2475,7 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
 {
     const char *p, *p_start;
     int is_neg, radix_bits, exp_is_neg, ret, digits_per_limb, shift, sep;
+    int ret_legacy_octal = 0;
     limb_t cur_limb;
     slimb_t pos, expn, int_len, digit_count;
     BOOL has_decpt, is_bin_exp, is_float;
@@ -2525,6 +2526,7 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
         } else if ((p[1] >= '0' && p[1] <= '9') &&
                    radix == 0 && (flags & BF_ATOF_LEGACY_OCTAL)) {
             int i;
+            ret_legacy_octal = BF_ATOF_ST_LEGACY_OCTAL;
             /* the separator is not allowed in legacy octal literals */
             sep = 256;
             for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
@@ -2745,7 +2747,7 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
  done:
     if (pnext)
         *pnext = p;
-    return ret;
+    return ret | ret_legacy_octal;
  error:
     if (!radix_bits)
         bf_delete(a);
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index e73b51d969..e3ea06019b 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -269,10 +269,12 @@ void bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
 /* only accept decimal floating point if radix = 0 */
 #define BF_ATOF_ONLY_DEC_FLOAT (1 << 26)
 
-/* one more return flag: indicate that the parsed number is an integer
-   (only set when the flags BF_ATOF_INT_PREC_INF or
-   BF_ATOF_INT_N_SUFFIX are used) */
+/* additional return flags */
+/* indicate that the parsed number is an integer (only set when the
+   flags BF_ATOF_INT_PREC_INF or BF_ATOF_INT_N_SUFFIX are used) */
 #define BF_ATOF_ST_INTEGER   (1 << 5)
+/* integer parsed as legacy octal */
+#define BF_ATOF_ST_LEGACY_OCTAL (1 << 6)
 
 int bf_atof(bf_t *a, const char *str, const char **pnext, int radix,
             limb_t prec, bf_flags_t flags);
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index b0708aa9be..6bbc3b2982 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -144,6 +144,11 @@ DEF(raw, "raw")
 DEF(new_target, "new.target")
 DEF(this_active_func, "this.active_func")
 DEF(home_object, "<home_object>")
+DEF(computed_field, "<computed_field>")
+DEF(static_computed_field, "<static_computed_field>") /* must come after computed_fields */
+DEF(class_fields_init, "<class_fields_init>")
+DEF(brand, "<brand>")
+DEF(hash_constructor, "#constructor")
 DEF(as, "as")
 DEF(from, "from")
 DEF(_default_, "*default*")
@@ -234,7 +239,8 @@ DEF(SyntaxError, "SyntaxError")
 DEF(TypeError, "TypeError")
 DEF(URIError, "URIError")
 DEF(InternalError, "InternalError")
-
+/* private symbols */
+DEF(Private_brand, "<brand>")
 /* symbols */
 DEF(Symbol_toPrimitive, "Symbol.toPrimitive")
 DEF(Symbol_iterator, "Symbol.iterator")
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index df6a36ab1c..a4a4c1c8d4 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -100,6 +100,7 @@ static JSValue js_printf_internal(JSContext *ctx,
     const uint8_t *p;
     char *q;
     int i, c, len;
+    size_t fmt_len;
     int32_t int32_arg;
     int64_t int64_arg;
     double double_arg;
@@ -112,13 +113,13 @@ static JSValue js_printf_internal(JSContext *ctx,
     js_std_dbuf_init(ctx, &dbuf);
 
     if (argc > 0) {
-        fmt_str = JS_ToCStringLen(ctx, &len, argv[0], FALSE);
+        fmt_str = JS_ToCStringLen(ctx, &fmt_len, argv[0]);
         if (!fmt_str)
             goto fail;
 
         i = 1;
         fmt = (const uint8_t *)fmt_str;
-        fmt_end = fmt + len;
+        fmt_end = fmt + fmt_len;
         while (fmt < fmt_end) {
             for (p = fmt; fmt < fmt_end && *fmt != '%'; fmt++)
                 continue;
@@ -477,9 +478,9 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
     const char *str;
-    int len;
+    size_t len;
     JSValue ret;
-    str = JS_ToCStringLen(ctx, &len, argv[0], FALSE);
+    str = JS_ToCStringLen(ctx, &len, argv[0]);
     if (!str)
         return JS_EXCEPTION;
     if (++eval_script_recurse == 1) {
@@ -878,6 +879,196 @@ static JSValue js_std_file_putByte(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, c);
 }
 
+/* urlGet */
+
+#define URL_GET_PROGRAM "curl -s -i"
+#define URL_GET_BUF_SIZE 4096
+
+static int http_get_header_line(FILE *f, char *buf, size_t buf_size,
+                                DynBuf *dbuf)
+{
+    int c;
+    char *p;
+    
+    p = buf;
+    for(;;) {
+        c = fgetc(f);
+        if (c < 0)
+            return -1;
+        if ((p - buf) < buf_size - 1)
+            *p++ = c;
+        if (dbuf)
+            dbuf_putc(dbuf, c);
+        if (c == '\n')
+            break;
+    }
+    *p = '\0';
+    return 0;
+}
+
+static int http_get_status(const char *buf)
+{
+    const char *p = buf;
+    while (*p != ' ' && *p != '\0')
+        p++;
+    if (*p != ' ')
+        return 0;
+    while (*p == ' ')
+        p++;
+    return atoi(p);
+}
+
+static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    const char *url;
+    DynBuf cmd_buf;
+    DynBuf data_buf_s, *data_buf = &data_buf_s;
+    DynBuf header_buf_s, *header_buf = &header_buf_s;
+    char *buf; 
+    size_t i, len;
+    int c, status;
+    JSValue val, response = JS_UNDEFINED, ret_obj;
+    JSValueConst options_obj;
+    FILE *f;
+    BOOL binary_flag, full_flag;
+    
+    url = JS_ToCString(ctx, argv[0]);
+    if (!url)
+        return JS_EXCEPTION;
+    
+    binary_flag = FALSE;
+    full_flag = FALSE;
+    
+    if (argc >= 2) {
+        options_obj = argv[1];
+
+        val = JS_GetPropertyStr(ctx, options_obj, "binary");
+        if (JS_IsException(val))
+            goto fail_opt;
+        binary_flag = JS_ToBool(ctx, val);
+        JS_FreeValue(ctx, val);
+
+        val = JS_GetPropertyStr(ctx, options_obj, "full");
+        if (JS_IsException(val)) {
+        fail_opt:
+            JS_FreeCString(ctx, url);
+            return JS_EXCEPTION;
+        }
+        full_flag = JS_ToBool(ctx, val);
+        JS_FreeValue(ctx, val);
+    }
+    
+
+    js_std_dbuf_init(ctx, &cmd_buf);
+    dbuf_printf(&cmd_buf, "%s ''", URL_GET_PROGRAM);
+    len = strlen(url);
+    for(i = 0; i < len; i++) {
+        c = url[i];
+        if (c == '\'' || c == '\\')
+            dbuf_putc(&cmd_buf, '\\');
+        dbuf_putc(&cmd_buf, c);
+    }
+    JS_FreeCString(ctx, url);
+    dbuf_putstr(&cmd_buf, "''");
+    dbuf_putc(&cmd_buf, '\0');
+    if (dbuf_error(&cmd_buf)) {
+        dbuf_free(&cmd_buf);
+        return JS_EXCEPTION;
+    }
+    //    printf("%s\n", (char *)cmd_buf.buf);
+    f = popen((char *)cmd_buf.buf, "r");
+    dbuf_free(&cmd_buf);
+    if (!f) {
+        return js_std_throw_errno(ctx, errno);
+    }
+
+    js_std_dbuf_init(ctx, data_buf);
+    js_std_dbuf_init(ctx, header_buf);
+    
+    buf = js_malloc(ctx, URL_GET_BUF_SIZE);
+    if (!buf)
+        goto fail;
+
+    /* get the HTTP status */
+    if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, NULL) < 0)
+        goto bad_header;
+    status = http_get_status(buf);
+    if (!full_flag && !(status >= 200 && status <= 299)) {
+        js_std_throw_errno(ctx, ENOENT);
+        goto fail;
+    }
+    
+    /* wait until there is an empty line */
+    for(;;) {
+        if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, header_buf) < 0) {
+        bad_header:
+            js_std_throw_errno(ctx, EINVAL);
+            goto fail;
+        }
+        if (!strcmp(buf, "\r\n"))
+            break;
+    }
+    if (dbuf_error(header_buf))
+        goto fail;
+    header_buf->size -= 2; /* remove the trailing CRLF */
+
+    /* download the data */
+    for(;;) {
+        len = fread(buf, 1, URL_GET_BUF_SIZE, f);
+        if (len == 0)
+            break;
+        dbuf_put(data_buf, (uint8_t *)buf, len);
+    }
+    js_free(ctx, buf);
+    buf = NULL;
+    pclose(f);
+    f = NULL;
+
+    if (dbuf_error(data_buf))
+        goto fail;
+    if (binary_flag) {
+        response = JS_NewArrayBufferCopy(ctx,
+                                         data_buf->buf, data_buf->size);
+    } else {
+        response = JS_NewStringLen(ctx, (char *)data_buf->buf, data_buf->size);
+    }
+    dbuf_free(data_buf);
+    data_buf = NULL;
+    if (JS_IsException(response))
+        goto fail;
+
+    if (full_flag) {
+        ret_obj = JS_NewObject(ctx);
+        if (JS_IsException(ret_obj))
+            goto fail;
+        JS_DefinePropertyValueStr(ctx, ret_obj, "response",
+                                  response,
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, ret_obj, "responseHeaders",
+                                  JS_NewStringLen(ctx, (char *)header_buf->buf,
+                                                  header_buf->size),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, ret_obj, "status",
+                                  JS_NewInt32(ctx, status),
+                                  JS_PROP_C_W_E);
+    } else {
+        ret_obj = response;
+    }
+    dbuf_free(header_buf);
+    return ret_obj;
+ fail:
+    if (f)
+        pclose(f);
+    js_free(ctx, buf);
+    if (data_buf)
+        dbuf_free(data_buf);
+    if (header_buf)
+        dbuf_free(header_buf);
+    JS_FreeValue(ctx, response);
+    return JS_EXCEPTION;
+}
+
 static JSClassDef js_std_file_class = {
     "FILE",
     .finalizer = js_std_file_finalizer,
@@ -889,6 +1080,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("evalScript", 1, js_evalScript ),
     JS_CFUNC_DEF("loadScript", 1, js_loadScript ),
     JS_CFUNC_DEF("getenv", 1, js_std_getenv ),
+    JS_CFUNC_DEF("urlGet", 1, js_std_urlGet ),
 
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index d7318682bf..0ea029eecf 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -61,20 +61,20 @@ FMT(label_u16)
 #define def(id, size, n_pop, n_push, f) DEF(id, size, n_pop, n_push, f)
 #endif
 
-def(invalid, 1, 0, 0, none) /* never emitted */
+DEF(invalid, 1, 0, 0, none) /* never emitted */
 
 /* push values */
 DEF(       push_i32, 5, 0, 1, i32)
 DEF(     push_const, 5, 0, 1, const)
 DEF(       fclosure, 5, 0, 1, const) /* must follow push_const */
 DEF(push_atom_value, 5, 0, 1, atom)
+DEF( private_symbol, 5, 0, 1, atom)
 DEF(      undefined, 1, 0, 1, none)
 DEF(           null, 1, 0, 1, none)
 DEF(      push_this, 1, 0, 1, none) /* only used at the start of a function */
 DEF(     push_false, 1, 0, 1, none)
 DEF(      push_true, 1, 0, 1, none)
 DEF(         object, 1, 0, 1, none)
-DEF(     var_object, 1, 0, 1, none)
 DEF( special_object, 2, 0, 1, u8) /* only used at the start of a function */
 DEF(           rest, 3, 0, 1, u16) /* only used at the start of a function */
 
@@ -109,6 +109,8 @@ DEF(         return, 1, 1, 0, none)
 DEF(   return_undef, 1, 0, 0, none)
 DEF(check_ctor_return, 1, 1, 2, none)
 DEF(     check_ctor, 1, 0, 0, none)
+DEF(    check_brand, 1, 2, 2, none) /* this_obj func -> this_obj func */
+DEF(      add_brand, 1, 2, 0, none) /* this_obj home_obj -> */
 DEF(   return_async, 1, 1, 0, none)
 DEF(          throw, 1, 1, 0, none)
 DEF(      throw_var, 6, 0, 0, atom_u8)
@@ -135,6 +137,9 @@ DEF(    define_func, 6, 1, 0, atom_u8)
 DEF(      get_field, 5, 1, 1, atom)
 DEF(     get_field2, 5, 1, 2, atom)
 DEF(      put_field, 5, 2, 0, atom)
+DEF( get_private_field, 1, 2, 1, none) /* obj prop -> value */
+DEF( put_private_field, 1, 3, 0, none) /* obj value prop -> */
+DEF(define_private_field, 1, 3, 1, none) /* obj prop value -> obj */
 DEF(   get_array_el, 1, 2, 1, none)
 DEF(  get_array_el2, 1, 2, 2, none) /* obj prop -> obj value */
 DEF(   put_array_el, 1, 3, 0, none)
@@ -144,12 +149,13 @@ DEF(   define_field, 5, 2, 1, atom)
 DEF(       set_name, 5, 1, 1, atom)
 DEF(set_name_computed, 1, 2, 2, none)
 DEF(      set_proto, 1, 2, 1, none)
+DEF(set_home_object, 1, 2, 2, none)
 DEF(define_array_el, 1, 3, 2, none)
 DEF(         append, 1, 3, 2, none) /* append enumerated object, update length */
 DEF(copy_data_properties, 2, 3, 3, u8)
 DEF(  define_method, 6, 2, 1, atom_u8)
 DEF(define_method_computed, 2, 3, 1, u8) /* must come after define_method */
-DEF(   define_class, 2, 2, 2, u8)
+DEF(   define_class, 6, 2, 2, atom_u8)
 
 DEF(        get_loc, 3, 0, 1, loc)
 DEF(        put_loc, 3, 1, 0, loc) /* must come after get_loc */
@@ -161,7 +167,6 @@ DEF(    get_var_ref, 3, 0, 1, var_ref)
 DEF(    put_var_ref, 3, 1, 0, var_ref) /* must come after get_var_ref */
 DEF(    set_var_ref, 3, 1, 1, var_ref) /* must come after put_var_ref */
 DEF(set_loc_uninitialized, 3, 0, 0, loc)
-def(set_arg_valid_upto, 3, 0, 0, arg) /* emitted in phase 1, removed in phase 2 */
 DEF(  get_loc_check, 3, 0, 1, loc)
 DEF(  put_loc_check, 3, 1, 0, loc) /* must come after get_loc_check */
 DEF(  put_loc_check_init, 3, 1, 0, loc)
@@ -169,26 +174,13 @@ DEF(get_var_ref_check, 3, 0, 1, var_ref)
 DEF(put_var_ref_check, 3, 1, 0, var_ref) /* must come after get_var_ref_check */
 DEF(put_var_ref_check_init, 3, 1, 0, var_ref)
 DEF(      close_loc, 3, 0, 0, loc)
-def(close_var_object, 1, 0, 0, none) /* emitted in phase 1, removed in phase 2 */
-def(    enter_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
-def(    leave_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
-
 DEF(       if_false, 5, 1, 0, label)
 DEF(        if_true, 5, 1, 0, label) /* must come after if_false */
 DEF(           goto, 5, 0, 0, label) /* must come after if_true */
-def(          label, 5, 0, 0, label) /* emitted in phase 1, removed in phase 3 */
 DEF(          catch, 5, 0, 1, label)
 DEF(          gosub, 5, 0, 0, label) /* used to execute the finally block */
 DEF(            ret, 1, 1, 0, none) /* used to return from the finally block */
 
-def(scope_get_var_undef, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_get_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_put_var, 7, 1, 0, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(scope_delete_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def( scope_make_ref, 11, 0, 2, atom_label_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_get_ref, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(scope_put_var_init, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
-
 DEF(      to_object, 1, 1, 1, none)
 //DEF(      to_string, 1, 1, 1, none)
 DEF(     to_propkey, 1, 1, 1, none)
@@ -206,8 +198,6 @@ DEF(   make_arg_ref, 7, 0, 2, atom_u16)
 DEF(make_var_ref_ref, 7, 0, 2, atom_u16)
 DEF(   make_var_ref, 5, 0, 2, atom)
 
-def(       line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
-
 DEF(   for_in_start, 1, 1, 1, none)
 DEF(   for_of_start, 1, 1, 3, none)
 DEF(for_await_of_start, 1, 1, 3, none)
@@ -270,6 +260,31 @@ DEF(       math_div, 1, 2, 1, none)
 DEF(       math_mod, 1, 2, 1, none)
 DEF(       math_pow, 1, 2, 1, none)
 #endif
+/* must be the last non short and non temporary opcode */
+DEF(            nop, 1, 0, 0, none) 
+
+/* temporary opcodes: never emitted in the final bytecode */
+
+def(set_arg_valid_upto, 3, 0, 0, arg) /* emitted in phase 1, removed in phase 2 */
+
+def(close_var_object, 1, 0, 0, none) /* emitted in phase 1, removed in phase 2 */
+def(    enter_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
+def(    leave_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
+
+def(          label, 5, 0, 0, label) /* emitted in phase 1, removed in phase 3 */
+
+def(scope_get_var_undef, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(  scope_get_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(  scope_put_var, 7, 1, 0, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_delete_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def( scope_make_ref, 11, 0, 2, atom_label_u16) /* emitted in phase 1, removed in phase 2 */
+def(  scope_get_ref, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_put_var_init, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_get_private_field, 7, 1, 1, atom_u16) /* obj -> value, emitted in phase 1, removed in phase 2 */
+def(scope_get_private_field2, 7, 1, 2, atom_u16) /* obj -> obj value, emitted in phase 1, removed in phase 2 */
+def(scope_put_private_field, 7, 1, 1, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
+
+def(       line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
 
 #if SHORT_OPCODES
 DEF(    push_minus1, 1, 0, 1, none_int)
@@ -345,8 +360,6 @@ DEF(        is_null, 1, 1, 1, none)
 DEF(    is_function, 1, 1, 1, none)
 #endif
 
-DEF(            nop, 1, 0, 0, none) /* temporary use during code generation */
-
 #undef DEF
 #undef def
 #endif  /* DEF */
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index d3e89b52e1..7bb20cb4db 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -70,7 +70,6 @@
 #if !defined(EMSCRIPTEN)
 #define CONFIG_ATOMICS
 #endif
-#define JSON_SUPERSET  1
 
 /* dump object free */
 //#define DUMP_FREE
@@ -379,14 +378,29 @@ enum {
     JS_ATOM_TYPE_STRING = 1,
     JS_ATOM_TYPE_GLOBAL_SYMBOL,
     JS_ATOM_TYPE_SYMBOL,
+    JS_ATOM_TYPE_PRIVATE,
 };
 
+enum {
+    JS_ATOM_HASH_SYMBOL,
+    JS_ATOM_HASH_PRIVATE,
+};
+
+typedef enum {
+    JS_ATOM_KIND_STRING,
+    JS_ATOM_KIND_SYMBOL,
+    JS_ATOM_KIND_PRIVATE,
+} JSAtomKindEnum;
+
 #define JS_ATOM_HASH_MASK  ((1 << 30) - 1)
 
 struct JSString {
     JSRefCountHeader header; /* must come first, 32-bit */
     uint32_t len : 31;
     uint8_t is_wide_char : 1; /* 0 = 8 bits, 1 = 16 bits characters */
+    /* for JS_ATOM_TYPE_SYMBOL: hash = 0, atom_type = 3,
+       for JS_ATOM_TYPE_PRIVATE: hash = 1, atom_type = 3
+       XXX: could change encoding to have one more bit in hash */
     uint32_t hash : 30;
     uint8_t atom_type : 2; /* != 0 if atom, JS_ATOM_TYPE_x */
     uint32_t hash_next; /* atom_index for JS_ATOM_TYPE_SYMBOL */
@@ -404,8 +418,8 @@ typedef struct JSClosureVar {
     uint8_t is_arg : 1;
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
-    uint8_t is_catch : 1;
-    /* 11 bits available */
+    uint8_t var_kind : 3; /* see JSVarKindEnum */
+    /* 9 bits available */
     uint16_t var_idx; /* is_local = TRUE: index to a normal variable of the
                     parent function. otherwise: index to a closure
                     variable of the parent function */
@@ -417,18 +431,29 @@ typedef struct JSVarScope {
     int first;   /* index into fd->vars of the last variable in this scope */
 } JSVarScope;
 
+typedef enum {
+    /* XXX: add more variable kinds here instead of using bit fields */
+    JS_VAR_NORMAL,
+    JS_VAR_CATCH,
+    JS_VAR_PRIVATE_FIELD,
+    JS_VAR_PRIVATE_METHOD,
+    JS_VAR_PRIVATE_GETTER,
+    JS_VAR_PRIVATE_SETTER, /* must come after JS_VAR_PRIVATE_GETTER */
+    JS_VAR_PRIVATE_GETTER_SETTER, /* must come after JS_VAR_PRIVATE_SETTER */
+} JSVarKindEnum;
+
 typedef struct JSVarDef {
     JSAtom var_name;
     int scope_level;   /* index into fd->scopes of this variable lexical scope */
     int scope_next;    /* index into fd->vars of the next variable in the
                         * same or enclosing lexical scope */
-    uint8_t is_catch : 1;
     uint8_t is_function : 1; /* only used for debug */
     uint8_t is_func_var : 1; /* used for the function self reference */
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
     uint8_t is_captured : 1;
-    int func_pool_idx : 26; /* only used during compilation */
+    uint8_t var_kind : 3; /* see JSVarKindEnum */
+    int func_pool_idx : 24; /* only used during compilation */
 } JSVarDef;
 
 /* for the encoding of the pc2line table */
@@ -457,9 +482,10 @@ typedef struct JSFunctionBytecode {
     uint8_t new_target_allowed : 1;
     uint8_t super_call_allowed : 1;
     uint8_t super_allowed : 1;
+    uint8_t arguments_allowed : 1;
     uint8_t has_debug : 1;
     uint8_t read_only_bytecode : 1;
-    /* XXX: 5 bits available */
+    /* XXX: 4 bits available */
     uint8_t *byte_code_buf; /* (self pointer) */
     int byte_code_len;
     JSAtom func_name;
@@ -513,6 +539,7 @@ typedef struct JSProxyData {
     JSValue handler;
     JSValue proto;
     uint8_t is_func;
+    uint8_t is_revoked;
 } JSProxyData;
 
 typedef struct JSArrayBuffer {
@@ -779,10 +806,23 @@ typedef enum OPCodeFormat {
 typedef enum OPCodeEnum {
 #define FMT(f)
 #define DEF(id, size, n_pop, n_push, f) OP_ ## id,
+#define def(id, size, n_pop, n_push, f)
+#include "quickjs-opcode.h"
+#undef def
+#undef DEF
+#undef FMT
+    OP_COUNT, /* excluding temporary opcodes */
+    /* temporary opcodes : overlap with the short opcodes */
+    OP_TEMP_START = OP_nop + 1,
+    OP___dummy = OP_TEMP_START - 1,
+#define FMT(f)
+#define DEF(id, size, n_pop, n_push, f)
+#define def(id, size, n_pop, n_push, f) OP_ ## id,
 #include "quickjs-opcode.h"
+#undef def
 #undef DEF
 #undef FMT
-    OP_COUNT,
+    OP_TEMP_END,
 } OPCodeEnum;
 
 static int JS_InitAtoms(JSRuntime *rt);
@@ -898,17 +938,15 @@ static JSProperty *add_property(JSContext *ctx,
                                 JSObject *p, JSAtom prop, int prop_flags);
 #ifdef CONFIG_BIGNUM
 static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
-static JSValue JS_NewBigInt64(JSContext *ctx, int64_t v);
-static JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);
 static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a);
 static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint);
 static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a);
 static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
-static int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
                            JSValueConst val);
 #endif
 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
+static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx);
 static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
                              JSValueConst this_obj,
                              int argc, JSValueConst *argv);
@@ -961,8 +999,8 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
 static int JS_NumberIsInteger(JSContext *ctx, JSValueConst val);
 static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val);
 static JSValue JS_ToNumberFree(JSContext *ctx, JSValue val);
-static int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
-                             JSObject *p, JSAtom prop);
+static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
+                                     JSObject *p, JSAtom prop);
 static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc);
 static void async_func_mark(JSRuntime *rt, JSAsyncFunctionState *s,
                             JS_MarkFunc *mark_func);
@@ -976,6 +1014,8 @@ static __exception int js_get_length32(JSContext *ctx, uint32_t *pres,
                                        JSValueConst obj);
 static __exception int js_get_length64(JSContext *ctx, int64_t *pres,
                                        JSValueConst obj);
+static BOOL js_get_fast_array(JSContext *ctx, JSValueConst obj,
+                              JSValue **arrpp, uint32_t *countp);
 static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
                                               JSValueConst sync_iter);
 static void js_c_function_data_finalizer(JSRuntime *rt, JSValue val);
@@ -984,6 +1024,8 @@ static void js_c_function_data_mark(JSRuntime *rt, JSValueConst val,
 static JSValue js_c_function_data_call(JSContext *ctx, JSValueConst func_obj,
                                        JSValueConst this_val,
                                        int argc, JSValueConst *argv);
+static JSAtom js_value_to_atom(JSContext *ctx, JSValueConst val);
+static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
 static const JSClassExoticMethods js_string_exotic_methods;
@@ -1635,9 +1677,15 @@ void JS_FreeRuntime(JSRuntime *rt)
                         printf(")");
                         break;
                     case JS_ATOM_TYPE_SYMBOL:
-                        printf("Symbol(");
-                        JS_DumpString(rt, p);
-                        printf(")");
+                        if (p->hash == JS_ATOM_HASH_SYMBOL) {
+                            printf("Symbol(");
+                            JS_DumpString(rt, p);
+                            printf(")");
+                        } else {
+                            printf("Private(");
+                            JS_DumpString(rt, p);
+                            printf(")");
+                        }
                         break;
                     }
                     if (rt->rt_info) {
@@ -2048,18 +2096,19 @@ static inline BOOL is_num_string(uint32_t *pval, const JSString *p)
 }
 
 /* XXX: could use faster version ? */
-static inline uint32_t hash_string8(const uint8_t *str, int len, uint32_t h)
+static inline uint32_t hash_string8(const uint8_t *str, size_t len, uint32_t h)
 {
-    int i;
+    size_t i;
 
     for(i = 0; i < len; i++)
         h = h * 263 + str[i];
     return h;
 }
 
-static inline uint32_t hash_string16(const uint16_t *str, int len, uint32_t h)
+static inline uint32_t hash_string16(const uint16_t *str,
+                                     size_t len, uint32_t h)
 {
-    int i;
+    size_t i;
 
     for(i = 0; i < len; i++)
         h = h * 263 + str[i];
@@ -2187,7 +2236,9 @@ static int JS_InitAtoms(JSRuntime *rt)
 
     p = js_atom_init;
     for(i = 1; i < JS_ATOM_END; i++) {
-        if (i >= JS_ATOM_Symbol_toPrimitive)
+        if (i == JS_ATOM_Private_brand)
+            atom_type = JS_ATOM_TYPE_PRIVATE;
+        else if (i >= JS_ATOM_Symbol_toPrimitive)
             atom_type = JS_ATOM_TYPE_SYMBOL;
         else
             atom_type = JS_ATOM_TYPE_STRING;
@@ -2223,16 +2274,37 @@ JSAtom JS_DupAtom(JSContext *ctx, JSAtom v)
     return v;
 }
 
-static BOOL JS_AtomIsString(JSContext *ctx, JSAtom v)
+static JSAtomKindEnum JS_AtomGetKind(JSContext *ctx, JSAtom v)
 {
     JSRuntime *rt;
     JSAtomStruct *p;
 
     rt = ctx->rt;
     if (__JS_AtomIsTaggedInt(v))
-        return TRUE;
+        return JS_ATOM_KIND_STRING;
     p = rt->atom_array[v];
-    return p->atom_type == JS_ATOM_TYPE_STRING;
+    switch(p->atom_type) {
+    case JS_ATOM_TYPE_STRING:
+        return JS_ATOM_KIND_STRING;
+    case JS_ATOM_TYPE_GLOBAL_SYMBOL:
+        return JS_ATOM_KIND_SYMBOL;
+    case JS_ATOM_TYPE_SYMBOL:
+        switch(p->hash) {
+        case JS_ATOM_HASH_SYMBOL:
+            return JS_ATOM_KIND_SYMBOL;
+        case JS_ATOM_HASH_PRIVATE:
+            return JS_ATOM_KIND_PRIVATE;
+        default:
+            abort();
+        }
+    default:
+        abort();
+    }
+}
+
+static BOOL JS_AtomIsString(JSContext *ctx, JSAtom v)
+{
+    return JS_AtomGetKind(ctx, v) == JS_ATOM_KIND_STRING;
 }
 
 static JSAtom js_get_atom_index(JSRuntime *rt, JSAtomStruct *p)
@@ -2263,7 +2335,7 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
 #if 0
     printf("__JS_NewAtom: ");  JS_DumpString(rt, str); printf("\n");
 #endif
-    if (atom_type != JS_ATOM_TYPE_SYMBOL) {
+    if (atom_type < JS_ATOM_TYPE_SYMBOL) {
         /* str is not NULL */
         if (str->atom_type == atom_type) {
             /* str is the atom, return its index */
@@ -2293,7 +2365,12 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
         }
     } else {
         h1 = 0; /* avoid warning */
-        h = 0;  /* avoid warning */
+        if (atom_type == JS_ATOM_TYPE_SYMBOL) {
+            h = JS_ATOM_HASH_SYMBOL;
+        } else {
+            h = JS_ATOM_HASH_PRIVATE;
+            atom_type = JS_ATOM_TYPE_SYMBOL;
+        }
     }
 
     if (rt->atom_free_index == 0) {
@@ -2417,7 +2494,7 @@ static JSAtom __JS_NewAtomInit(JSRuntime *rt, const char *str, int len,
     return __JS_NewAtom(rt, p, atom_type);
 }
 
-static JSAtom __JS_FindAtom(JSRuntime *rt, const char *str, int len,
+static JSAtom __JS_FindAtom(JSRuntime *rt, const char *str, size_t len,
                             int atom_type)
 {
     uint32_t h, h1, i;
@@ -2511,7 +2588,7 @@ static JSAtom JS_NewAtomStr(JSContext *ctx, JSString *p)
     return __JS_NewAtom(rt, p, JS_ATOM_TYPE_STRING);
 }
 
-JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, int len)
+JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len)
 {
     JSValue val;
 
@@ -2574,6 +2651,20 @@ static JSValue JS_NewSymbol(JSContext *ctx, JSString *p, int atom_type)
     return JS_MKPTR(JS_TAG_SYMBOL, rt->atom_array[atom]);
 }
 
+/* descr must be a non-numeric string atom */
+static JSValue JS_NewSymbolFromAtom(JSContext *ctx, JSAtom descr,
+                                    int atom_type)
+{
+    JSRuntime *rt = ctx->rt;
+    JSString *p;
+
+    assert(!__JS_AtomIsTaggedInt(descr));
+    assert(descr < rt->atom_size);
+    p = rt->atom_array[descr];
+    JS_DupValue(ctx, JS_MKPTR(JS_TAG_STRING, p));
+    return JS_NewSymbol(ctx, p, atom_type);
+}
+
 #define ATOM_GET_STR_BUF_SIZE 64
 
 /* Should only be used for debug. */
@@ -2812,7 +2903,9 @@ static BOOL JS_AtomSymbolHasDescription(JSContext *ctx, JSAtom v)
     if (__JS_AtomIsTaggedInt(v))
         return FALSE;
     p = rt->atom_array[v];
-    return (p->atom_type != JS_ATOM_TYPE_STRING &&
+    return (((p->atom_type == JS_ATOM_TYPE_SYMBOL &&
+              p->hash == JS_ATOM_HASH_SYMBOL) ||
+             p->atom_type == JS_ATOM_TYPE_GLOBAL_SYMBOL) &&
             !(p->len == 0 && p->is_wide_char != 0));
 }
 
@@ -2868,6 +2961,46 @@ const char *JS_AtomToCString(JSContext *ctx, JSAtom atom)
     return cstr;
 }
 
+/* return a string atom containing name concatenated with str1 */
+static JSAtom js_atom_concat_str(JSContext *ctx, JSAtom name, const char *str1)
+{
+    JSValue str;
+    JSAtom atom;
+    const char *cstr;
+    char *cstr2;
+    size_t len, len1;
+    
+    str = JS_AtomToString(ctx, name);
+    if (JS_IsException(str))
+        return JS_ATOM_NULL;
+    cstr = JS_ToCStringLen(ctx, &len, str);
+    if (!cstr)
+        goto fail;
+    len1 = strlen(str1);
+    cstr2 = js_malloc(ctx, len + len1 + 1);
+    if (!cstr2)
+        goto fail;
+    memcpy(cstr2, cstr, len);
+    memcpy(cstr2 + len, str1, len1);
+    cstr2[len + len1] = '\0';
+    atom = JS_NewAtomLen(ctx, cstr2, len + len1);
+    js_free(ctx, cstr2);
+    JS_FreeCString(ctx, cstr);
+    JS_FreeValue(ctx, str);
+    return atom;
+ fail:
+    JS_FreeCString(ctx, cstr);
+    JS_FreeValue(ctx, str);
+    return JS_ATOM_NULL;
+}
+
+static JSAtom js_atom_concat_num(JSContext *ctx, JSAtom name, uint32_t n)
+{
+    char buf[16];
+    snprintf(buf, sizeof(buf), "%u", n);
+    return js_atom_concat_str(ctx, name, buf);
+}
+
 static inline BOOL JS_IsEmptyString(JSValueConst v)
 {
     return JS_VALUE_GET_TAG(v) == JS_TAG_STRING && JS_VALUE_GET_STRING(v)->len == 0;
@@ -3366,22 +3499,25 @@ static JSValue string_buffer_end(StringBuffer *s)
 }
 
 /* create a string from a UTF-8 buffer */
-JSValue JS_NewStringLen(JSContext *ctx, const char *buf, int buf_len)
+JSValue JS_NewStringLen(JSContext *ctx, const char *buf, size_t buf_len)
 {
     const uint8_t *p, *p_end, *p_start, *p_next;
     uint32_t c;
     StringBuffer b_s, *b = &b_s;
-
+    size_t len1;
+    
     p_start = (const uint8_t *)buf;
     p_end = p_start + buf_len;
     p = p_start;
     while (p < p_end && *p < 128)
         p++;
+    len1 = p - p_start;
+    if (len1 > JS_STRING_LEN_MAX)
+        return JS_ThrowInternalError(ctx, "string too long");
     if (p == p_end) {
         /* ASCII string */
         return js_new_string8(ctx, (const uint8_t *)buf, buf_len);
     } else {
-        int len1 = p - p_start;
         if (string_buffer_init(ctx, b, buf_len))
             goto fail;
         string_buffer_write8(b, p_start, len1);
@@ -3472,7 +3608,7 @@ JSValue JS_NewAtomString(JSContext *ctx, const char *str)
 /* return (NULL, 0) if exception. */
 /* return pointer into a JSString with a live ref_count */
 /* cesu8 determines if non-BMP1 codepoints are encoded as 1 or 2 utf-8 sequences */
-const char *JS_ToCStringLen(JSContext *ctx, int *plen, JSValueConst val1, BOOL cesu8)
+const char *JS_ToCStringLen2(JSContext *ctx, size_t *plen, JSValueConst val1, BOOL cesu8)
 {
     JSValue val;
     JSString *str, *str_new;
@@ -5851,6 +5987,28 @@ static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
     return line_num;
 }
 
+/* in order to avoid executing arbitrary code during the stack trace
+   generation, we only look at simple 'name' properties containing a
+   string. */
+static const char *get_func_name(JSContext *ctx, JSValueConst func)
+{
+    JSProperty *pr;
+    JSShapeProperty *prs;
+    JSValueConst val;
+    
+    if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
+        return NULL;
+    prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
+    if (!prs)
+        return NULL;
+    if ((prs->flags & JS_PROP_TMASK) != JS_PROP_NORMAL)
+        return NULL;
+    val = pr->u.value;
+    if (JS_VALUE_GET_TAG(val) != JS_TAG_STRING)
+        return NULL;
+    return JS_ToCString(ctx, val);
+}
+
 /* if filename != NULL, an additional level is added with the filename
    and line number information (used for parse error). If 'pc' !=
    NULL, it is used as the cur_pc value for the current stack frame */
@@ -5859,7 +6017,7 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
                             const uint8_t *cur_pc)
 {
     JSStackFrame *sf;
-    JSValue str, func_name;
+    JSValue str;
     DynBuf dbuf;
     const char *func_name_str;
     const char *str1;
@@ -5879,15 +6037,13 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     }
     for(sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
-        func_name = JS_GetProperty(ctx, sf->cur_func, JS_ATOM_name);
-        func_name_str = JS_ToCString(ctx, func_name);
+        func_name_str = get_func_name(ctx, sf->cur_func);
         if (!func_name_str || func_name_str[0] == '\0')
             str1 = "<anonymous>";
         else
             str1 = func_name_str;
         dbuf_printf(&dbuf, "    at %s", str1);
         JS_FreeCString(ctx, func_name_str);
-        JS_FreeValue(ctx, func_name);
 
         p = JS_VALUE_GET_OBJ(sf->cur_func);
         if (js_class_has_bytecode(p->class_id)) {
@@ -6056,6 +6212,11 @@ static JSValue JS_ThrowTypeErrorNotAnObject(JSContext *ctx)
     return JS_ThrowTypeError(ctx, "not an object");
 }
 
+static JSValue JS_ThrowTypeErrorNotASymbol(JSContext *ctx)
+{
+    return JS_ThrowTypeError(ctx, "not a symbol");
+}
+
 static JSValue JS_ThrowReferenceErrorNotDefined(JSContext *ctx, JSAtom name)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
@@ -6443,6 +6604,189 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
     }
 }
 
+static JSValue JS_ThrowTypeErrorPrivateNotFound(JSContext *ctx, JSAtom atom)
+{
+    char buf[ATOM_GET_STR_BUF_SIZE];
+    return JS_ThrowTypeError(ctx, "private class field %s does not exist",
+                      JS_AtomGetStr(ctx, buf, sizeof(buf), atom));
+}
+
+/* Private fields can be added even on non extensible objects or
+   Proxies */
+static int JS_DefinePrivateField(JSContext *ctx, JSValueConst obj,
+                                 JSValueConst name, JSValue val)
+{
+    JSObject *p;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    JSAtom prop;
+
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        goto fail;
+    }
+    /* safety check */
+    if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL)) {
+        JS_ThrowTypeErrorNotASymbol(ctx);
+        goto fail;
+    }
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    p = JS_VALUE_GET_OBJ(obj);
+    prs = find_own_property(&pr, p, prop);
+    if (prs) {
+        char buf[ATOM_GET_STR_BUF_SIZE];
+        JS_ThrowTypeError(ctx, "private class field %s already exists",
+                          JS_AtomGetStr(ctx, buf, sizeof(buf), prop));
+        goto fail;
+    }
+    pr = add_property(ctx, p, prop, JS_PROP_C_W_E);
+    if (unlikely(!pr)) {
+    fail:
+        JS_FreeValue(ctx, val);
+        return -1;
+    }
+    pr->u.value = val;
+    return 0;
+}
+
+static JSValue JS_GetPrivateField(JSContext *ctx, JSValueConst obj,
+                                  JSValueConst name)
+{
+    JSObject *p;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    JSAtom prop;
+
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    /* safety check */
+    if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL))
+        return JS_ThrowTypeErrorNotASymbol(ctx);
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    p = JS_VALUE_GET_OBJ(obj);
+    prs = find_own_property(&pr, p, prop);
+    if (!prs) {
+        JS_ThrowTypeErrorPrivateNotFound(ctx, prop);
+        return JS_EXCEPTION;
+    }
+    return JS_DupValue(ctx, pr->u.value);
+}
+
+static int JS_SetPrivateField(JSContext *ctx, JSValueConst obj,
+                              JSValueConst name, JSValue val)
+{
+    JSObject *p;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    JSAtom prop;
+
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        goto fail;
+    }
+    /* safety check */
+    if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL)) {
+        JS_ThrowTypeErrorNotASymbol(ctx);
+        goto fail;
+    }
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    p = JS_VALUE_GET_OBJ(obj);
+    prs = find_own_property(&pr, p, prop);
+    if (!prs) {
+        JS_ThrowTypeErrorPrivateNotFound(ctx, prop);
+    fail:
+        JS_FreeValue(ctx, val);
+        return -1;
+    }
+    set_value(ctx, &pr->u.value, val);
+    return 0;
+}
+
+static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
+{
+    JSObject *p, *p1;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    JSValue brand;
+    JSAtom brand_atom;
+    
+    if (unlikely(JS_VALUE_GET_TAG(home_obj) != JS_TAG_OBJECT)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    p = JS_VALUE_GET_OBJ(home_obj);
+    prs = find_own_property(&pr, p, JS_ATOM_Private_brand);
+    if (!prs) {
+        brand = JS_NewSymbolFromAtom(ctx, JS_ATOM_brand, JS_ATOM_TYPE_PRIVATE);
+        if (JS_IsException(brand))
+            return -1;
+        /* if the brand is not present, add it */
+        pr = add_property(ctx, p, JS_ATOM_Private_brand, JS_PROP_C_W_E);
+        if (!pr) {
+            JS_FreeValue(ctx, brand);
+            return -1;
+        }
+        pr->u.value = JS_DupValue(ctx, brand);
+    } else {
+        brand = JS_DupValue(ctx, pr->u.value);
+    }
+    brand_atom = js_symbol_to_atom(ctx, brand);
+    
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        JS_FreeAtom(ctx, brand_atom);
+        return -1;
+    }
+    p1 = JS_VALUE_GET_OBJ(obj);
+    pr = add_property(ctx, p1, brand_atom, JS_PROP_C_W_E);
+    JS_FreeAtom(ctx, brand_atom);
+    if (!pr)
+        return -1;
+    pr->u.value = JS_UNDEFINED;
+    return 0;
+}
+
+static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
+{
+    JSObject *p, *p1, *home_obj;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    JSValueConst brand;
+    
+    /* get the home object of 'func' */
+    if (unlikely(JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)) {
+    not_obj:
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    p1 = JS_VALUE_GET_OBJ(func);
+    if (!js_class_has_bytecode(p1->class_id))
+        goto not_obj;
+    home_obj = p1->u.func.home_object;
+    if (!home_obj)
+        goto not_obj;
+    prs = find_own_property(&pr, home_obj, JS_ATOM_Private_brand);
+    if (!prs) {
+        JS_ThrowTypeError(ctx, "expecting <brand> private field");
+        return -1;
+    }
+    brand = pr->u.value;
+    /* safety check */
+    if (unlikely(JS_VALUE_GET_TAG(brand) != JS_TAG_SYMBOL))
+        goto not_obj;
+    
+    /* get the brand array of 'obj' */
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
+        goto not_obj;
+    p = JS_VALUE_GET_OBJ(obj);
+    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
+    if (!prs) {
+        JS_ThrowTypeError(ctx, "invalid brand on object");
+        return -1;
+    }
+    return 0;
+}
+
 static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
 {
     JSContext *ctx = opaque;
@@ -6472,16 +6816,12 @@ static void js_free_prop_enum(JSContext *ctx, JSPropertyEnum *tab, uint32_t len)
     }
 }
 
-#define JS_GPN_SYMBOL_MASK  (1 << 0)
-#define JS_GPN_STRING_MASK  (1 << 1)
-/* only include the enumerable properties */
-#define JS_GPN_ENUM_ONLY    (1 << 2)
-/* set theJSPropertyEnum.is_enumerable field */
-#define JS_GPN_SET_ENUM     (1 << 3)
-
-static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
-                                              uint32_t *plen,
-                                              JSObject *p, int flags)
+/* return < 0 in case if exception, 0 if OK. ptab and its atoms must
+   be freed by the user. */
+static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
+                                                      JSPropertyEnum **ptab,
+                                                      uint32_t *plen,
+                                                      JSObject *p, int flags)
 {
     int i, j;
     JSShape *sh;
@@ -6490,9 +6830,10 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
     JSAtom atom;
     uint32_t num_keys_count, str_keys_count, sym_keys_count, atom_count;
     uint32_t num_index, str_index, sym_index, exotic_count;
-    BOOL is_enumerable, is_string, num_sorted;
+    BOOL is_enumerable, num_sorted;
     uint32_t num_key;
-
+    JSAtomKindEnum kind;
+    
     /* clear pointer for consistency in case of failure */
     *ptab = NULL;
     *plen = 0;
@@ -6508,9 +6849,9 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
         atom = prs->atom;
         if (atom != JS_ATOM_NULL) {
             is_enumerable = ((prs->flags & JS_PROP_ENUMERABLE) != 0);
-            is_string = JS_AtomIsString(ctx, atom);
+            kind = JS_AtomGetKind(ctx, atom);
             if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
-                ((flags >> is_string) & 1) != 0) {
+                ((flags >> kind) & 1) != 0) {
                 /* need to raise an exception in case of the module
                    name space (implicit GetOwnProperty) */
                 if (unlikely((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) &&
@@ -6523,7 +6864,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                 }
                 if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                     num_keys_count++;
-                } else if (is_string) {
+                } else if (kind == JS_ATOM_KIND_STRING) {
                     str_keys_count++;
                 } else {
                     sym_keys_count++;
@@ -6553,14 +6894,14 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                     return -1;
                 for(i = 0; i < exotic_count; i++) {
                     atom = tab_exotic[i].atom;
-                    is_string = JS_AtomIsString(ctx, atom);
-                    if (((flags >> is_string) & 1) != 0) {
+                    kind = JS_AtomGetKind(ctx, atom);
+                    if (((flags >> kind) & 1) != 0) {
                         is_enumerable = FALSE;
                         if (flags & (JS_GPN_SET_ENUM | JS_GPN_ENUM_ONLY)) {
                             JSPropertyDescriptor desc;
                             int res;
                             /* set the "is_enumerable" field if necessary */
-                            res = JS_GetOwnProperty(ctx, &desc, p, atom);
+                            res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
                             if (res < 0) {
                                 js_free_prop_enum(ctx, tab_exotic, exotic_count);
                                 return -1;
@@ -6575,7 +6916,7 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
                         if (!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) {
                             if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                                 num_keys_count++;
-                            } else if (is_string) {
+                            } else if (kind == JS_ATOM_KIND_STRING) {
                                 str_keys_count++;
                             } else {
                                 sym_keys_count++;
@@ -6607,13 +6948,13 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
         atom = prs->atom;
         if (atom != JS_ATOM_NULL) {
             is_enumerable = ((prs->flags & JS_PROP_ENUMERABLE) != 0);
-            is_string = JS_AtomIsString(ctx, atom);
+            kind = JS_AtomGetKind(ctx, atom);
             if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
-                ((flags >> is_string) & 1) != 0) {
+                ((flags >> kind) & 1) != 0) {
                 if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                     j = num_index++;
                     num_sorted = FALSE;
-                } else if (is_string) {
+                } else if (kind == JS_ATOM_KIND_STRING) {
                     j = str_index++;
                 } else {
                     j = sym_index++;
@@ -6641,13 +6982,13 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
             for(i = 0; i < exotic_count; i++) {
                 atom = tab_exotic[i].atom;
                 is_enumerable = tab_exotic[i].is_enumerable;
-                is_string = JS_AtomIsString(ctx, atom);
+                kind = JS_AtomGetKind(ctx, atom);
                 if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
-                    ((flags >> is_string) & 1) != 0) {
+                    ((flags >> kind) & 1) != 0) {
                     if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
                         j = num_index++;
                         num_sorted = FALSE;
-                    } else if (is_string) {
+                    } else if (kind == JS_ATOM_KIND_STRING) {
                         j = str_index++;
                     } else {
                         j = sym_index++;
@@ -6675,11 +7016,22 @@ static int __exception JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **p
     return 0;
 }
 
+int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
+                           uint32_t *plen, JSValueConst obj, int flags)
+{
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    return JS_GetOwnPropertyNamesInternal(ctx, ptab, plen,
+                                          JS_VALUE_GET_OBJ(obj), flags);
+}
+
 /* Return -1 if exception,
    FALSE if the property does not exist, TRUE if it exists. If TRUE is
    returned, the property descriptor 'desc' is filled present. */
-static int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
-                             JSObject *p, JSAtom prop)
+static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
+                                     JSObject *p, JSAtom prop)
 {
     JSShapeProperty *prs;
     JSProperty *pr;
@@ -6771,6 +7123,16 @@ static int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
     return FALSE;
 }
 
+int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
+                      JSValueConst obj, JSAtom prop)
+{
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    return JS_GetOwnPropertyInternal(ctx, desc, JS_VALUE_GET_OBJ(obj), prop);
+}
+
 /* return -1 if exception (Proxy object only) or TRUE/FALSE */
 int JS_IsExtensible(JSContext *ctx, JSValueConst obj)
 {
@@ -6814,7 +7176,7 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
             if (em && em->has_property)
                 return em->has_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p), prop);
         }
-        ret = JS_GetOwnProperty(ctx, NULL, p, prop);
+        ret = JS_GetOwnPropertyInternal(ctx, NULL, p, prop);
         if (ret != 0)
             return ret;
         if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
@@ -6824,7 +7186,7 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
                 if (ret < 0)
                     return -1;
                 /* the detached array test was done in
-                   JS_GetOwnProperty() */
+                   JS_GetOwnPropertyInternal() */
                 return FALSE;
             }
         }
@@ -6835,6 +7197,13 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
     return FALSE;
 }
 
+/* val must be a symbol */
+static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val)
+{
+    JSAtomStruct *p = JS_VALUE_GET_PTR(val);
+    return js_get_atom_index(ctx->rt, p);
+}
+
 /* return JS_ATOM_NULL in case of exception */
 static JSAtom js_value_to_atom(JSContext *ctx, JSValueConst val)
 {
@@ -6854,8 +7223,7 @@ static JSAtom js_value_to_atom(JSContext *ctx, JSValueConst val)
         if (JS_IsException(str))
             return JS_ATOM_NULL;
         if (JS_VALUE_GET_TAG(str) == JS_TAG_SYMBOL) {
-            JSAtomStruct *p = JS_VALUE_GET_PTR(str);
-            atom = js_get_atom_index(ctx->rt, p);
+            atom = js_symbol_to_atom(ctx, str);
         } else {
             atom = JS_NewAtomStr(ctx, JS_VALUE_GET_STRING(str));
         }
@@ -7333,7 +7701,7 @@ static int JS_SetPropertyGeneric(JSContext *ctx,
             }
         }
 
-        ret = JS_GetOwnProperty(ctx, &desc, p, prop);
+        ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
         if (ret < 0)
             return ret;
         if (ret) {
@@ -7364,7 +7732,7 @@ static int JS_SetPropertyGeneric(JSContext *ctx,
     p = JS_VALUE_GET_OBJ(this_obj);
 
     /* modify the property in this_obj if it already exists */
-    ret = JS_GetOwnProperty(ctx, &desc, p, prop);
+    ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
     if (ret < 0)
         return ret;
     if (ret) {
@@ -7478,12 +7846,12 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                             return JS_SetPropertyValue(ctx, this_obj, JS_NewInt32(ctx, idx), val, flags);
                         else
                             break;
-                    } else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
-                               p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
+                    } else if (p1->class_id >= JS_CLASS_UINT8C_ARRAY &&
+                               p1->class_id <= JS_CLASS_FLOAT64_ARRAY) {
                         goto typed_array_oob;
                     }
-                } else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
-                           p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
+                } else if (p1->class_id >= JS_CLASS_UINT8C_ARRAY &&
+                           p1->class_id <= JS_CLASS_FLOAT64_ARRAY) {
                     ret = JS_AtomIsNumericIndex(ctx, prop);
                     if (ret != 0) {
                         if (ret < 0) {
@@ -7495,7 +7863,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                         JS_FreeValue(ctx, val);
                         if (JS_IsException(val))
                             return -1;
-                        if (typed_array_is_detached(ctx, p)) {
+                        if (typed_array_is_detached(ctx, p1)) {
                             JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
                             return -1;
                         }
@@ -8598,6 +8966,7 @@ static int JS_SetGlobalVar(JSContext *ctx, JSAtom prop, JSValue val,
         /* XXX: should handle JS_PROP_AUTOINIT properties? */
         if (flag != 1) {
             if (unlikely(JS_IsUninitialized(pr->u.value))) {
+                JS_FreeValue(ctx, val);
                 JS_ThrowReferenceErrorUninitialized(ctx, prs->atom);
                 return -1;
             }
@@ -10661,7 +11030,7 @@ static double js_pow(double a, double b)
 
 #ifdef CONFIG_BIGNUM
 
-static JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
+JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
 {
     BOOL is_bignum = is_bignum_mode(ctx);
     if (is_bignum && v == (int32_t)v) {
@@ -10674,7 +11043,7 @@ static JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
     }
 }
 
-static JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
+JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
 {
     BOOL is_bignum = is_bignum_mode(ctx);
     if (is_bignum && v == (int32_t)v) {
@@ -10846,7 +11215,7 @@ static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
     return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
 }
 
-static JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
+static __attribute__((unused)) JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
 {
     if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
         return val;
@@ -10886,7 +11255,7 @@ static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
     return 0;
 }
 
-static int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
+int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
 {
     return JS_ToBigInt64Free(ctx, pres, JS_DupValue(ctx, val));
 }
@@ -13316,7 +13685,7 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
     /* fast path: assume no enumerable properties in the prototype chain */
     p1 = p->shape->proto;
     while (p1 != NULL) {
-        if (JS_GetOwnPropertyNames(ctx, &tab_atom, &tab_atom_count, p1,
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p1,
                                    JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY))
             goto fail;
         js_free_prop_enum(ctx, tab_atom, tab_atom_count);
@@ -13348,7 +13717,7 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
         it->array_length = p->u.array.count;
     } else {
     normal_case:
-        if (JS_GetOwnPropertyNames(ctx, &tab_atom, &tab_atom_count, p,
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
                                    JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY))
             goto fail;
         for(i = 0; i < tab_atom_count; i++) {
@@ -13362,7 +13731,7 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
     /* non enumerable properties hide the enumerables ones in the
        prototype chain */
     while (p != NULL) {
-        if (JS_GetOwnPropertyNames(ctx, &tab_atom, &tab_atom_count, p,
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
                                    JS_GPN_STRING_MASK | JS_GPN_SET_ENUM))
             goto fail;
         for(i = 0; i < tab_atom_count; i++) {
@@ -13852,7 +14221,7 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
         pexcl = JS_VALUE_GET_OBJ(excluded);
 
     p = JS_VALUE_GET_OBJ(source);
-    if (JS_GetOwnPropertyNames(ctx, &tab_atom, &tab_atom_count, p,
+    if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
                                JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK |
                                JS_GPN_ENUM_ONLY))
         return -1;
@@ -13861,7 +14230,7 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
 
     for (i = 0; i < tab_atom_count; i++) {
         if (pexcl) {
-            ret = JS_GetOwnProperty(ctx, NULL, pexcl, tab_atom[i].atom);
+            ret = JS_GetOwnPropertyInternal(ctx, NULL, pexcl, tab_atom[i].atom);
             if (ret) {
                 if (ret < 0)
                     break;
@@ -14045,7 +14414,7 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
 #define JS_DEFINE_CLASS_HAS_HERITAGE     (1 << 0)
 
 static int js_op_define_class(JSContext *ctx, JSValue *sp,
-                              int class_flags,
+                              JSAtom class_name, int class_flags,
                               JSVarRef **cur_var_refs,
                               JSStackFrame *sf)
 {
@@ -14113,6 +14482,11 @@ static int js_op_define_class(JSContext *ctx, JSValue *sp,
     set_cycle_flag(ctx, ctor);
     set_cycle_flag(ctx, proto);
 
+    if (class_name != JS_ATOM_NULL) {
+        if (JS_DefineObjectName(ctx, ctor, class_name, JS_PROP_CONFIGURABLE) < 0)
+            goto fail;
+    }
+    
     JS_FreeValue(ctx, parent_proto);
     JS_FreeValue(ctx, parent_class);
 
@@ -14185,6 +14559,12 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
 
     p = JS_VALUE_GET_OBJ(func_obj);
     cproto = p->u.cfunc.cproto;
+    arg_count = p->u.cfunc.length;
+
+    /* better to always check stack overflow */
+    if (js_check_stack_overflow(ctx, sizeof(arg_buf[0]) * arg_count))
+        return JS_ThrowStackOverflow(ctx);
+
     prev_sf = ctx->current_stack_frame;
     sf->prev_frame = prev_sf;
     ctx->current_stack_frame = sf;
@@ -14202,11 +14582,6 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     sf->arg_count = argc;
     arg_buf = argv;
 
-    arg_count = p->u.cfunc.length;
-    /* better to always check stack overflow */
-    if (js_check_stack_overflow(ctx, sizeof(arg_buf[0]) * arg_count))
-        return JS_ThrowStackOverflow(ctx);
-
     if (unlikely(argc < arg_count)) {
         /* ensure that at least argc_count arguments are readable */
         arg_buf = alloca(sizeof(arg_buf[0]) * arg_count);
@@ -14370,6 +14745,7 @@ typedef enum {
     OP_SPECIAL_OBJECT_THIS_FUNC,
     OP_SPECIAL_OBJECT_NEW_TARGET,
     OP_SPECIAL_OBJECT_HOME_OBJECT,
+    OP_SPECIAL_OBJECT_VAR_OBJECT,
 } OPSpecialObjectEnum;
 
 #define FUNC_RET_AWAIT      0
@@ -14398,9 +14774,13 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 #else
     static const void * const dispatch_table[256] = {
 #define DEF(id, size, n_pop, n_push, f) && case_OP_ ## id,
+#if SHORT_OPCODES
+#define def(id, size, n_pop, n_push, f)
+#else                                                     
 #define def(id, size, n_pop, n_push, f) && case_default,
+#endif
 #include "quickjs-opcode.h"
-        [ OP_nop + 1 ... 255 ] = &&case_default
+        [ OP_COUNT ... 255 ] = &&case_default
     };
 #define SWITCH(pc)      goto *dispatch_table[opcode = *pc++];
 #define CASE(op)        case_ ## op
@@ -14599,11 +14979,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             if (unlikely(JS_IsException(sp[-1])))
                 goto exception;
             BREAK;
-        CASE(OP_var_object):
-            *sp++ = JS_NewObjectProto(ctx, JS_NULL);
-            if (unlikely(JS_IsException(sp[-1])))
-                goto exception;
-            BREAK;
         CASE(OP_special_object):
             {
                 int arg = *pc++;
@@ -14635,6 +15010,11 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                             *sp++ = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p1));
                     }
                     break;
+                case OP_SPECIAL_OBJECT_VAR_OBJECT:
+                    *sp++ = JS_NewObjectProto(ctx, JS_NULL);
+                    if (unlikely(JS_IsException(sp[-1])))
+                        goto exception;
+                    break;
                 default:
                     abort();
                 }
@@ -14932,7 +15312,18 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 goto exception;
             }
             BREAK;
-
+        CASE(OP_check_brand):
+            if (JS_CheckBrand(ctx, sp[-2], sp[-1]) < 0)
+                goto exception;
+            BREAK;
+        CASE(OP_add_brand):
+            if (JS_AddBrand(ctx, sp[-2], sp[-1]) < 0)
+                goto exception;
+            JS_FreeValue(ctx, sp[-2]);
+            JS_FreeValue(ctx, sp[-1]);
+            sp -= 2;
+            BREAK;
+            
         CASE(OP_throw):
             JS_Throw(ctx, *--sp);
             goto exception;
@@ -15725,6 +16116,57 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             }
             BREAK;
 
+        CASE(OP_private_symbol):
+            {
+                JSAtom atom;
+                JSValue val;
+                
+                atom = get_u32(pc);
+                pc += 4;
+                val = JS_NewSymbolFromAtom(ctx, atom, JS_ATOM_TYPE_PRIVATE);
+                if (JS_IsException(val))
+                    goto exception;
+                *sp++ = val;
+            }
+            BREAK;
+            
+        CASE(OP_get_private_field):
+            {
+                JSValue val;
+
+                val = JS_GetPrivateField(ctx, sp[-2], sp[-1]);
+                JS_FreeValue(ctx, sp[-1]);
+                JS_FreeValue(ctx, sp[-2]);
+                sp[-2] = val;
+                sp--;
+                if (unlikely(JS_IsException(val)))
+                    goto exception;
+            }
+            BREAK;
+
+        CASE(OP_put_private_field):
+            {
+                int ret;
+                ret = JS_SetPrivateField(ctx, sp[-3], sp[-1], sp[-2]);
+                JS_FreeValue(ctx, sp[-3]);
+                JS_FreeValue(ctx, sp[-1]);
+                sp -= 3;
+                if (unlikely(ret < 0))
+                    goto exception;
+            }
+            BREAK;
+
+        CASE(OP_define_private_field):
+            {
+                int ret;
+                ret = JS_DefinePrivateField(ctx, sp[-3], sp[-2], sp[-1]);
+                JS_FreeValue(ctx, sp[-2]);
+                sp -= 2;
+                if (unlikely(ret < 0))
+                    goto exception;
+            }
+            BREAK;
+
         CASE(OP_define_field):
             {
                 int ret;
@@ -15772,6 +16214,9 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 sp--;
             }
             BREAK;
+        CASE(OP_set_home_object):
+            js_method_set_home_object(ctx, sp[-1], sp[-2]);
+            BREAK;
         CASE(OP_define_method):
         CASE(OP_define_method_computed):
             {
@@ -15835,9 +16280,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
         CASE(OP_define_class):
             {
                 int class_flags;
-
-                class_flags = *pc++;
-                if (js_op_define_class(ctx, sp, class_flags,
+                JSAtom atom;
+                
+                atom = get_u32(pc);
+                class_flags = pc[4];
+                pc += 5;
+                if (js_op_define_class(ctx, sp, atom, class_flags,
                                        var_refs, sf) < 0)
                     goto exception;
             }
@@ -15956,12 +16404,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                                             atom, sp[-1], sp[-4],
                                             JS_PROP_THROW_STRICT);
                 JS_FreeAtom(ctx, atom);
-                if (ret < 0)
-                    goto exception;
                 JS_FreeValue(ctx, sp[-4]);
                 JS_FreeValue(ctx, sp[-3]);
                 JS_FreeValue(ctx, sp[-2]);
                 sp -= 4;
+                if (ret < 0)
+                    goto exception;
             }
             BREAK;
 
@@ -16736,6 +17184,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             sp[-1] = JS_FALSE;
             BREAK;
 #endif
+        CASE(OP_invalid):
         DEFAULT:
             JS_ThrowInternalError(ctx, "invalid opcode: pc=%u opcode=0x%02x",
                                   (int)(pc - b->byte_code_buf - 1), opcode);
@@ -16837,8 +17286,8 @@ static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
             /* check if revoked proxy */
             {
                 JSProxyData *s = JS_GetOpaque(ctor, JS_CLASS_PROXY);
-                if (s && JS_IsNull(s->handler))
-                    return JS_ThrowTypeError(ctx, "revoked proxy");
+                if (s && s->is_revoked)
+                    return JS_ThrowTypeErrorRevokedProxy(ctx);
             }
             /* XXX: should use the ctor realm instead of 'ctx' */
             proto = JS_DupValue(ctx, ctx->class_proto[class_id]);
@@ -16957,8 +17406,8 @@ static __exception int async_func_init(JSContext *ctx, JSAsyncFunctionState *s,
     sf->cur_pc = b->byte_code_buf;
     arg_buf_len = max_int(b->arg_count, argc);
     local_count = arg_buf_len + b->var_count + b->stack_size;
-    sf->arg_buf = js_malloc(ctx, sizeof(JSValue) * local_count);
-    if (!sf->arg_buf && local_count != 0)
+    sf->arg_buf = js_malloc(ctx, sizeof(JSValue) * max_int(local_count, 1));
+    if (!sf->arg_buf)
         return -1;
     sf->cur_func = JS_DupValue(ctx, func_obj);
     s->this_val = JS_DupValue(ctx, this_obj);
@@ -17932,6 +18381,7 @@ enum {
     TOK_ARROW,
     TOK_ELLIPSIS,
     TOK_ERROR,
+    TOK_PRIVATE_NAME,
     TOK_EOF,
     /* keywords: WARNING: same order as atoms */
     TOK_NULL, /* must be first */
@@ -18088,6 +18538,7 @@ typedef struct JSFunctionDef {
                                 throw a syntax error */
     BOOL super_call_allowed; /* true if super() is allowed */
     BOOL super_allowed; /* true if super. or super[] is allowed */
+    BOOL arguments_allowed; /* true if the 'arguments' identifier is allowed */
     BOOL is_derived_class_constructor;
     BOOL in_function_body;
     JSFunctionKindEnum func_kind : 8;
@@ -18111,7 +18562,8 @@ typedef struct JSFunctionDef {
     int new_target_var_idx; /* variable containg the 'new.target' value, -1 if none */
     int this_active_func_var_idx; /* variable containg the 'this.active_func' value, -1 if none */
     int home_object_var_idx;
-
+    BOOL need_home_object;
+    
     int scope_level;    /* index into fd->scopes if the current lexical scope */
     int scope_first;    /* index into vd->vars of first lexically scoped variable */
     int scope_size;     /* allocated size of fd->scopes array */
@@ -18126,7 +18578,8 @@ typedef struct JSFunctionDef {
     DynBuf byte_code;
     int last_opcode_pos; /* -1 if no last opcode */
     int last_opcode_line_num;
-
+    BOOL use_short_opcodes; /* true if short opcodes are used in byte_code */
+    
     LabelSlot *label_slots;
     int label_size; /* allocated size for label_slots[] */
     int label_count;
@@ -18219,7 +18672,7 @@ typedef struct JSOpCode {
     uint8_t fmt;
 } JSOpCode;
 
-static const JSOpCode opcode_info[OP_COUNT] = {
+static const JSOpCode opcode_info[OP_COUNT + (OP_TEMP_END - OP_TEMP_START)] = {
 #define FMT(f)
 #ifdef DUMP_BYTECODE
 #define DEF(id, size, n_pop, n_push, f) { #id, size, n_pop, n_push, OP_FMT_ ## f },
@@ -18231,6 +18684,18 @@ static const JSOpCode opcode_info[OP_COUNT] = {
 #undef FMT
 };
 
+#if SHORT_OPCODES
+/* After the final compilation pass, short opcodes are used. Their
+   opcodes overlap with the temporary opcodes which cannot appear in
+   the final bytecode. Their description is after the temporary
+   opcodes in opcode_info[]. */
+#define short_opcode_info(op)           \
+    opcode_info[(op) >= OP_TEMP_START ? \
+                (op) + (OP_TEMP_END - OP_TEMP_START) : (op)]
+#else
+#define short_opcode_info(op) opcode_info[op]
+#endif
+
 static __exception int next_token(JSParseState *s);
 
 static void free_token(JSParseState *s, JSToken *token)
@@ -18251,6 +18716,7 @@ static void free_token(JSParseState *s, JSToken *token)
         break;
     case TOK_IDENT:
     case TOK_FIRST_KEYWORD ... TOK_LAST_KEYWORD:
+    case TOK_PRIVATE_NAME:
         JS_FreeAtom(s->ctx, token->u.ident.atom);
         break;
     default:
@@ -18532,15 +18998,6 @@ static __exception int js_parse_string(JSParseState *s, int sep,
             if (c > 0x10FFFF)
                 goto invalid_utf8;
             p = p_next;
-#ifndef JSON_SUPERSET
-            /* LS or PS are invalid in Javascript string literals, considered
-               as line terminators, but allowed in JSON source and template
-               literals.
-               ECMA 2019 proposal json-superset removes this restriction.
-             */
-            if ((c == CP_LS || c == CP_PS) && sep != '`' && s->cur_func)
-                goto invalid_char;
-#endif
         }
         if (string_buffer_putc(b, c))
             goto fail;
@@ -18896,6 +19353,53 @@ static __exception int next_token(JSParseState *s)
             s->token.val = TOK_IDENT;
         }
         break;
+    case '#':
+        /* private name */
+        {
+            const uint8_t *p1;
+            p++;
+            q = buf;
+            *q++ = '#';
+            p1 = p;
+            c = *p1++;
+            if (c == '\\' && *p1 == 'u') {
+                c = lre_parse_escape(&p1, TRUE);
+            } else if (c >= 128) {
+                c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
+            }
+            if (!lre_js_is_ident_first(c)) {
+                js_parse_error(s, "invalid first character of private name");
+                goto fail;
+            }
+            p = p1;
+            for(;;) {
+                if (c < 128) {
+                    *q++ = c;
+                } else {
+                    q += unicode_to_utf8((uint8_t*)q, c);
+                }
+                p1 = p;
+                c = *p1++;
+                if (c == '\\' && *p1 == 'u') {
+                    c = lre_parse_escape(&p1, TRUE);
+                    ident_has_escape = TRUE;
+                } else if (c >= 128) {
+                    c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
+                }
+                /* XXX: check if c >= 0 and c <= 0x10FFFF */
+                if (!lre_js_is_ident_next(c))
+                    break;
+                p = p1;
+                if ((q - buf) >= sizeof(buf) - UTF8_CHAR_LEN_MAX) {
+                    js_parse_error(s, "private name too long");
+                    goto fail;
+                }
+            }
+            *q = '\0';
+            s->token.u.ident.atom = JS_NewAtomLen(s->ctx, buf, q - buf);
+            s->token.val = TOK_PRIVATE_NAME;
+        }
+        break;
     case '.':
         if (p[1] == '.' && p[2] == '.') {
             p += 3;
@@ -18961,7 +19465,8 @@ static __exception int next_token(JSParseState *s)
                 is_bigint = FALSE;
                 is_bigfloat = FALSE;
                 if (*p == 'n') {
-                    if (!(res & BF_ATOF_ST_INTEGER)) {
+                    if (!(res & BF_ATOF_ST_INTEGER) ||
+                        (res & BF_ATOF_ST_LEGACY_OCTAL)) {
                         bf_delete(r);
                         goto bad_number;
                     }
@@ -19552,7 +20057,8 @@ static int find_lexical_decl(JSContext *ctx, JSFunctionDef *fd, JSAtom name,
     while (scope_idx >= 0) {
         JSVarDef *vd = &fd->vars[scope_idx];
         if (vd->var_name == name &&
-            (vd->is_lexical || (vd->is_catch && check_catch_var)))
+            (vd->is_lexical || (vd->var_kind == JS_VAR_CATCH &&
+                                check_catch_var)))
             return scope_idx;
         scope_idx = vd->scope_next;
     }
@@ -19768,7 +20274,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name, int tok)
         if (idx >= 0) {
             if ((idx < GLOBAL_VAR_OFFSET &&
                  (fd->vars[idx].scope_level == fd->scope_level ||
-                  (fd->vars[idx].is_catch && (fd->vars[idx].scope_level + 2) == fd->scope_level))) ||
+                  (fd->vars[idx].var_kind == JS_VAR_CATCH && (fd->vars[idx].scope_level + 2) == fd->scope_level))) ||
                 (idx == GLOBAL_VAR_OFFSET && fd->scope_level == 1)) {
                 /* redefining a scoped var in the same scope: error */
                 return js_parse_error(s, "invalid redefinition of lexical identifier");
@@ -19827,7 +20333,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name, int tok)
         idx = add_var(ctx, fd, name);
         if (idx >= 0) {
             vd = &fd->vars[idx];
-            vd->is_catch = 1;
+            vd->var_kind = JS_VAR_CATCH;
             vd->scope_level = fd->scope_level;
             vd->scope_next = fd->scope_first;
             fd->scopes[fd->scope_level].first = idx;
@@ -19877,6 +20383,7 @@ static __exception int js_parse_function_decl(JSParseState *s,
                                               JSFunctionKindEnum func_kind,
                                               JSAtom func_name, const uint8_t *ptr,
                                               int start_line);
+static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s);
 static __exception int js_parse_function_decl2(JSParseState *s,
                                                JSParseFunctionEnum func_type,
                                                JSFunctionKindEnum func_kind,
@@ -20032,6 +20539,8 @@ static __exception int js_parse_template(JSParseState *s, int call, int *argc)
 #define PROP_TYPE_ASYNC 5
 #define PROP_TYPE_ASYNC_STAR 6
 
+#define PROP_TYPE_PRIVATE (1 << 4)
+
 static BOOL token_is_ident(int tok)
 {
     /* Accept keywords and reserved words as property names */
@@ -20043,11 +20552,13 @@ static BOOL token_is_ident(int tok)
 /* if the property is an expression, name = JS_ATOM_NULL */
 static int __exception js_parse_property_name(JSParseState *s,
                                               JSAtom *pname,
-                                              BOOL allow_method, BOOL allow_var)
+                                              BOOL allow_method, BOOL allow_var,
+                                              BOOL allow_private)
 {
+    int is_private = 0;
     JSAtom name;
     int prop_type;
-
+    
     prop_type = PROP_TYPE_IDENT;
     if (allow_method) {
         if (token_is_pseudo_keyword(s, JS_ATOM_get)
@@ -20067,8 +20578,13 @@ static int __exception js_parse_property_name(JSParseState *s,
             prop_type = PROP_TYPE_STAR;
         } else if (token_is_pseudo_keyword(s, JS_ATOM_async) &&
                    peek_token(s, TRUE) != '\n') {
+            name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
             if (next_token(s))
-                goto fail;
+                goto fail1;
+            if (s->token.val == ':' || s->token.val == ',' ||
+                s->token.val == '}' || s->token.val == '(')
+                goto done;
+            JS_FreeAtom(s->ctx, name);
             if (s->token.val == '*') {
                 if (next_token(s))
                     goto fail;
@@ -20127,6 +20643,11 @@ static int __exception js_parse_property_name(JSParseState *s,
         if (js_parse_expect(s, ']'))
             goto fail;
         name = JS_ATOM_NULL;
+    } else if (s->token.val == TOK_PRIVATE_NAME && allow_private) {
+        name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
+        if (next_token(s))
+            goto fail1;
+        is_private = PROP_TYPE_PRIVATE;
     } else {
         goto invalid_prop;
     }
@@ -20139,7 +20660,7 @@ static int __exception js_parse_property_name(JSParseState *s,
     }
  done:
     *pname = name;
-    return prop_type;
+    return prop_type | is_private;
  fail1:
     JS_FreeAtom(s->ctx, name);
  fail:
@@ -20303,7 +20824,7 @@ static __exception int js_parse_object_literal(JSParseState *s)
             goto next;
         }
 
-        prop_type = js_parse_property_name(s, &name, TRUE, TRUE);
+        prop_type = js_parse_property_name(s, &name, TRUE, TRUE, FALSE);
         if (prop_type < 0)
             goto fail;
 
@@ -20424,20 +20945,165 @@ static __exception int js_parse_class_default_ctor(JSParseState *s,
     return ret;
 }
 
+/* find field in the current scope */
+static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
+                                    JSAtom name, int scope_level)
+{
+    int idx;
+    idx = fd->scopes[scope_level].first;
+    while (idx != -1) {
+        if (fd->vars[idx].scope_level != scope_level)
+            break;
+        if (fd->vars[idx].var_name == name)
+            return idx;
+        idx = fd->vars[idx].scope_next;
+    }
+    return -1;
+}
+
+/* add field in the current scope */
+static int add_private_class_field(JSParseState *s, JSFunctionDef *fd,
+                                   JSAtom name, JSVarKindEnum var_kind)
+{
+    JSContext *ctx = s->ctx;
+    JSVarDef *vd;
+    int idx;
+
+    idx = add_var(ctx, fd, name);
+    if (idx < 0)
+        return idx;
+    vd = &fd->vars[idx];
+    vd->is_lexical = 1;
+    vd->is_const = 1;
+    vd->var_kind = var_kind;
+    vd->scope_level = fd->scope_level;
+    vd->scope_next = fd->scope_first;
+    fd->scopes[fd->scope_level].first = idx;
+    fd->scope_first = idx;
+    return idx;
+}
+
+/* initialize the class fields, called by the constructor. Note:
+   super() can be called in an arrow function, so <this> and
+   <class_fields_init> can be variable references */
+static void emit_class_field_init(JSParseState *s)
+{
+    int label_next;
+    
+    emit_op(s, OP_scope_get_var);
+    emit_atom(s, JS_ATOM_class_fields_init);
+    emit_u16(s, s->cur_func->scope_level);
+
+    /* no need to call the class field initializer if not defined */
+    emit_op(s, OP_dup);
+    label_next = emit_goto(s, OP_if_false, -1);
+    
+    emit_op(s, OP_scope_get_var);
+    emit_atom(s, JS_ATOM_this);
+    emit_u16(s, 0);
+    
+    emit_op(s, OP_swap);
+    
+    emit_op(s, OP_call_method);
+    emit_u16(s, 0);
+
+    emit_label(s, label_next);
+    emit_op(s, OP_drop);
+}
+
+/* build a private setter function name from the private getter name */
+static JSAtom get_private_setter_name(JSContext *ctx, JSAtom name)
+{
+    return js_atom_concat_str(ctx, name, "<set>");
+}
+
+typedef struct {
+    JSFunctionDef *fields_init_fd;
+    int computed_fields_count;
+    BOOL has_brand;
+    int brand_push_pos;
+} ClassFieldsDef;
+
+static __exception int emit_class_init_start(JSParseState *s,
+                                             ClassFieldsDef *cf)
+{
+    int label_add_brand;
+    
+    cf->fields_init_fd = js_parse_function_class_fields_init(s);
+    if (!cf->fields_init_fd)
+        return -1;
+
+    s->cur_func = cf->fields_init_fd;
+    
+    /* XXX: would be better to add the code only if needed, maybe in a
+       later pass */
+    emit_op(s, OP_push_false); /* will be patched later */
+    cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
+    label_add_brand = emit_goto(s, OP_if_false, -1);
+    
+    emit_op(s, OP_scope_get_var);
+    emit_atom(s, JS_ATOM_this);
+    emit_u16(s, 0);
+    
+    emit_op(s, OP_scope_get_var);
+    emit_atom(s, JS_ATOM_home_object);
+    emit_u16(s, 0);
+    
+    emit_op(s, OP_add_brand);
+    
+    emit_label(s, label_add_brand);
+
+    s->cur_func = s->cur_func->parent;
+    return 0;
+}
+
+static __exception int add_brand(JSParseState *s, ClassFieldsDef *cf)
+{
+    if (!cf->has_brand) {
+        /* define the brand field in 'this' of the initializer */
+        if (!cf->fields_init_fd) {
+            if (emit_class_init_start(s, cf))
+                return -1;
+        }
+        /* patch the start of the function to enable the OP_add_brand code */
+        cf->fields_init_fd->byte_code.buf[cf->brand_push_pos] = OP_push_true;
+        
+        cf->has_brand = TRUE;
+    }
+    return 0;
+}
+
+static void emit_class_init_end(JSParseState *s, ClassFieldsDef *cf)
+{
+    int cpool_idx;
+        
+    s->cur_func = cf->fields_init_fd;
+    emit_op(s, OP_return_undef);
+    s->cur_func = s->cur_func->parent;
+    
+    cpool_idx = cpool_add(s, JS_NULL);
+    cf->fields_init_fd->parent_cpool_idx = cpool_idx;
+    emit_op(s, OP_fclosure);
+    emit_u32(s, cpool_idx);
+    emit_op(s, OP_set_home_object);
+}
+
+
 static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                                       JSParseExportEnum export_flag)
 {
     JSContext *ctx = s->ctx;
     JSFunctionDef *fd = s->cur_func;
-    JSAtom name = JS_ATOM_NULL, class_name = JS_ATOM_NULL;
+    JSAtom name = JS_ATOM_NULL, class_name = JS_ATOM_NULL, class_name1;
     JSAtom class_var_name = JS_ATOM_NULL;
     JSFunctionDef *method_fd, *ctor_fd;
     int saved_js_mode, class_name_var_idx, prop_type, ctor_cpool_offset;
-    int class_flags = 0;
-    BOOL is_static;
+    int class_flags = 0, i;
+    BOOL is_static, is_private;
     const uint8_t *class_start_ptr = s->token.ptr;
     const uint8_t *start_ptr;
-
+    ClassFieldsDef class_fields[2];
+        
     /* classes are parsed and executed in strict mode */
     saved_js_mode = fd->js_mode;
     fd->js_mode |= JS_MODE_STRICT;
@@ -20486,13 +21152,29 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     if (js_parse_expect(s, '{'))
         goto fail;
 
+    /* this scope contains the private fields */
+    push_scope(s);
+
     emit_op(s, OP_push_const);
     ctor_cpool_offset = fd->byte_code.size;
     emit_u32(s, 0); /* will be patched at the end of the class parsing */
 
+    if (class_var_name != JS_ATOM_NULL && class_name == JS_ATOM_NULL)
+        class_name1 = JS_ATOM_default;
+    else
+        class_name1 = class_name;
+    
     emit_op(s, OP_define_class);
+    emit_atom(s, class_name1);
     emit_u8(s, class_flags);
 
+    for(i = 0; i < 2; i++) {
+        ClassFieldsDef *cf = &class_fields[i];
+        cf->fields_init_fd = NULL;
+        cf->computed_fields_count = 0;
+        cf->has_brand = FALSE;
+    }
+    
     ctor_fd = NULL;
     while (s->token.val != '}') {
         if (s->token.val == ';') {
@@ -20508,33 +21190,169 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         if (is_static)
             emit_op(s, OP_swap);
         start_ptr = s->token.ptr;
-        prop_type = js_parse_property_name(s, &name, TRUE, FALSE);
+        prop_type = js_parse_property_name(s, &name, TRUE, FALSE, TRUE);
         if (prop_type < 0)
             goto fail;
-
+        is_private = prop_type & PROP_TYPE_PRIVATE;
+        prop_type &= ~PROP_TYPE_PRIVATE;
+        
         if ((name == JS_ATOM_constructor && !is_static &&
              prop_type != PROP_TYPE_IDENT) ||
-            (name == JS_ATOM_prototype && is_static)) {
+            (name == JS_ATOM_prototype && is_static) ||
+            name == JS_ATOM_hash_constructor) {
             js_parse_error(s, "invalid method name");
             goto fail;
         }
         if (prop_type == PROP_TYPE_GET || prop_type == PROP_TYPE_SET) {
             BOOL is_set = prop_type - PROP_TYPE_GET;
-            if (js_parse_function_decl(s, JS_PARSE_FUNC_GETTER + is_set,
-                                       JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                       start_ptr, s->token.line_num))
+            JSFunctionDef *method_fd;
+
+            if (is_private) {
+                int idx, var_kind;
+                idx = find_private_class_field(ctx, fd, name, fd->scope_level);
+                if (idx >= 0) {
+                    var_kind = fd->vars[idx].var_kind;
+                    if (var_kind == JS_VAR_PRIVATE_FIELD ||
+                        var_kind == JS_VAR_PRIVATE_METHOD ||
+                        var_kind == JS_VAR_PRIVATE_GETTER_SETTER ||
+                        var_kind == (JS_VAR_PRIVATE_GETTER + is_set)) {
+                        goto private_field_already_defined;
+                    }
+                    fd->vars[idx].var_kind = JS_VAR_PRIVATE_GETTER_SETTER;
+                } else {
+                    if (add_private_class_field(s, fd, name,
+                                                JS_VAR_PRIVATE_GETTER + is_set) < 0)
+                        goto fail;
+                }
+                if (add_brand(s, &class_fields[is_static]) < 0)
+                    goto fail;
+            }
+
+            if (js_parse_function_decl2(s, JS_PARSE_FUNC_GETTER + is_set,
+                                        JS_FUNC_NORMAL, JS_ATOM_NULL,
+                                        start_ptr, s->token.line_num,
+                                        JS_PARSE_EXPORT_NONE, &method_fd))
                 goto fail;
+            if (is_private) {
+                method_fd->need_home_object = TRUE; /* needed for brand check */
+                emit_op(s, OP_set_home_object);
+                /* XXX: missing function name */
+                emit_op(s, OP_scope_put_var_init);
+                if (is_set) {
+                    JSAtom setter_name;
+                    int ret;
+                    
+                    setter_name = get_private_setter_name(ctx, name);
+                    if (setter_name == JS_ATOM_NULL)
+                        goto fail;
+                    emit_atom(s, setter_name);
+                    ret = add_private_class_field(s, fd, setter_name,
+                                                  JS_VAR_PRIVATE_SETTER);
+                    JS_FreeAtom(ctx, setter_name);
+                    if (ret < 0)
+                        goto fail;
+                } else {
+                    emit_atom(s, name);
+                }
+                emit_u16(s, s->cur_func->scope_level);
+            } else {
+                if (name == JS_ATOM_NULL) {
+                    emit_op(s, OP_define_method_computed);
+                } else {
+                    emit_op(s, OP_define_method);
+                    emit_atom(s, name);
+                }
+                emit_u8(s, OP_DEFINE_METHOD_GETTER + is_set);
+            }
+        } else if (prop_type == PROP_TYPE_IDENT && s->token.val != '(') {
+            ClassFieldsDef *cf = &class_fields[is_static];
+            JSAtom field_var_name = JS_ATOM_NULL;
+            
+            /* class field */
+
+            /* XXX: spec: not consistent with method name checks */
+            if (name == JS_ATOM_constructor || name == JS_ATOM_prototype) {
+                js_parse_error(s, "invalid field name");
+                goto fail;
+            }
+            
+            if (is_private) {
+                if (find_private_class_field(ctx, fd, name,
+                                             fd->scope_level) >= 0) {
+                    goto private_field_already_defined;
+                }
+                if (add_private_class_field(s, fd, name,
+                                            JS_VAR_PRIVATE_FIELD) < 0)
+                    goto fail;
+                emit_op(s, OP_private_symbol);
+                emit_atom(s, name);
+                emit_op(s, OP_scope_put_var_init);
+                emit_atom(s, name);
+                emit_u16(s, s->cur_func->scope_level);
+            }
+
+            if (!cf->fields_init_fd) {
+                if (emit_class_init_start(s, cf))
+                    goto fail;
+            }
+            if (name == JS_ATOM_NULL ) {
+                /* save the computed field name into a variable */
+                field_var_name = js_atom_concat_num(ctx, JS_ATOM_computed_field + is_static, cf->computed_fields_count);
+                if (field_var_name == JS_ATOM_NULL)
+                    goto fail;
+                if (define_var(s, fd, field_var_name, TOK_CONST) < 0) {
+                    JS_FreeAtom(ctx, field_var_name);
+                    goto fail;
+                }
+                emit_op(s, OP_to_propkey);
+                emit_op(s, OP_scope_put_var_init);
+                emit_atom(s, field_var_name);
+                emit_u16(s, s->cur_func->scope_level);
+            }
+            s->cur_func = cf->fields_init_fd;
+            emit_op(s, OP_scope_get_var);
+            emit_atom(s, JS_ATOM_this);
+            emit_u16(s, 0);
+
             if (name == JS_ATOM_NULL) {
-                emit_op(s, OP_define_method_computed);
+                emit_op(s, OP_scope_get_var);
+                emit_atom(s, field_var_name);
+                emit_u16(s, s->cur_func->scope_level);
+                cf->computed_fields_count++;
+                JS_FreeAtom(ctx, field_var_name);
+            } else if (is_private) {
+                emit_op(s, OP_scope_get_var);
+                emit_atom(s, name);
+                emit_u16(s, s->cur_func->scope_level);
+            }
+            
+            if (s->token.val == '=') {
+                if (next_token(s))
+                    goto fail;
+                if (js_parse_assign_expr(s, TRUE))
+                    goto fail;
             } else {
-                emit_op(s, OP_define_method);
+                emit_op(s, OP_undefined);
+            }
+            if (is_private) {
+                set_object_name_computed(s);
+                emit_op(s, OP_define_private_field);
+            } else if (name == JS_ATOM_NULL) {
+                set_object_name_computed(s);
+                emit_op(s, OP_define_array_el);
+                emit_op(s, OP_drop);
+            } else {
+                set_object_name(s, name);
+                emit_op(s, OP_define_field);
                 emit_atom(s, name);
             }
-            emit_u8(s, OP_DEFINE_METHOD_GETTER + is_set);
+            s->cur_func = s->cur_func->parent;
+            if (js_parse_expect_semi(s))
+                goto fail;
         } else {
             JSParseFunctionEnum func_type;
             JSFunctionKindEnum func_kind;
-
+            
             func_type = JS_PARSE_FUNC_METHOD;
             func_kind = JS_FUNC_NORMAL;
             if (prop_type == PROP_TYPE_STAR) {
@@ -20553,11 +21371,32 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 else
                     func_type = JS_PARSE_FUNC_CLASS_CONSTRUCTOR;
             }
+            if (is_private) {
+                if (add_brand(s, &class_fields[is_static]) < 0)
+                    goto fail;
+            }
             if (js_parse_function_decl2(s, func_type, func_kind, JS_ATOM_NULL, start_ptr, s->token.line_num, JS_PARSE_EXPORT_NONE, &method_fd))
                 goto fail;
             if (func_type == JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR ||
                 func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
                 ctor_fd = method_fd;
+            } else if (is_private) {
+                method_fd->need_home_object = TRUE; /* needed for brand check */
+                if (find_private_class_field(ctx, fd, name,
+                                             fd->scope_level) >= 0) {
+                private_field_already_defined:
+                    js_parse_error(s, "private class field is already defined");
+                    goto fail;
+                }
+                if (add_private_class_field(s, fd, name,
+                                            JS_VAR_PRIVATE_METHOD) < 0)
+                    goto fail;
+                emit_op(s, OP_set_home_object);
+                emit_op(s, OP_set_name);
+                emit_atom(s, name);
+                emit_op(s, OP_scope_put_var_init);
+                emit_atom(s, name);
+                emit_u16(s, s->cur_func->scope_level);
             } else {
                 if (name == JS_ATOM_NULL) {
                     emit_op(s, OP_define_method_computed);
@@ -20579,9 +21418,6 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         goto fail;
     }
 
-    /* drop the prototype */
-    emit_op(s, OP_drop);
-
     if (!ctor_fd) {
         if (js_parse_class_default_ctor(s, class_flags & JS_DEFINE_CLASS_HAS_HERITAGE, &ctor_fd))
             goto fail;
@@ -20603,6 +21439,38 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     if (next_token(s))
         goto fail;
 
+    /* store the function to initialize the fields to that it can be
+       referenced by the constructor */
+    {
+        ClassFieldsDef *cf = &class_fields[0];
+        int var_idx;
+        
+        var_idx = define_var(s, fd, JS_ATOM_class_fields_init, TOK_CONST);
+        if (var_idx < 0)
+            goto fail;
+        if (cf->fields_init_fd) {
+            emit_class_init_end(s, cf);
+        } else {
+            emit_op(s, OP_undefined);
+        }
+        emit_op(s, OP_scope_put_var_init);
+        emit_atom(s, JS_ATOM_class_fields_init);
+        emit_u16(s, s->cur_func->scope_level);
+    }
+
+    /* drop the prototype */
+    emit_op(s, OP_drop);
+
+    /* initialize the static fields */
+    if (class_fields[1].fields_init_fd != NULL) {
+        ClassFieldsDef *cf = &class_fields[1];
+        emit_op(s, OP_dup);
+        emit_class_init_end(s, cf);
+        emit_op(s, OP_call_method);
+        emit_u16(s, 0);
+        emit_op(s, OP_drop);
+    }
+    
     if (class_name != JS_ATOM_NULL) {
         /* store the class name in the scoped class name variable (it
            is independent from the class statement variable
@@ -20613,28 +21481,23 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         emit_u16(s, fd->scope_level);
     }
     pop_scope(s);
+    pop_scope(s);
 
     /* the class statements have a block level scope */
     if (class_var_name != JS_ATOM_NULL) {
-        emit_op(s, OP_set_name);
-        if (class_name == JS_ATOM_NULL) {
-            /* only happens when export_flag == JS_PARSE_EXPORT_DEFAULT */
-            emit_atom(s, JS_ATOM_default);
-        } else {
-            emit_atom(s, class_name);
-        }
         if (define_var(s, fd, class_var_name, TOK_LET) < 0)
             goto fail;
         emit_op(s, OP_scope_put_var_init);
         emit_atom(s, class_var_name);
         emit_u16(s, fd->scope_level);
     } else {
-        emit_op(s, OP_set_name);
-        emit_atom(s, class_name);
-        /* if class_name = JS_ATOM_NULL, it will be set upon storing into
-           a named variable or property */
-        if (class_name != JS_ATOM_NULL)
-            fd->last_opcode_pos = -1;
+        if (class_name == JS_ATOM_NULL) {
+            /* XXX: should be done before calling the initializers. It
+               could be done with a specific opcode to patch the code
+               before */
+            emit_op(s, OP_set_name);
+            emit_atom(s, class_name); /* will be patched by assignment */
+        }
     }
 
     if (export_flag != JS_PARSE_EXPORT_NONE) {
@@ -20842,6 +21705,11 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
         name = get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
         depth = 1;
         break;
+    case OP_scope_get_private_field:
+        name = get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
+        scope = get_u16(fd->byte_code.buf + fd->last_opcode_pos + 5);
+        depth = 1;
+        break;
     case OP_get_array_el:
         depth = 2;
         break;
@@ -20881,6 +21749,11 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
             emit_op(s, OP_get_field2);
             emit_atom(s, name);
             break;
+        case OP_scope_get_private_field:
+            emit_op(s, OP_scope_get_private_field2);
+            emit_atom(s, name);
+            emit_u16(s, scope);
+            break;
         case OP_get_array_el:
             /* XXX: replace by a single opcode ? */
             emit_op(s, OP_to_propkey2);
@@ -20940,6 +21813,15 @@ static void put_lvalue(JSParseState *s, int opcode, int scope,
         emit_op(s, OP_put_field);
         emit_u32(s, name);  /* name has refcount */
         break;
+    case OP_scope_get_private_field:
+        if (!special)
+            emit_op(s, OP_insert2); /* obj v -> v obj v */
+        else
+            emit_op(s, OP_perm3); /* obj v0 v -> v0 obj v */
+        emit_op(s, OP_scope_put_private_field);
+        emit_u32(s, name);  /* name has refcount */
+        emit_u16(s, scope);
+        break;
     case OP_get_array_el:
         if (!special)
             emit_op(s, OP_insert3); /* obj prop v -> v obj prop v */
@@ -20968,6 +21850,43 @@ static void put_lvalue(JSParseState *s, int opcode, int scope,
     }
 }
 
+static void put_lvalue_nokeep(JSParseState *s, int opcode, int scope,
+                              JSAtom name, int label, int var_tok)
+{
+    switch(opcode) {
+    case OP_scope_get_var:  /* val -- */
+        emit_op(s, (var_tok == TOK_CONST || var_tok == TOK_LET) ?
+                OP_scope_put_var_init : OP_scope_put_var);
+        emit_u32(s, name);  /* has refcount */
+        emit_u16(s, scope);
+        break;
+    case OP_get_field:      /* obj val -- */
+        emit_op(s, OP_put_field);
+        emit_u32(s, name);  /* has refcount */
+        break;
+    case OP_scope_get_private_field:
+        emit_op(s, OP_scope_put_private_field);
+        emit_u32(s, name);  /* has refcount */
+        emit_u16(s, scope);
+        break;
+    case OP_get_array_el:   /* obj prop val -- */
+        emit_op(s, OP_put_array_el);
+        break;
+    case OP_get_ref_value:   /* obj prop val -- */
+        /* XXX: currently this reference is never optimized */
+        JS_FreeAtom(s->ctx, name);
+        emit_label(s, label);
+        //emit_op(s, OP_nop);   /* emit 2 bytes for optimizer */
+        emit_op(s, OP_put_ref_value);
+        break;
+    case OP_get_super_value:
+        emit_op(s, OP_put_super_value);
+        break;
+    default:
+        abort();
+    }
+}
+
 static __exception int js_parse_expr_paren(JSParseState *s)
 {
     if (js_parse_expect(s, '('))
@@ -21150,7 +22069,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                 emit_u8(s, 0 | ((depth_lvalue + 1) << 2) | ((depth_lvalue + 2) << 5));
                 goto set_val;
             }
-            prop_type = js_parse_property_name(s, &prop_name, FALSE, TRUE);
+            prop_type = js_parse_property_name(s, &prop_name, FALSE, TRUE, FALSE);
             if (prop_type < 0)
                 return -1;
             var_name = JS_ATOM_NULL;
@@ -21161,7 +22080,9 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
             if (prop_type == PROP_TYPE_IDENT) {
                 if (next_token(s))
                     goto prop_error;
-                if (s->token.val == '[' || s->token.val == '{') {
+                if ((s->token.val == '[' || s->token.val == '{')
+                    &&  ((tok1 = js_parse_skip_parens_token(s, &skip_bits, FALSE)) == ',' ||
+                         tok1 == '=' || tok1 == '}')) {
                     if (prop_name == JS_ATOM_NULL) {
                         /* computed property name on stack */
                         if (has_ellipsis) {
@@ -21330,34 +22251,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                 emit_label(s, label_hasval);
             }
             /* store value into lvalue object */
-            /* XXX: should use put_lvalue() with tok and no_keep */
-            switch(opcode) {
-            case OP_scope_get_var:  /* val -- */
-                emit_op(s, (tok == TOK_CONST || tok == TOK_LET) ?
-                        OP_scope_put_var_init : OP_scope_put_var);
-                emit_u32(s, var_name);  /* has refcount */
-                emit_u16(s, scope);
-                break;
-            case OP_get_field:      /* obj val -- */
-                emit_op(s, OP_put_field);
-                emit_u32(s, var_name);  /* has refcount */
-                break;
-            case OP_get_array_el:   /* obj prop val -- */
-                emit_op(s, OP_put_array_el);
-                break;
-            case OP_get_ref_value:   /* obj prop val -- */
-                /* XXX: currently this reference is never optimized */
-                JS_FreeAtom(s->ctx, var_name);
-                emit_label(s, label_lvalue);
-                //emit_op(s, OP_nop);   /* emit 2 bytes for optimizer */
-                emit_op(s, OP_put_ref_value);
-                break;
-            case OP_get_super_value:
-                emit_op(s, OP_put_super_value);
-                break;
-            default:
-                abort();
-            }
+            put_lvalue_nokeep(s, opcode, scope, var_name, label_lvalue, tok);
             if (s->token.val == '}')
                 break;
             /* accept a trailing comma before the '}' */
@@ -21457,34 +22351,8 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                     emit_label(s, label_hasval);
                 }
                 /* store value into lvalue object */
-                /* XXX: should use put_lvalue() with tok and no_keep */
-                switch(opcode) {
-                case OP_scope_get_var:  /* enum_rec val -- enum_rec */
-                    emit_op(s, (tok == TOK_CONST || tok == TOK_LET) ?
-                            OP_scope_put_var_init : OP_scope_put_var);
-                    emit_u32(s, var_name); /* has refcount */
-                    emit_u16(s, scope);
-                    break;
-                case OP_get_field:      /* enum_rec obj val -- enum_rec */
-                    emit_op(s, OP_put_field);
-                    emit_u32(s, var_name); /* has refcount */
-                    break;
-                case OP_get_array_el:   /* enum_rec obj prop val -- enum_rec */
-                    emit_op(s, OP_put_array_el);
-                    break;
-                case OP_get_ref_value:   /* enum_rec obj prop val -- enum_rec */
-                    /* XXX: this reference is not optimized for global vars */
-                    JS_FreeAtom(s->ctx, var_name);
-                    emit_label(s, label_lvalue);
-                    //emit_op(s, OP_nop);   /* emit 2 bytes for optimizer */
-                    emit_op(s, OP_put_ref_value);
-                    break;
-                case OP_get_super_value:   /* enum_rec this obj prop val -- enum_rec */
-                    emit_op(s, OP_put_super_value);
-                    break;
-                default:
-                    abort();
-                }
+                put_lvalue_nokeep(s, opcode, scope, var_name,
+                                  label_lvalue, tok);
             }
             if (s->token.val == ']')
                 break;
@@ -21714,6 +22582,11 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     goto do_get_var;
                 }
             } else {
+                if (s->token.u.ident.atom == JS_ATOM_arguments &&
+                    !s->cur_func->arguments_allowed) {
+                    js_parse_error(s, "'arguments' identifier is not allowed in class field initializer");
+                    return -1;
+                }
                 name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
                 if (next_token(s))  /* update line number before emitting code */
                     return -1;
@@ -21832,6 +22705,10 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
                     break;
+                case OP_scope_get_private_field:
+                    /* keep the object on the stack */
+                    fd->byte_code.buf[fd->last_opcode_pos] = OP_scope_get_private_field2;
+                    break;
                 case OP_get_array_el:
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
@@ -21974,6 +22851,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 /* apply function call */
                 switch(opcode) {
                 case OP_get_field:
+                case OP_scope_get_private_field:
                 case OP_get_array_el:
                 case OP_scope_get_ref:
                     /* obj func array -> func obj array */
@@ -21998,6 +22876,8 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         emit_op(s, OP_scope_put_var_init);
                         emit_atom(s, JS_ATOM_this);
                         emit_u16(s, 0);
+
+                        emit_class_field_init(s);
                     } else if (call_type == FUNC_CALL_NEW) {
                         /* obj func array -> func obj array */
                         emit_op(s, OP_perm3);
@@ -22018,6 +22898,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             emit_func_call:
                 switch(opcode) {
                 case OP_get_field:
+                case OP_scope_get_private_field:
                 case OP_get_array_el:
                 case OP_scope_get_ref:
                     emit_op(s, OP_call_method);
@@ -22050,6 +22931,8 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         emit_op(s, OP_scope_put_var_init);
                         emit_atom(s, JS_ATOM_this);
                         emit_u16(s, 0);
+
+                        emit_class_field_init(s);
                     } else if (call_type == FUNC_CALL_NEW) {
                         emit_op(s, OP_call_constructor);
                         emit_u16(s, arg_count);
@@ -22064,21 +22947,31 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         } else if (s->token.val == '.') {
             if (next_token(s))
                 return -1;
-            if (!token_is_ident(s->token.val)) {
-                return js_parse_error(s, "expecting field name");
-            }
-            if (get_prev_opcode(fd) == OP_get_super) {
-                JSValue val;
-                int ret;
-                val = JS_AtomToValue(s->ctx, s->token.u.ident.atom);
-                ret = emit_push_const(s, val, 1);
-                JS_FreeValue(s->ctx, val);
-                if (ret)
-                    return -1;
-                emit_op(s, OP_get_super_value);
-            } else {
-                emit_op(s, OP_get_field);
+            if (s->token.val == TOK_PRIVATE_NAME) {
+                /* private class field */
+                if (get_prev_opcode(fd) == OP_get_super) {
+                    return js_parse_error(s, "private class field forbidden after super");
+                }
+                emit_op(s, OP_scope_get_private_field);
                 emit_atom(s, s->token.u.ident.atom);
+                emit_u16(s, s->cur_func->scope_level);
+            } else {
+                if (!token_is_ident(s->token.val)) {
+                    return js_parse_error(s, "expecting field name");
+                }
+                if (get_prev_opcode(fd) == OP_get_super) {
+                    JSValue val;
+                    int ret;
+                    val = JS_AtomToValue(s->ctx, s->token.u.ident.atom);
+                    ret = emit_push_const(s, val, 1);
+                    JS_FreeValue(s->ctx, val);
+                    if (ret)
+                        return -1;
+                    emit_op(s, OP_get_super_value);
+                } else {
+                    emit_op(s, OP_get_field);
+                    emit_atom(s, s->token.u.ident.atom);
+                }
             }
             if (next_token(s))
                 return -1;
@@ -22157,6 +23050,8 @@ static __exception int js_parse_delete(JSParseState *s)
             fd->byte_code.buf[fd->last_opcode_pos] = OP_scope_delete_var;
         }
         break;
+    case OP_scope_get_private_field:
+        return js_parse_error(s, "cannot delete a private class field");
     default:
     ret_true:
         emit_op(s, OP_drop);
@@ -23152,41 +24047,29 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
             if (js_parse_destructing_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                 return -1;
         } else {
-            int lvalue_label;
+            int lvalue_label, depth;
             if (js_parse_postfix_expr(s, TRUE))
                 return -1;
-            if (get_lvalue(s, &opcode, &scope, &var_name, &lvalue_label, NULL, FALSE, TOK_FOR))
+            if (get_lvalue(s, &opcode, &scope, &var_name, &lvalue_label,
+                           &depth, FALSE, TOK_FOR))
                 return -1;
             /* swap value and lvalue object and store it into lvalue object */
-            /* cannot use put_lvalue() */
-            switch(opcode) {
-            case OP_get_field:
-                /* enum_rec val obj -- enum_rec */
+            /* enum_rec val [depth] -- enum_rec */
+            switch(depth) {
+            case 1:
                 emit_op(s, OP_swap);
-                emit_op(s, OP_put_field);
-                emit_u32(s, var_name);  /* has refcount */
-                break;
-            case OP_get_array_el:
-                /* enum_rec val obj prop -- enum_rec obj prop val */
-                emit_op(s, OP_rot3l);
-                /* enum_obj obj prop val -- enum_obj */
-                emit_op(s, OP_put_array_el);
                 break;
-            case OP_get_ref_value:
-                JS_FreeAtom(s->ctx, var_name);
-                emit_label(s, lvalue_label);
-                /* enum_rec val obj prop -- enum_rec obj prop val */
+            case 2:
                 emit_op(s, OP_rot3l);
-                emit_op(s, OP_put_ref_value);
                 break;
-            case OP_get_super_value:
-                /* enum_rec val this obj prop -- enum_rec this obj prop val */
+            case 3:
                 emit_op(s, OP_rot4l);
-                emit_op(s, OP_put_super_value);
                 break;
             default:
                 abort();
             }
+            put_lvalue_nokeep(s, opcode, scope, var_name, lvalue_label,
+                              TOK_FOR /* not used */);
         }
         var_name = JS_ATOM_NULL;
     }
@@ -25393,7 +26276,8 @@ static __exception int js_parse_export(JSParseState *s)
 static int add_closure_var(JSContext *ctx, JSFunctionDef *s,
                            BOOL is_local, BOOL is_arg,
                            int var_idx, JSAtom var_name,
-                           BOOL is_const, BOOL is_lexical, BOOL is_catch);
+                           BOOL is_const, BOOL is_lexical,
+                           JSVarKindEnum var_kind);
 
 static int add_import(JSParseState *s, JSModuleDef *m,
                       JSAtom local_name, JSAtom import_name)
@@ -25627,16 +26511,23 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
 }
 
 static void free_bytecode_atoms(JSRuntime *rt,
-                                const uint8_t *bc_buf, int bc_len)
+                                const uint8_t *bc_buf, int bc_len,
+                                BOOL use_short_opcodes)
 {
     int pos, len, op;
     JSAtom atom;
-
+    const JSOpCode *oi;
+    
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
-        len = opcode_info[op].size;
-        switch(opcode_info[op].fmt) {
+        if (use_short_opcodes)
+            oi = &short_opcode_info(op);
+        else
+            oi = &opcode_info[op];
+            
+        len = oi->size;
+        switch(oi->fmt) {
         case OP_FMT_atom:
         case OP_FMT_atom_u8:
         case OP_FMT_atom_u16:
@@ -25664,7 +26555,8 @@ static void js_free_function_def(JSContext *ctx, JSFunctionDef *fd)
         js_free_function_def(ctx, fd1);
     }
 
-    free_bytecode_atoms(ctx->rt, fd->byte_code.buf, fd->byte_code.size);
+    free_bytecode_atoms(ctx->rt, fd->byte_code.buf, fd->byte_code.size,
+                        fd->use_short_opcodes);
     dbuf_free(&fd->byte_code);
     js_free(ctx, fd->jump_slots);
     js_free(ctx, fd->label_slots);
@@ -25749,13 +26641,18 @@ static void dump_byte_code(JSContext *ctx, int pass,
     const JSOpCode *oi;
     int pos, pos_next, op, size, idx, addr, line, line1, in_source;
     uint8_t *bits = js_mallocz(ctx, len * sizeof(*bits));
+    BOOL use_short_opcodes = (b != NULL);
 
     /* scan for jump targets */
     for (pos = 0; pos < len; pos = pos_next) {
         op = tab[pos];
-        pos_next = pos + opcode_info[op].size;
+        if (use_short_opcodes)
+            oi = &short_opcode_info(op);
+        else
+            oi = &opcode_info[op];
+        pos_next = pos + oi->size;
         if (op < OP_COUNT) {
-            switch (opcode_info[op].fmt) {
+            switch (oi->fmt) {
 #if SHORT_OPCODES
             case OP_FMT_label8:
                 pos++;
@@ -25821,7 +26718,10 @@ static void dump_byte_code(JSContext *ctx, int pass,
             pos++;
             continue;
         }
-        oi = &opcode_info[op];
+        if (use_short_opcodes)
+            oi = &short_opcode_info(op);
+        else
+            oi = &opcode_info[op];
         size = oi->size;
         if (pos + size > len) {
             printf("truncated opcode (0x%02x)\n", op);
@@ -26077,7 +26977,7 @@ static __attribute__((unused)) void js_dump_function_bytecode(JSContext *ctx, JS
         for(i = 0; i < b->var_count; i++) {
             JSVarDef *vd = &b->vardefs[b->arg_count + i];
             printf("%5d: %s %s", i,
-                   vd->is_catch ? "catch" :
+                   vd->var_kind == JS_VAR_CATCH ? "catch" :
                    vd->is_function ? "function" :
                    vd->is_const ? "const" :
                    vd->is_lexical ? "let" : "var",
@@ -26119,7 +27019,8 @@ static __attribute__((unused)) void js_dump_function_bytecode(JSContext *ctx, JS
 static int add_closure_var(JSContext *ctx, JSFunctionDef *s,
                            BOOL is_local, BOOL is_arg,
                            int var_idx, JSAtom var_name,
-                           BOOL is_const, BOOL is_lexical, BOOL is_catch)
+                           BOOL is_const, BOOL is_lexical,
+                           JSVarKindEnum var_kind)
 {
     JSClosureVar *cv;
 
@@ -26148,7 +27049,7 @@ static int add_closure_var(JSContext *ctx, JSFunctionDef *s,
     cv->is_arg = is_arg;
     cv->is_const = is_const;
     cv->is_lexical = is_lexical;
-    cv->is_catch = is_catch;
+    cv->var_kind = var_kind;
     cv->var_idx = var_idx;
     cv->var_name = JS_DupAtom(ctx, var_name);
     return s->closure_var_count - 1;
@@ -26172,14 +27073,15 @@ static int find_closure_var(JSContext *ctx, JSFunctionDef *s,
 static int get_closure_var2(JSContext *ctx, JSFunctionDef *s,
                             JSFunctionDef *fd, BOOL is_local,
                             BOOL is_arg, int var_idx, JSAtom var_name,
-                            BOOL is_const, BOOL is_lexical, BOOL is_catch)
+                            BOOL is_const, BOOL is_lexical,
+                            JSVarKindEnum var_kind)
 {
     int i;
 
     if (fd != s->parent) {
         var_idx = get_closure_var2(ctx, s->parent, fd, is_local,
                                    is_arg, var_idx, var_name,
-                                   is_const, is_lexical, is_catch);
+                                   is_const, is_lexical, var_kind);
         if (var_idx < 0)
             return -1;
         is_local = FALSE;
@@ -26191,17 +27093,18 @@ static int get_closure_var2(JSContext *ctx, JSFunctionDef *s,
             return i;
     }
     return add_closure_var(ctx, s, is_local, is_arg, var_idx, var_name,
-                           is_const, is_lexical, is_catch);
+                           is_const, is_lexical, var_kind);
 }
 
 static int get_closure_var(JSContext *ctx, JSFunctionDef *s,
                            JSFunctionDef *fd, BOOL is_arg,
                            int var_idx, JSAtom var_name,
                            BOOL is_const, BOOL is_lexical,
-                           BOOL is_catch)
+                           JSVarKindEnum var_kind)
 {
     return get_closure_var2(ctx, s, fd, TRUE, is_arg,
-                            var_idx, var_name, is_const, is_lexical, is_catch);
+                            var_idx, var_name, is_const, is_lexical,
+                            var_kind);
 }
 
 static int get_with_scope_opcode(int op)
@@ -26599,7 +27502,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                 break;
             } else if (vd->var_name == JS_ATOM__with_ && !is_pseudo_var) {
                 vd->is_captured = 1;
-                idx = get_closure_var(ctx, s, fd, FALSE, idx, vd->var_name, FALSE, FALSE, FALSE);
+                idx = get_closure_var(ctx, s, fd, FALSE, idx, vd->var_name, FALSE, FALSE, JS_VAR_NORMAL);
                 if (idx >= 0) {
                     dbuf_putc(bc, OP_get_var_ref);
                     dbuf_put_u16(bc, idx);
@@ -26645,7 +27548,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
             fd->vars[fd->var_object_idx].is_captured = 1;
             idx = get_closure_var(ctx, s, fd, FALSE,
                                   fd->var_object_idx, JS_ATOM__var_,
-                                  FALSE, FALSE, FALSE);
+                                  FALSE, FALSE, JS_VAR_NORMAL);
             dbuf_putc(bc, OP_get_var_ref);
             dbuf_put_u16(bc, idx);
             dbuf_putc(bc, get_with_scope_opcode(op));
@@ -26675,7 +27578,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                                            FALSE,
                                            cv->is_arg, idx1,
                                            cv->var_name, cv->is_const,
-                                           cv->is_lexical, cv->is_catch);
+                                           cv->is_lexical, cv->var_kind);
                 } else {
                     idx = idx1;
                 }
@@ -26687,7 +27590,8 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                     idx = get_closure_var2(ctx, s, fd,
                                            FALSE,
                                            cv->is_arg, idx1,
-                                           cv->var_name, FALSE, FALSE, FALSE);
+                                           cv->var_name, FALSE, FALSE,
+                                           JS_VAR_NORMAL);
                 } else {
                     idx = idx1;
                 }
@@ -26710,7 +27614,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
             fd->args[var_idx - ARGUMENT_VAR_OFFSET].is_captured = 1;
             idx = get_closure_var(ctx, s, fd,
                                   TRUE, var_idx - ARGUMENT_VAR_OFFSET,
-                                  var_name, FALSE, FALSE, FALSE);
+                                  var_name, FALSE, FALSE, JS_VAR_NORMAL);
         } else {
             fd->vars[var_idx].is_captured = 1;
             idx = get_closure_var(ctx, s, fd,
@@ -26718,7 +27622,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                                   var_name,
                                   fd->vars[var_idx].is_const,
                                   fd->vars[var_idx].is_lexical,
-                                  fd->vars[var_idx].is_catch);
+                                  fd->vars[var_idx].var_kind);
         }
         if (idx >= 0) {
         has_idx:
@@ -26844,6 +27748,190 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
     return pos_next;
 }
 
+/* search in all scopes */
+static int find_private_class_field_all(JSContext *ctx, JSFunctionDef *fd,
+                                        JSAtom name, int scope_level)
+{
+    int idx;
+
+    idx = fd->scopes[scope_level].first;
+    while (idx >= 0) {
+        if (fd->vars[idx].var_name == name)
+            return idx;
+        idx = fd->vars[idx].scope_next;
+    }
+    return -1;
+}
+
+static void get_loc_or_ref(DynBuf *bc, BOOL is_ref, int idx)
+{
+    if (is_ref) 
+        dbuf_putc(bc, OP_get_var_ref);
+    else
+        dbuf_putc(bc, OP_get_loc);
+    dbuf_put_u16(bc, idx);
+    
+}
+
+static int resolve_scope_private_field1(JSContext *ctx,
+                                        BOOL *pis_ref, int *pvar_kind,
+                                        JSFunctionDef *s,
+                                        JSAtom var_name, int scope_level)
+{
+    int idx, var_kind;
+    JSFunctionDef *fd;
+    BOOL is_ref;
+    
+    fd = s;
+    is_ref = FALSE;
+    for(;;) {
+        idx = find_private_class_field_all(ctx, fd, var_name, scope_level);
+        if (idx >= 0) {
+            var_kind = fd->vars[idx].var_kind;
+            if (is_ref) {
+                idx = get_closure_var(ctx, s, fd, FALSE, idx, var_name,
+                                      TRUE, TRUE, JS_VAR_NORMAL);
+                if (idx < 0)
+                    return -1;
+            }
+            break;
+        }
+        scope_level = fd->parent_scope_level;
+        if (!fd->parent) {
+            char buf[ATOM_GET_STR_BUF_SIZE];
+
+            if (fd->is_eval) {
+                /* closure of the eval function (top level) */
+                for (idx = 0; idx < fd->closure_var_count; idx++) {
+                    JSClosureVar *cv = &fd->closure_var[idx];
+                    if (cv->var_name == var_name) {
+                        var_kind = cv->var_kind;
+                        is_ref = TRUE;
+                        if (fd != s) {
+                            idx = get_closure_var2(ctx, s, fd,
+                                                   FALSE,
+                                                   cv->is_arg, idx,
+                                                   cv->var_name, cv->is_const,
+                                                   cv->is_lexical,
+                                                   cv->var_kind);
+                            if (idx < 0)
+                                return -1;
+                        }
+                        goto done;
+                    }
+                }
+            }
+            /* XXX: no line number info */
+            JS_ThrowSyntaxError(ctx, "undefined private field %s",
+                                JS_AtomGetStr(ctx, buf, sizeof(buf), var_name));
+            return -1;
+        } else {
+            fd = fd->parent;
+        }
+        is_ref = TRUE;
+    }
+ done:
+    *pis_ref = is_ref;
+    *pvar_kind = var_kind;
+    return idx;
+}
+
+/* return 0 if OK or -1 if the private field could not be resolved */
+static int resolve_scope_private_field(JSContext *ctx, JSFunctionDef *s,
+                                       JSAtom var_name, int scope_level, int op,
+                                       DynBuf *bc)
+{
+    int idx, var_kind;
+    BOOL is_ref;
+
+    idx = resolve_scope_private_field1(ctx, &is_ref, &var_kind, s,
+                                       var_name, scope_level);
+    if (idx < 0)
+        return -1;
+    assert(var_kind != JS_VAR_NORMAL);
+    switch (op) {
+    case OP_scope_get_private_field:
+    case OP_scope_get_private_field2:
+        switch(var_kind) {
+        case JS_VAR_PRIVATE_FIELD:
+            if (op == OP_scope_get_private_field2)
+                dbuf_putc(bc, OP_dup);
+            get_loc_or_ref(bc, is_ref, idx);
+            dbuf_putc(bc, OP_get_private_field);
+            break;
+        case JS_VAR_PRIVATE_METHOD:
+            get_loc_or_ref(bc, is_ref, idx);
+            dbuf_putc(bc, OP_check_brand);
+            if (op != OP_scope_get_private_field2)
+                dbuf_putc(bc, OP_nip);
+            break;
+        case JS_VAR_PRIVATE_GETTER:
+        case JS_VAR_PRIVATE_GETTER_SETTER:
+            if (op == OP_scope_get_private_field2)
+                dbuf_putc(bc, OP_dup);
+            get_loc_or_ref(bc, is_ref, idx);
+            dbuf_putc(bc, OP_check_brand);
+            dbuf_putc(bc, OP_call_method);
+            dbuf_put_u16(bc, 0);
+            break;
+        case JS_VAR_PRIVATE_SETTER:
+            /* XXX: add clearer error message */
+            dbuf_putc(bc, OP_throw_var);
+            dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
+            dbuf_putc(bc, JS_THROW_VAR_RO);
+            break;
+        default:
+            abort();
+        }
+        break;
+    case OP_scope_put_private_field:
+        switch(var_kind) {
+        case JS_VAR_PRIVATE_FIELD:
+            get_loc_or_ref(bc, is_ref, idx);
+            dbuf_putc(bc, OP_put_private_field);
+            break;
+        case JS_VAR_PRIVATE_METHOD:
+        case JS_VAR_PRIVATE_GETTER:
+            /* XXX: add clearer error message */
+            dbuf_putc(bc, OP_throw_var);
+            dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
+            dbuf_putc(bc, JS_THROW_VAR_RO);
+            break;
+        case JS_VAR_PRIVATE_SETTER:
+        case JS_VAR_PRIVATE_GETTER_SETTER:
+            {
+                JSAtom setter_name = get_private_setter_name(ctx, var_name);
+                if (setter_name == JS_ATOM_NULL)
+                    return -1;
+                idx = resolve_scope_private_field1(ctx, &is_ref,
+                                                   &var_kind, s,
+                                                   setter_name, scope_level);
+                JS_FreeAtom(ctx, setter_name);
+                if (idx < 0)
+                    return -1;
+                assert(var_kind == JS_VAR_PRIVATE_SETTER);
+                get_loc_or_ref(bc, is_ref, idx);
+                dbuf_putc(bc, OP_swap);
+                /* obj func value */
+                dbuf_putc(bc, OP_rot3r);
+                /* value obj func */
+                dbuf_putc(bc, OP_check_brand);
+                dbuf_putc(bc, OP_rot3l);
+                /* obj func value */
+                dbuf_putc(bc, OP_call_method);
+                dbuf_put_u16(bc, 1);
+            }
+            break;
+        default:
+            abort();
+        }
+        break;
+    default:
+        abort();
+    }
+    return 0;
+}
+
 static void mark_eval_captured_variables(JSContext *ctx, JSFunctionDef *s,
                                          int scope_level)
 {
@@ -26928,7 +28016,7 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
             vd = &fd->vars[scope_idx];
             vd->is_captured = 1;
             get_closure_var(ctx, s, fd, FALSE, scope_idx,
-                            vd->var_name, vd->is_const, vd->is_lexical, vd->is_catch);
+                            vd->var_name, vd->is_const, vd->is_lexical, vd->var_kind);
             scope_idx = vd->scope_next;
         }
         /* add unscoped variables */
@@ -26936,7 +28024,8 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
             vd = &fd->args[i];
             if (vd->var_name != JS_ATOM_NULL) {
                 get_closure_var(ctx, s, fd,
-                                TRUE, i, vd->var_name, FALSE, FALSE, FALSE);
+                                TRUE, i, vd->var_name, FALSE, FALSE,
+                                JS_VAR_NORMAL);
             }
         }
         for(i = 0; i < fd->var_count; i++) {
@@ -26946,7 +28035,8 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
                 vd->var_name != JS_ATOM__ret_ &&
                 vd->var_name != JS_ATOM_NULL) {
                 get_closure_var(ctx, s, fd,
-                                FALSE, i, vd->var_name, FALSE, FALSE, FALSE);
+                                FALSE, i, vd->var_name, FALSE, FALSE,
+                                JS_VAR_NORMAL);
             }
         }
         if (fd->is_eval) {
@@ -26958,7 +28048,7 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
                 get_closure_var2(ctx, s, fd,
                                  FALSE, cv->is_arg,
                                  idx, cv->var_name, cv->is_const,
-                                 cv->is_lexical, cv->is_catch);
+                                 cv->is_lexical, cv->var_kind);
             }
         }
     }
@@ -26990,7 +28080,7 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
             cv->is_arg = FALSE;
             cv->is_const = vd->is_const;
             cv->is_lexical = vd->is_lexical;
-            cv->is_catch = vd->is_catch;
+            cv->var_kind = vd->var_kind;
             cv->var_idx = i;
             cv->var_name = JS_DupAtom(ctx, vd->var_name);
         }
@@ -27004,7 +28094,7 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
         cv->is_arg = TRUE;
         cv->is_const = FALSE;
         cv->is_lexical = FALSE;
-        cv->is_catch = FALSE;
+        cv->var_kind = JS_VAR_NORMAL;
         cv->var_idx = i;
         cv->var_name = JS_DupAtom(ctx, vd->var_name);
     }
@@ -27017,7 +28107,7 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
             cv->is_arg = FALSE;
             cv->is_const = FALSE;
             cv->is_lexical = FALSE;
-            cv->is_catch = FALSE;
+            cv->var_kind = JS_VAR_NORMAL;
             cv->var_idx = i;
             cv->var_name = JS_DupAtom(ctx, vd->var_name);
         }
@@ -27029,7 +28119,7 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
         cv->is_arg = cv0->is_arg;
         cv->is_const = cv0->is_const;
         cv->is_lexical = cv0->is_lexical;
-        cv->is_catch = cv0->is_catch;
+        cv->var_kind = cv0->var_kind;
         cv->var_idx = i;
         cv->var_name = JS_DupAtom(ctx, cv0->var_name);
     }
@@ -27380,7 +28470,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                     if (cv->var_name == hf->var_name) {
                         if (s->eval_type == JS_EVAL_TYPE_DIRECT &&
                             (cv->is_lexical ||
-                             (cv->is_catch && hf->is_for_of))) {
+                             (cv->var_kind == JS_VAR_CATCH && hf->is_for_of))) {
                             /* Check if a lexical variable is
                                redefined as 'var'. XXX: Could abort
                                compilation here, but for consistency
@@ -27456,7 +28546,19 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                 JS_FreeAtom(ctx, var_name);
             }
             break;
-
+        case OP_scope_get_private_field:
+        case OP_scope_get_private_field2:
+        case OP_scope_put_private_field:
+            {
+                int ret;
+                var_name = get_u32(bc_buf + pos + 1);
+                scope = get_u16(bc_buf + pos + 5);
+                ret = resolve_scope_private_field(ctx, s, var_name, scope, op, &bc_out);
+                if (ret < 0)
+                    goto fail;
+                JS_FreeAtom(ctx, var_name);
+            }
+            break;
         case OP_gosub:
             s->jump_size++;
             if (OPTIMIZE) {
@@ -27668,6 +28770,18 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         return -1;
     }
     return 0;
+ fail:
+    /* continue the copy to keep the atom refcounts consistent */
+    /* XXX: find a better solution ? */
+    for (; pos < bc_len; pos = pos_next) {
+        op = bc_buf[pos];
+        len = opcode_info[op].size;
+        pos_next = pos + len;
+        dbuf_put(&bc_out, bc_buf + pos, len);
+    }
+    dbuf_free(&s->byte_code);
+    s->byte_code = bc_out;
+    return -1;
 }
 
 /* the pc2line table gives a line number for each PC value */
@@ -27970,7 +29084,8 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
     }
     /* initialize the variable environment object if needed */
     if (s->var_object_idx >= 0) {
-        dbuf_putc(&bc_out, OP_var_object);
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
         put_short_code(&bc_out, OP_put_loc, s->var_object_idx);
     }
 
@@ -27987,7 +29102,8 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                     add_pc2line_info(s, bc_out.size, line_num);
                     dbuf_putc(&bc_out, OP_close_loc);
                     dbuf_put_u16(&bc_out, s->var_object_idx);
-                    dbuf_putc(&bc_out, OP_var_object);
+                    dbuf_putc(&bc_out, OP_special_object);
+                    dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
                     put_short_code(&bc_out, OP_put_loc, s->var_object_idx);
                 }
             }
@@ -28494,10 +29610,13 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                 if (code_match(&cc, pos_next, OP_push_atom_value, OP_add, OP_dup, OP_put_loc, idx, OP_drop, -1)) {
                     if (cc.line_num >= 0) line_num = cc.line_num;
                     add_pc2line_info(s, bc_out.size, line_num);
+#if SHORT_OPCODES
                     if (cc.atom == JS_ATOM_empty_string) {
                         JS_FreeAtom(ctx, cc.atom);
                         dbuf_putc(&bc_out, OP_push_empty_string);
-                    } else {
+                    } else
+#endif
+                    {
                         dbuf_putc(&bc_out, OP_push_atom_value);
                         dbuf_put_u32(&bc_out, cc.atom);
                     }
@@ -28765,12 +29884,14 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
     /* set the new byte code */
     dbuf_free(&s->byte_code);
     s->byte_code = bc_out;
+    s->use_short_opcodes = TRUE;
     if (dbuf_error(&s->byte_code)) {
         JS_ThrowOutOfMemory(ctx);
         return -1;
     }
     return 0;
  fail:
+    /* XXX: not safe */
     dbuf_free(&bc_out);
     return -1;
 }
@@ -28822,7 +29943,7 @@ static __exception int compute_stack_size_rec(JSContext *ctx,
             JS_ThrowInternalError(ctx, "invalid opcode (op=%d, pc=%d)", op, pos);
             return -1;
         }
-        oi = &opcode_info[op];
+        oi = &short_opcode_info(op);
         pos_next = pos + oi->size;
         if (pos_next > bc_len) {
         buf_overflow:
@@ -29177,10 +30298,12 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     b->js_mode = fd->js_mode;
     b->is_derived_class_constructor = fd->is_derived_class_constructor;
     b->func_kind = fd->func_kind;
-    b->need_home_object = (fd->home_object_var_idx >= 0);
+    b->need_home_object = (fd->home_object_var_idx >= 0 ||
+                           fd->need_home_object);
     b->new_target_allowed = fd->new_target_allowed;
     b->super_call_allowed = fd->super_call_allowed;
     b->super_allowed = fd->super_allowed;
+    b->arguments_allowed = fd->arguments_allowed;
 
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
     if (!(fd->js_mode & JS_MODE_STRIP)) {
@@ -29211,7 +30334,7 @@ static void free_function_bytecode(JSRuntime *rt, JSFunctionBytecode *b)
                JS_AtomGetStrRT(rt, buf, sizeof(buf), b->func_name));
     }
 #endif
-    free_bytecode_atoms(rt, b->byte_code_buf, b->byte_code_len);
+    free_bytecode_atoms(rt, b->byte_code_buf, b->byte_code_len, TRUE);
 
     if (b->vardefs) {
         for(i = 0; i < b->arg_count + b->var_count; i++) {
@@ -29383,6 +30506,32 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
     return js_parse_error(s, "duplicate argument names not allowed in this context");
 }
 
+/* create a function to initialize class fields */
+static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
+{
+    JSFunctionDef *fd;
+    
+    fd = js_new_function_def(s->ctx, s->cur_func, FALSE, FALSE,
+                             s->filename, 0);
+    if (!fd)
+        return NULL;
+    fd->func_name = JS_ATOM_NULL;
+    fd->has_prototype = FALSE;
+    fd->has_home_object = TRUE;
+    
+    fd->has_arguments_binding = FALSE;
+    fd->has_this_binding = TRUE;
+    fd->is_derived_class_constructor = FALSE;
+    fd->new_target_allowed = TRUE;
+    fd->super_call_allowed = FALSE;
+    fd->super_allowed = fd->has_home_object;
+    fd->arguments_allowed = FALSE;
+    
+    fd->func_kind = JS_FUNC_NORMAL;
+    fd->func_type = JS_PARSE_FUNC_METHOD;
+    return fd;
+}
+
 /* func_name must be JS_ATOM_NULL for JS_PARSE_FUNC_STATEMENT and
    JS_PARSE_FUNC_EXPR, JS_PARSE_FUNC_ARROW and JS_PARSE_FUNC_VAR */
 static __exception int js_parse_function_decl2(JSParseState *s,
@@ -29525,10 +30674,12 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         fd->new_target_allowed = fd->parent->new_target_allowed;
         fd->super_call_allowed = fd->parent->super_call_allowed;
         fd->super_allowed = fd->parent->super_allowed;
+        fd->arguments_allowed = fd->parent->arguments_allowed;
     } else {
         fd->new_target_allowed = TRUE;
         fd->super_call_allowed = fd->is_derived_class_constructor;
         fd->super_allowed = fd->has_home_object;
+        fd->arguments_allowed = TRUE;
     }
 
     /* fd->in_function_body == FALSE prevents yield/await during the parsing
@@ -29543,6 +30694,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         emit_op(s, OP_check_ctor);
     }
 
+    if (func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
+        emit_class_field_init(s);
+    }
+    
     /* parse arguments */
     fd->has_simple_parameter_list = TRUE;
     has_opt_arg = FALSE;
@@ -30054,10 +31209,12 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
         fd->new_target_allowed = b->new_target_allowed;
         fd->super_call_allowed = b->super_call_allowed;
         fd->super_allowed = b->super_allowed;
+        fd->arguments_allowed = b->arguments_allowed;
     } else {
         fd->new_target_allowed = FALSE;
         fd->super_call_allowed = FALSE;
         fd->super_allowed = FALSE;
+        fd->arguments_allowed = TRUE;
     }
     fd->js_mode = js_mode;
     fd->func_name = JS_DupAtom(ctx, JS_ATOM__eval_);
@@ -30120,11 +31277,11 @@ static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
 {
     JSValue ret;
     const char *str;
-    int len;
+    size_t len;
 
     if (!JS_IsString(val))
         return JS_DupValue(ctx, val);
-    str = JS_ToCStringLen(ctx, &len, val, FALSE);
+    str = JS_ToCStringLen(ctx, &len, val);
     if (!str)
         return JS_EXCEPTION;
     ret = JS_EvalInternal(ctx, this_obj, str, len, "<input>", flags, scope_idx);
@@ -30354,8 +31511,8 @@ static void bc_byte_swap(uint8_t *bc_buf, int bc_len)
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
-        len = opcode_info[op].size;
-        fmt = opcode_info[op].fmt;
+        len = short_opcode_info(op).size;
+        fmt = short_opcode_info(op).fmt;
         switch(fmt) {
         case OP_FMT_u16:
         case OP_FMT_i16:
@@ -30417,8 +31574,8 @@ static int JS_WriteFunctionBytecode(BCWriterState *s,
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
-        len = opcode_info[op].size;
-        switch(opcode_info[op].fmt) {
+        len = short_opcode_info(op).size;
+        switch(short_opcode_info(op).fmt) {
         case OP_FMT_atom:
         case OP_FMT_atom_u8:
         case OP_FMT_atom_u16:
@@ -30510,6 +31667,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
             bc_set_flags(&flags, &idx, b->new_target_allowed, 1);
             bc_set_flags(&flags, &idx, b->super_call_allowed, 1);
             bc_set_flags(&flags, &idx, b->super_allowed, 1);
+            bc_set_flags(&flags, &idx, b->arguments_allowed, 1);
             bc_set_flags(&flags, &idx, b->has_debug, 1);
             assert(idx <= 16);
             bc_put_u16(s, flags);
@@ -30531,7 +31689,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                     bc_put_leb128(s, vd->scope_level);
                     bc_put_leb128(s, vd->scope_next + 1);
                     flags = idx = 0;
-                    bc_set_flags(&flags, &idx, vd->is_catch, 1);
+                    bc_set_flags(&flags, &idx, vd->var_kind, 3);
                     bc_set_flags(&flags, &idx, vd->is_function, 1);
                     bc_set_flags(&flags, &idx, vd->is_func_var, 1);
                     bc_set_flags(&flags, &idx, vd->is_const, 1);
@@ -30553,7 +31711,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                 bc_set_flags(&flags, &idx, cv->is_arg, 1);
                 bc_set_flags(&flags, &idx, cv->is_const, 1);
                 bc_set_flags(&flags, &idx, cv->is_lexical, 1);
-                bc_set_flags(&flags, &idx, cv->is_catch, 1);
+                bc_set_flags(&flags, &idx, cv->var_kind, 3);
                 assert(idx <= 8);
                 bc_put_u8(s, flags);
             }
@@ -31114,8 +32272,8 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
-        len = opcode_info[op].size;
-        switch(opcode_info[op].fmt) {
+        len = short_opcode_info(op).size;
+        switch(short_opcode_info(op).fmt) {
         case OP_FMT_atom:
         case OP_FMT_atom_u8:
         case OP_FMT_atom_u16:
@@ -31224,6 +32382,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
             bc.new_target_allowed = bc_get_flags(v16, &idx, 1);
             bc.super_call_allowed = bc_get_flags(v16, &idx, 1);
             bc.super_allowed = bc_get_flags(v16, &idx, 1);
+            bc.arguments_allowed = bc_get_flags(v16, &idx, 1);
             bc.has_debug = bc_get_flags(v16, &idx, 1);
             bc.read_only_bytecode = s->is_rom_data;
             if (bc_get_u8(s, &v8))
@@ -31295,7 +32454,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
                     if (bc_get_u8(s, &v8))
                         goto fail;
                     idx = 0;
-                    vd->is_catch = bc_get_flags(v8, &idx, 1);
+                    vd->var_kind = bc_get_flags(v8, &idx, 3);
                     vd->is_function = bc_get_flags(v8, &idx, 1);
                     vd->is_func_var = bc_get_flags(v8, &idx, 1);
                     vd->is_const = bc_get_flags(v8, &idx, 1);
@@ -31325,7 +32484,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
                     cv->is_arg = bc_get_flags(v8, &idx, 1);
                     cv->is_const = bc_get_flags(v8, &idx, 1);
                     cv->is_lexical = bc_get_flags(v8, &idx, 1);
-                    cv->is_catch = bc_get_flags(v8, &idx, 1);
+                    cv->var_kind = bc_get_flags(v8, &idx, 3);
 #ifdef DUMP_READ_OBJECT
                     bc_read_trace(s, "name: "); print_atom(s->ctx, cv->var_name); printf("\n");
 #endif
@@ -32239,7 +33398,7 @@ static __exception int JS_ObjectDefineProperties(JSContext *ctx,
     if (JS_IsException(props))
         return -1;
     p = JS_VALUE_GET_OBJ(props);
-    if (JS_GetOwnPropertyNames(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK) < 0)
+    if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK) < 0)
         goto exception;
     for(i = 0; i < len; i++) {
         JS_FreeValue(ctx, desc);
@@ -32441,7 +33600,7 @@ static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst t
         return JS_EXCEPTION;
     ret = JS_UNDEFINED;
     if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
-        res = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(obj), atom);
+        res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), atom);
         if (res < 0)
             goto exception;
         if (res) {
@@ -32493,7 +33652,7 @@ static JSValue js_object_getOwnPropertyDescriptors(JSContext *ctx, JSValueConst
         return JS_EXCEPTION;
 
     p = JS_VALUE_GET_OBJ(obj);
-    if (JS_GetOwnPropertyNames(ctx, &props, &len, p,
+    if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p,
                                JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK))
         goto exception;
     r = JS_NewObject(ctx);
@@ -32543,7 +33702,7 @@ static JSValue JS_GetOwnPropertyNames2(JSContext *ctx, JSValueConst obj1,
     if (JS_IsException(obj))
         return JS_EXCEPTION;
     p = JS_VALUE_GET_OBJ(obj);
-    if (JS_GetOwnPropertyNames(ctx, &atoms, &len, p, flags & ~JS_GPN_ENUM_ONLY))
+    if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, flags & ~JS_GPN_ENUM_ONLY))
         goto exception;
     r = JS_NewArray(ctx);
     if (JS_IsException(r))
@@ -32555,7 +33714,7 @@ static JSValue JS_GetOwnPropertyNames2(JSContext *ctx, JSValueConst obj1,
             int res;
 
             /* Check if property is still enumerable */
-            res = JS_GetOwnProperty(ctx, &desc, p, atom);
+            res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
             if (res < 0)
                 goto exception;
             if (!res)
@@ -32688,7 +33847,7 @@ static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValueConst this_val,
         return obj;
     }
     p = JS_VALUE_GET_OBJ(obj);
-    ret = JS_GetOwnProperty(ctx, NULL, p, atom);
+    ret = JS_GetOwnPropertyInternal(ctx, NULL, p, atom);
     JS_FreeAtom(ctx, atom);
     JS_FreeValue(ctx, obj);
     if (ret < 0)
@@ -32806,7 +33965,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
 
     p = JS_VALUE_GET_OBJ(obj);
     flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
-    if (JS_GetOwnPropertyNames(ctx, &props, &len, p, flags))
+    if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
         return JS_EXCEPTION;
 
     for(i = 0; i < len; i++) {
@@ -32815,7 +33974,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
 
         desc_flags = JS_PROP_THROW | JS_PROP_HAS_CONFIGURABLE;
         if (freeze_flag) {
-            res = JS_GetOwnProperty(ctx, &desc, p, prop);
+            res = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
             if (res < 0)
                 goto exception;
             if (res) {
@@ -32850,14 +34009,14 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
 
     p = JS_VALUE_GET_OBJ(obj);
     flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
-    if (JS_GetOwnPropertyNames(ctx, &props, &len, p, flags))
+    if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
         return JS_EXCEPTION;
 
     for(i = 0; i < len; i++) {
         JSPropertyDescriptor desc;
         JSAtom prop = props[i].atom;
 
-        res = JS_GetOwnProperty(ctx, &desc, p, prop);
+        res = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
         if (res < 0)
             goto exception;
         if (res) {
@@ -33166,7 +34325,7 @@ static JSValue js_object_propertyIsEnumerable(JSContext *ctx, JSValueConst this_
     if (unlikely(prop == JS_ATOM_NULL))
         goto exception;
 
-    has_prop = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
+    has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
     if (has_prop < 0)
         goto exception;
     if (has_prop) {
@@ -33199,7 +34358,7 @@ static JSValue js_object___lookupGetter__(JSContext *ctx, JSValueConst this_val,
         goto exception;
 
     for (v = obj;;) {
-        has_prop = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(v), prop);
+        has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(v), prop);
         if (has_prop < 0)
             goto exception;
         if (has_prop) {
@@ -36609,6 +37768,7 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
 
     pos = string_indexof(sp, searchp, 0);
     if (pos < 0) {
+        string_buffer_free(b);
         JS_FreeValue(ctx, search_str);
         JS_FreeValue(ctx, replaceValue_str);
         return str;
@@ -37100,7 +38260,7 @@ static int JS_ToUTF32String(JSContext *ctx, uint32_t **pbuf, JSValueConst val1)
     p = JS_VALUE_GET_STRING(val);
     len = p->len;
     /* UTF32 buffer length is len minus the number of correct surrogates pairs */
-    buf = js_malloc(ctx, sizeof(buf[0]) * len);
+    buf = js_malloc(ctx, sizeof(buf[0]) * max_int(len, 1));
     if (!buf) {
         JS_FreeValue(ctx, val);
         goto fail;
@@ -37135,7 +38295,8 @@ static JSValue js_string_normalize(JSContext *ctx, JSValueConst this_val,
                                    int argc, JSValueConst *argv)
 {
     const char *form, *p;
-    int form_len, is_compat, buf_len, out_len;
+    size_t form_len;
+    int is_compat, buf_len, out_len;
     UnicodeNormalizationEnum n_type;
     JSValue val;
     uint32_t *buf, *out_buf;
@@ -37151,7 +38312,7 @@ static JSValue js_string_normalize(JSContext *ctx, JSValueConst this_val,
     if (argc == 0 || JS_IsUndefined(argv[0])) {
         n_type = UNICODE_NFC;
     } else {
-        form = JS_ToCStringLen(ctx, &form_len, argv[0], FALSE);
+        form = JS_ToCStringLen(ctx, &form_len, argv[0]);
         if (!form)
             goto fail1;
         p = form;
@@ -38154,13 +39315,14 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
     const char *str;
     int re_flags, mask;
     uint8_t *re_bytecode_buf;
-    int re_bytecode_len, i, len;
+    size_t i, len;
+    int re_bytecode_len;
     JSValue ret;
     char error_msg[64];
 
     re_flags = 0;
     if (!JS_IsUndefined(flags)) {
-        str = JS_ToCStringLen(ctx, &len, flags, FALSE);
+        str = JS_ToCStringLen(ctx, &len, flags);
         if (!str)
             return JS_EXCEPTION;
         /* XXX: re_flags = LRE_FLAG_OCTAL unless strict mode? */
@@ -38197,7 +39359,7 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
         JS_FreeCString(ctx, str);
     }
 
-    str = JS_ToCStringLen(ctx, &len, pattern, !(re_flags & LRE_FLAG_UTF16));
+    str = JS_ToCStringLen2(ctx, &len, pattern, !(re_flags & LRE_FLAG_UTF16));
     if (!str)
         return JS_EXCEPTION;
     re_bytecode_buf = lre_compile(&re_bytecode_len, error_msg,
@@ -39772,7 +40934,6 @@ JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
     return JS_EXCEPTION;
 }
 
-/* XXX: check stack limit ? */
 static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
                                          JSAtom name, JSValueConst reviver)
 {
@@ -39783,6 +40944,10 @@ static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
     JSAtom prop;
     JSPropertyEnum *atoms = NULL;
 
+    if (js_check_stack_overflow(ctx, 0)) {
+        return JS_ThrowStackOverflow(ctx);
+    }
+
     val = JS_GetProperty(ctx, holder, name);
     if (JS_IsException(val))
         return val;
@@ -39794,7 +40959,7 @@ static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
             if (js_get_length32(ctx, &len, val))
                 goto fail;
         } else {
-            ret = JS_GetOwnPropertyNames(ctx, &atoms, &len, JS_VALUE_GET_OBJ(val), JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
+            ret = JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, JS_VALUE_GET_OBJ(val), JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
             if (ret < 0)
                 goto fail;
         }
@@ -39844,9 +41009,9 @@ static JSValue js_json_parse(JSContext *ctx, JSValueConst this_val,
     JSValue obj, root;
     JSValueConst reviver;
     const char *str;
-    int len;
+    size_t len;
 
-    str = JS_ToCStringLen(ctx, &len, argv[0], FALSE);
+    str = JS_ToCStringLen(ctx, &len, argv[0]);
     if (!str)
         return JS_EXCEPTION;
     obj = JS_ParseJSON(ctx, str, len, "<input>");
@@ -40436,15 +41601,26 @@ static void js_proxy_mark(JSRuntime *rt, JSValueConst val,
     }
 }
 
+static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx)
+{
+    return JS_ThrowTypeError(ctx, "revoked proxy");
+}
+
 static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
                                      JSValueConst obj, JSAtom name)
 {
     JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
     JSValue method;
 
+    /* safer to test recursion in all proxy methods */
+    if (js_check_stack_overflow(ctx, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        return NULL;
+    }
+    
     /* 's' should never be NULL */
-    if (JS_IsNull(s->handler)) {
-        JS_ThrowTypeError(ctx, "revoked proxy");
+    if (s->is_revoked) {
+        JS_ThrowTypeErrorRevokedProxy(ctx);
         return NULL;
     }
     method = JS_GetProperty(ctx, s->handler, name);
@@ -40628,7 +41804,7 @@ static int js_proxy_has(JSContext *ctx, JSValueConst obj, JSAtom atom)
     if (!ret) {
         JSPropertyDescriptor desc;
         p = JS_VALUE_GET_OBJ(s->target);
-        res = JS_GetOwnProperty(ctx, &desc, p, atom);
+        res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
         if (res < 0)
             return -1;
         if (res) {
@@ -40655,6 +41831,7 @@ static JSValue js_proxy_get(JSContext *ctx, JSValueConst obj, JSAtom atom,
     s = get_proxy_method(ctx, &method, obj, JS_ATOM_get);
     if (!s)
         return JS_EXCEPTION;
+    /* Note: recursion is possible thru the prototype of s->target */
     if (JS_IsUndefined(method))
         return JS_GetPropertyInternal(ctx, s->target, atom, receiver, FALSE);
     atom_val = JS_AtomToValue(ctx, atom);
@@ -40669,7 +41846,7 @@ static JSValue js_proxy_get(JSContext *ctx, JSValueConst obj, JSAtom atom,
     JS_FreeValue(ctx, atom_val);
     if (JS_IsException(ret))
         return JS_EXCEPTION;
-    res = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
+    res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
     if (res < 0)
         return JS_EXCEPTION;
     if (res) {
@@ -40722,7 +41899,7 @@ static int js_proxy_set(JSContext *ctx, JSValueConst obj, JSAtom atom,
     ret = JS_ToBoolFree(ctx, ret1);
     if (ret) {
         JSPropertyDescriptor desc;
-        res = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
+        res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
         if (res < 0)
             return -1;
         if (res) {
@@ -40801,7 +41978,7 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
         return -1;
     p = JS_VALUE_GET_OBJ(s->target);
     if (JS_IsUndefined(method)) {
-        return JS_GetOwnProperty(ctx, pdesc, p, prop);
+        return JS_GetOwnPropertyInternal(ctx, pdesc, p, prop);
     }
     prop_val = JS_AtomToValue(ctx, prop);
     if (JS_IsException(prop_val)) {
@@ -40818,7 +41995,7 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
         JS_FreeValue(ctx, ret1);
         goto fail;
     }
-    target_res = JS_GetOwnProperty(ctx, &target_desc, p, prop);
+    target_res = JS_GetOwnPropertyInternal(ctx, &target_desc, p, prop);
     if (target_res < 0) {
         JS_FreeValue(ctx, ret1);
         return -1;
@@ -40920,7 +42097,7 @@ static int js_proxy_define_own_property(JSContext *ctx, JSValueConst obj,
         }
     }
     p = JS_VALUE_GET_OBJ(s->target);
-    res = JS_GetOwnProperty(ctx, &desc, p, prop);
+    res = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
     if (res < 0)
         return -1;
     setting_not_configurable = ((flags & (JS_PROP_HAS_CONFIGURABLE |
@@ -40989,7 +42166,7 @@ static int js_proxy_delete_property(JSContext *ctx, JSValueConst obj,
     res = JS_ToBoolFree(ctx, ret);
     if (res) {
         JSPropertyDescriptor desc;
-        res2 = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
+        res2 = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
         if (res2 < 0)
             return -1;
         if (res2) {
@@ -41032,7 +42209,7 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
     if (!s)
         return -1;
     if (JS_IsUndefined(method)) {
-        return JS_GetOwnPropertyNames(ctx, ptab, plen,
+        return JS_GetOwnPropertyNamesInternal(ctx, ptab, plen,
                                       JS_VALUE_GET_OBJ(s->target),
                                       JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK);
     }
@@ -41081,19 +42258,19 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
         goto fail;
 
     /* check if there are non configurable properties */
-    if (JS_IsNull(s->handler)) {
-        JS_ThrowTypeError(ctx, "revoked proxy");
+    if (s->is_revoked) {
+        JS_ThrowTypeErrorRevokedProxy(ctx);
         goto fail;
     }
-    if (JS_GetOwnPropertyNames(ctx, &tab2, &len2, JS_VALUE_GET_OBJ(s->target),
+    if (JS_GetOwnPropertyNamesInternal(ctx, &tab2, &len2, JS_VALUE_GET_OBJ(s->target),
                                JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK))
         goto fail;
     for(i = 0; i < len2; i++) {
-        if (JS_IsNull(s->handler)) {
-            JS_ThrowTypeError(ctx, "revoked proxy");
+        if (s->is_revoked) {
+            JS_ThrowTypeErrorRevokedProxy(ctx);
             goto fail;
         }
-        res = JS_GetOwnProperty(ctx, &desc, JS_VALUE_GET_OBJ(s->target),
+        res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target),
                                 tab2[i].atom);
         if (res < 0)
             goto fail;
@@ -41203,8 +42380,8 @@ static int js_proxy_isArray(JSContext *ctx, JSValueConst obj)
     JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
     if (!s)
         return FALSE;
-    if (JS_IsNull(s->handler)) {
-        JS_ThrowTypeError(ctx, "revoked proxy");
+    if (s->is_revoked) {
+        JS_ThrowTypeErrorRevokedProxy(ctx);
         return -1;
     }
     return JS_IsArray(ctx, s->target);
@@ -41233,12 +42410,12 @@ static JSValue js_proxy_constructor(JSContext *ctx, JSValueConst this_val,
         JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
     s = JS_GetOpaque(target, JS_CLASS_PROXY);
-    if (s && JS_IsNull(s->handler))
+    if (s && s->is_revoked)
         goto revoked_proxy;
     s = JS_GetOpaque(handler, JS_CLASS_PROXY);
-    if (s && JS_IsNull(s->handler)) {
+    if (s && s->is_revoked) {
     revoked_proxy:
-        return JS_ThrowTypeError(ctx, "revoked proxy");
+        return JS_ThrowTypeErrorRevokedProxy(ctx);
     }
 
     obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
@@ -41253,6 +42430,7 @@ static JSValue js_proxy_constructor(JSContext *ctx, JSValueConst this_val,
     s->handler = JS_DupValue(ctx, handler);
     s->proto = JS_NULL;
     s->is_func = JS_IsFunction(ctx, target);
+    s->is_revoked = FALSE;
     JS_SetOpaque(obj, s);
     JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
     return obj;
@@ -41264,10 +42442,9 @@ static JSValue js_proxy_revoke(JSContext *ctx, JSValueConst this_val,
 {
     JSProxyData *s = JS_GetOpaque(func_data[0], JS_CLASS_PROXY);
     if (s) {
-        /* Note: we keep s->target so that the proxy handlers can still be
-           executed if the revocation is done inside a Proxy callback */
-        JS_FreeValue(ctx, s->handler);
-        s->handler = JS_NULL;
+        /* We do not free the handler and target in case they are
+           referenced as constants in the C call stack */
+        s->is_revoked = TRUE;
         JS_FreeValue(ctx, func_data[0]);
         func_data[0] = JS_NULL;
     }
@@ -44371,10 +45548,24 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
         if (string_get_signed_field(sp, &p, &fields[0]))
             goto done;
 
-        for(i = 1; i < 7; i++) {
+        for (i = 1; i < 6; i++) {
             if (string_get_field(sp, &p, &fields[i]))
                 break;
         }
+        if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
+            /* parse milliseconds as a fractional part, round to nearest */
+            /* XXX: the spec does not indicate which rounding should be used */
+            int mul = 1000, ms = 0;
+            while (++p < sp->len) {
+                int c = string_get(sp, p);
+                if (!(c >= '0' && c <= '9'))
+                    break;
+                if (mul == 1 && c >= '5')
+                    ms += 1;
+                ms += (c - '0') * (mul /= 10);
+            }
+            fields[6] = ms;
+        }
         fields[1] -= 1;
 
         /* parse the time zone offset if present: [+-]HH:mm */
@@ -44418,6 +45609,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
             if (string_get_field(sp, &p, &fields[3 + i]))
                 goto done;
         }
+        // XXX: parse optional milliseconds?
 
         /* parse the time zone offset if present: [+-]HHmm */
         tz = 0;
@@ -47234,21 +48426,24 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
         res = JS_Call(ctx, psc->cmp, JS_UNDEFINED, 2, argv);
         if (JS_IsException(res)) {
             psc->exception = 1;
-        } else
-        if (validate_typed_array(ctx, psc->arr) < 0) {
-            JS_FreeValue(ctx, res);
-            psc->exception = 1;
-        } else
+            goto done;
+        }
         if (JS_VALUE_GET_TAG(res) == JS_TAG_INT) {
             int val = JS_VALUE_GET_INT(res);
             cmp = (val > 0) - (val < 0);
         } else {
             double val;
-            if (JS_ToFloat64Free(ctx, &val, res) < 0)
+            if (JS_ToFloat64Free(ctx, &val, res) < 0) {
                 psc->exception = 1;
-            else
+                goto done;
+            } else {
                 cmp = (val > 0) - (val < 0);
+            }
         }
+        if (validate_typed_array(ctx, psc->arr) < 0) {
+            psc->exception = 1;
+        }
+    done:
         JS_FreeValue(ctx, (JSValue)argv[0]);
         JS_FreeValue(ctx, (JSValue)argv[1]);
     }
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 6b863be360..5936032725 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -374,7 +374,7 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s);
 void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt);
 
 /* atom support */
-JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, int len);
+JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len);
 JSAtom JS_NewAtom(JSContext *ctx, const char *str);
 JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n);
 JSAtom JS_DupAtom(JSContext *ctx, JSAtom v);
@@ -466,6 +466,8 @@ static js_force_inline JSValue JS_NewCatchOffset(JSContext *ctx, int32_t val)
 }
 
 JSValue JS_NewInt64(JSContext *ctx, int64_t v);
+JSValue JS_NewBigInt64(JSContext *ctx, int64_t v);
+JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);
 
 static js_force_inline JSValue JS_NewFloat64(JSContext *ctx, double d)
 {
@@ -603,16 +605,21 @@ static int inline JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
 int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val);
 int JS_ToFloat64(JSContext *ctx, double *pres, JSValueConst val);
+int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 
-JSValue JS_NewStringLen(JSContext *ctx, const char *str1, int len1);
+JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);
 JSValue JS_NewString(JSContext *ctx, const char *str);
 JSValue JS_NewAtomString(JSContext *ctx, const char *str);
 JSValue JS_ToString(JSContext *ctx, JSValueConst val);
 JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val);
-const char *JS_ToCStringLen(JSContext *ctx, int *plen, JSValueConst val1, JS_BOOL cesu8);
+const char *JS_ToCStringLen2(JSContext *ctx, size_t *plen, JSValueConst val1, JS_BOOL cesu8);
+static inline const char *JS_ToCStringLen(JSContext *ctx, size_t *plen, JSValueConst val1)
+{
+    return JS_ToCStringLen2(ctx, plen, val1, 0);
+}
 static inline const char *JS_ToCString(JSContext *ctx, JSValueConst val1)
 {
-    return JS_ToCStringLen(ctx, NULL, val1, 0);
+    return JS_ToCStringLen2(ctx, NULL, val1, 0);
 }
 void JS_FreeCString(JSContext *ctx, const char *ptr);
 
@@ -661,6 +668,19 @@ int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags);
 int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val);
 JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val);
 
+#define JS_GPN_STRING_MASK  (1 << 0)
+#define JS_GPN_SYMBOL_MASK  (1 << 1)
+#define JS_GPN_PRIVATE_MASK (1 << 2)
+/* only include the enumerable properties */
+#define JS_GPN_ENUM_ONLY    (1 << 4)
+/* set theJSPropertyEnum.is_enumerable field */
+#define JS_GPN_SET_ENUM     (1 << 5)
+
+int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
+                           uint32_t *plen, JSValueConst obj, int flags);
+int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
+                      JSValueConst obj, JSAtom prop);
+
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
                      const char *filename);
 JSValue JS_Call(JSContext *ctx, JSValueConst func_obj, JSValueConst this_obj,
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 40fbf35a48..000a10f587 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -160,11 +160,11 @@ namespace qjs {
         {
             static js_string unwrap(JSContext * ctx, JSValueConst v)
             {
-                int plen;
-                const char * ptr = JS_ToCStringLen(ctx, &plen, v, 0);
+                std::size_t plen;
+                const char * ptr = JS_ToCStringLen(ctx, &plen, v);
                 if(!ptr)
                     throw exception{};
-                return js_string{ctx, ptr, (std::size_t)plen};
+                return js_string{ctx, ptr, plen};
             }
 
             static JSValue wrap(JSContext * ctx, std::string_view str) noexcept

From e593f9904522d648db3ba7f2c8268738cfdb8ea2 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Aug 2019 20:20:24 +0300
Subject: [PATCH 018/185] move exception and traits out of detail namespace

---
 main.cpp      |    2 +-
 quickjspp.hpp | 1665 +++++++++++++++++++++++++------------------------
 2 files changed, 843 insertions(+), 824 deletions(-)

diff --git a/main.cpp b/main.cpp
index 61f26b0a6f..186d65ed4f 100644
--- a/main.cpp
+++ b/main.cpp
@@ -147,7 +147,7 @@ int main(int argc, char ** argv)
                     context.eval("t").cast<std::shared_ptr<test>>(), "test string", std::string{"test"});
         assert(zzz == 19);
     }
-    catch(detail::exception)
+    catch(exception)
     {
         js_std_dump_error(ctx);
     }
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 000a10f587..496302f20f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -18,1002 +18,1021 @@ extern "C" {
 namespace qjs {
 
 
-    template <typename T>
-    struct allocator
+template <typename T>
+struct allocator
+{
+    JSRuntime * rt;
+    using value_type = T;
+    using propagate_on_container_move_assignment = std::true_type;
+    using propagate_on_container_copy_assignment = std::true_type;
+
+    constexpr allocator(JSRuntime * rt) noexcept : rt{rt}
+    {}
+
+    allocator(JSContext * ctx) noexcept : rt{JS_GetRuntime(ctx)}
+    {}
+
+    template <class U>
+    constexpr allocator(const allocator<U>& other) noexcept : rt{other.rt}
+    {}
+
+    [[nodiscard]] T * allocate(std::size_t n)
     {
-        JSRuntime * rt;
-        using value_type = T;
-        using propagate_on_container_move_assignment = std::true_type;
-        using propagate_on_container_copy_assignment = std::true_type;
+        if(auto p = static_cast<T *>(js_malloc_rt(rt, n * sizeof(T)))) return p;
+        throw std::bad_alloc();
+    }
 
-        constexpr allocator(JSRuntime * rt) noexcept : rt{rt}
-        {}
+    void deallocate(T * p, std::size_t) noexcept
+    { js_free_rt(rt, p); }
 
-        allocator(JSContext * ctx) noexcept : rt{JS_GetRuntime(ctx)}
-        {}
+    template <class U>
+    bool operator ==(const allocator<U>& other) const
+    { return rt == other.rt; }
 
-        template <class U>
-        constexpr allocator(const allocator<U>& other) noexcept : rt{other.rt}
-        {}
+    template <class U>
+    bool operator !=(const allocator<U>& other) const
+    { return rt != other.rt; }
+};
 
-        [[nodiscard]] T * allocate(std::size_t n)
-        {
-            if(auto p = static_cast<T *>(js_malloc_rt(rt, n * sizeof(T)))) return p;
-            throw std::bad_alloc();
-        }
+class exception {};
 
-        void deallocate(T * p, std::size_t) noexcept
-        { js_free_rt(rt, p); }
+template <typename R>
+struct js_traits
+{
+    //static R unwrap(JSContext * ctx, JSValueConst v);
+    //static JSValue wrap(JSContext * ctx, R value);
+};
 
-        template <class U>
-        bool operator == (const allocator<U>& other) const { return rt == other.rt; }
-        template <class U>
-        bool operator != (const allocator<U>& other) const { return rt != other.rt; }
-    };
+// identity
+template <>
+struct js_traits<JSValue>
+{
+    static JSValue unwrap(JSContext * ctx, JSValueConst v) noexcept
+    {
+        return JS_DupValue(ctx, v);
+    }
 
-    namespace detail {
-        class exception {};
+    static JSValue wrap(JSContext * ctx, JSValue v) noexcept
+    {
+        return v;
+    }
+};
 
-        template <typename R>
-        struct js_traits
-        {
-            //static R unwrap(JSContext * ctx, JSValueConst v);
-            //static JSValue wrap(JSContext * ctx, R value);
-        };
+template <>
+struct js_traits<int32_t>
+{
+    static int32_t unwrap(JSContext * ctx, JSValueConst v)
+    {
+        int32_t r;
+        if(JS_ToInt32(ctx, &r, v))
+            throw exception{};
+        return r;
+    }
 
-        // identity
-        template <>
-        struct js_traits<JSValue>
-        {
-            static JSValue unwrap(JSContext * ctx, JSValueConst v) noexcept
-            {
-                return JS_DupValue(ctx, v);
-            }
+    static JSValue wrap(JSContext * ctx, int32_t i) noexcept
+    {
+        return JS_NewInt32(ctx, i);
+    }
+};
 
-            static JSValue wrap(JSContext * ctx, JSValue v) noexcept
-            {
-                return v;
-            }
-        };
+template <>
+struct js_traits<bool>
+{
+    static bool unwrap(JSContext * ctx, JSValueConst v) noexcept
+    {
+        return JS_ToBool(ctx, v);
+    }
 
-        template <>
-        struct js_traits<int32_t>
-        {
-            static int32_t unwrap(JSContext * ctx, JSValueConst v)
-            {
-                int32_t r;
-                if(JS_ToInt32(ctx, &r, v))
-                    throw exception{};
-                return r;
-            }
+    static JSValue wrap(JSContext * ctx, bool i) noexcept
+    {
+        return JS_NewBool(ctx, i);
+    }
+};
 
-            static JSValue wrap(JSContext * ctx, int32_t i) noexcept
-            {
-                return JS_NewInt32(ctx, i);
-            }
-        };
+template <>
+struct js_traits<void>
+{
+    static void unwrap(JSContext * ctx, JSValueConst undefined)
+    {
+        if(!JS_IsUndefined(undefined))
+            throw exception{};
+    }
+};
 
-        template <>
-        struct js_traits<bool>
-        {
-            static bool unwrap(JSContext * ctx, JSValueConst v) noexcept
-            {
-                return JS_ToBool(ctx, v);
-            }
+template <>
+struct js_traits<double>
+{
+    static double unwrap(JSContext * ctx, JSValueConst v)
+    {
+        double r;
+        if(JS_ToFloat64(ctx, &r, v))
+            throw exception{};
+        return r;
+    }
 
-            static JSValue wrap(JSContext * ctx, bool i) noexcept
-            {
-                return JS_NewBool(ctx, i);
-            }
-        };
+    static JSValue wrap(JSContext * ctx, double i) noexcept
+    {
+        return JS_NewFloat64(ctx, i);
+    }
+};
 
-        template <>
-        struct js_traits<void>
-        {
-            static void unwrap(JSContext * ctx, JSValueConst undefined)
-            {
-                if(!JS_IsUndefined(undefined))
-                    throw exception{};
-            }
-        };
+namespace detail {
+class js_string : public std::string_view
+{
+    using Base = std::string_view;
+    JSContext * ctx = nullptr;
 
-        template <>
-        struct js_traits<double>
-        {
-            static double unwrap(JSContext * ctx, JSValueConst v)
-            {
-                double r;
-                if(JS_ToFloat64(ctx, &r, v))
-                    throw exception{};
-                return r;
-            }
+    friend struct js_traits<std::string_view>;
 
-            static JSValue wrap(JSContext * ctx, double i) noexcept
-            {
-                return JS_NewFloat64(ctx, i);
-            }
-        };
+    js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx)
+    {}
 
-        class js_string : public std::string_view
-        {
-            using Base = std::string_view;
-            JSContext * ctx = nullptr;
+public:
 
-            friend struct js_traits<std::string_view>;
-            js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx) {}
-        public:
+    template <typename... Args>
+    js_string(Args&& ... args) : Base(std::forward<Args>(args)...), ctx(nullptr)
+    {}
 
-            template <typename... Args>
-            js_string(Args&&... args) : Base(std::forward<Args>(args)...), ctx(nullptr) {}
+    js_string(const js_string& other) = delete;
 
-            js_string(const js_string& other) = delete;
+    ~js_string()
+    {
+        if(ctx)
+            JS_FreeCString(ctx, this->data());
+    }
+};
+} // namespace detail
 
-            ~js_string()
-            {
-                if(ctx)
-                    JS_FreeCString(ctx, this->data());
-            }
-        };
+template <>
+struct js_traits<std::string_view>
+{
+    static detail::js_string unwrap(JSContext * ctx, JSValueConst v)
+    {
+        std::size_t plen;
+        const char * ptr = JS_ToCStringLen(ctx, &plen, v);
+        if(!ptr)
+            throw exception{};
+        return detail::js_string{ctx, ptr, plen};
+    }
 
-        template <>
-        struct js_traits<std::string_view>
-        {
-            static js_string unwrap(JSContext * ctx, JSValueConst v)
-            {
-                std::size_t plen;
-                const char * ptr = JS_ToCStringLen(ctx, &plen, v);
-                if(!ptr)
-                    throw exception{};
-                return js_string{ctx, ptr, plen};
-            }
+    static JSValue wrap(JSContext * ctx, std::string_view str) noexcept
+    {
+        return JS_NewStringLen(ctx, str.data(), (int) str.size());
+    }
+};
 
-            static JSValue wrap(JSContext * ctx, std::string_view str) noexcept
-            {
-                return JS_NewStringLen(ctx, str.data(), (int)str.size());
-            }
-        };
+template <> // slower
+struct js_traits<std::string>
+{
+    static std::string unwrap(JSContext * ctx, JSValueConst v)
+    {
+        auto str_view = js_traits<std::string_view>::unwrap(ctx, v);
+        return std::string{str_view.data(), str_view.size()};
+    }
 
-        template <> // slower
-        struct js_traits<std::string>
-        {
-            static std::string unwrap(JSContext * ctx, JSValueConst v)
-            {
-                auto str_view = js_traits<std::string_view>::unwrap(ctx, v);
-                return std::string{str_view.data(), str_view.size()};
-            }
+    static JSValue wrap(JSContext * ctx, const std::string& str) noexcept
+    {
+        return JS_NewStringLen(ctx, str.data(), (int) str.size());
+    }
+};
 
-            static JSValue wrap(JSContext * ctx, const std::string& str) noexcept
-            {
-                return JS_NewStringLen(ctx, str.data(), (int) str.size());
-            }
-        };
+namespace detail {
 
-        // unwrap and free value
-        template <typename T>
-        T unwrap_free(JSContext * ctx, JSValue val)
+// unwrap and free value
+template <typename T>
+T unwrap_free(JSContext * ctx, JSValue val)
+{
+    if constexpr(std::is_same_v<T, void>)
+    {
+        JS_FreeValue(ctx, val);
+        return js_traits<T>::unwrap(ctx, val);
+    } else
+    {
+        try
         {
-            if constexpr(std::is_same_v<T, void>)
-            {
-                JS_FreeValue(ctx, val);
-                return js_traits<T>::unwrap(ctx, val);
-            }
-            else
-            {
-                try
-                {
-                    T result = js_traits<std::decay_t<T>>::unwrap(ctx, val);
-                    JS_FreeValue(ctx, val);
-                    return result;
-                }
-                catch(...)
-                {
-                    JS_FreeValue(ctx, val);
-                    throw;
-                }
-            }
+            T result = js_traits<std::decay_t<T>>::unwrap(ctx, val);
+            JS_FreeValue(ctx, val);
+            return result;
         }
-
-        template <class Tuple, std::size_t... I>
-        Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
+        catch(...)
         {
-            return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
+            JS_FreeValue(ctx, val);
+            throw;
         }
+    }
+}
 
-        template <typename... Args>
-        std::tuple<Args...> unwrap_args(JSContext * ctx, JSValueConst * argv)
-        {
-            return unwrap_args_impl<std::tuple<Args...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
-        }
+template <class Tuple, std::size_t... I>
+Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
+{
+    return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
+}
 
-        template <typename R, typename... Args, typename Callable>
-        JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
-        {
-            try
-            {
-                if constexpr(std::is_same_v<R, void>)
-                {
-                    std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
-                    return JS_UNDEFINED;
-                } else
-                {
-                    return js_traits<std::decay_t<R>>::wrap(ctx,
-                                                            std::apply(std::forward<Callable>(f),
-                                                                       unwrap_args<Args...>(ctx, argv)));
-                }
-            }
-            catch(exception)
-            {
-                return JS_EXCEPTION;
-            }
-        }
+template <typename... Args>
+std::tuple<Args...> unwrap_args(JSContext * ctx, JSValueConst * argv)
+{
+    return unwrap_args_impl<std::tuple<Args...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
+}
 
-        template <typename R, typename FirstArg, typename... Args, typename Callable>
-        JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
+template <typename R, typename... Args, typename Callable>
+JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
+{
+    try
+    {
+        if constexpr(std::is_same_v<R, void>)
         {
-            try
-            {
-                if constexpr(std::is_same_v<R, void>)
-                {
-                    std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
-                            unwrap_args<Args...>(ctx, argv)));
-                    return JS_UNDEFINED;
-                } else
-                {
-                    return js_traits<std::decay_t<R>>::wrap(ctx,
-                                                            std::apply(std::forward<Callable>(f),
-                                                                       std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
-                                                                                      unwrap_args<Args...>(ctx, argv))));
-                }
-            }
-            catch(exception)
-            {
-                return JS_EXCEPTION;
-            }
-        }
-
-        template <class Tuple, std::size_t... I>
-        void wrap_args_impl(JSContext * ctx, JSValue * argv, Tuple tuple, std::index_sequence<I...>)
+            std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
+            return JS_UNDEFINED;
+        } else
         {
-            ((argv[I] = js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::wrap(ctx, std::get<I>(tuple))), ...);
+            return js_traits<std::decay_t<R>>::wrap(ctx,
+                                                    std::apply(std::forward<Callable>(f),
+                                                               unwrap_args<Args...>(ctx, argv)));
         }
+    }
+    catch(exception)
+    {
+        return JS_EXCEPTION;
+    }
+}
 
-        template <typename... Args>
-        void wrap_args(JSContext * ctx, JSValue * argv, Args&&... args)
+template <typename R, typename FirstArg, typename... Args, typename Callable>
+JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
+{
+    try
+    {
+        if constexpr(std::is_same_v<R, void>)
         {
-            wrap_args_impl(ctx, argv, std::make_tuple(std::forward<Args>(args)...), std::make_index_sequence<sizeof...(Args)>());
-        }
-
-        template <auto F, bool PassThis = false /* pass this as the first argument */>
-        struct fwrapper
+            std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
+                                                                 unwrap_args<Args...>(ctx, argv)));
+            return JS_UNDEFINED;
+        } else
         {
-            const char * name = nullptr;
-        };
+            return js_traits<std::decay_t<R>>::wrap(ctx,
+                                                    std::apply(std::forward<Callable>(f),
+                                                               std::tuple_cat(
+                                                                       unwrap_args<FirstArg>(ctx, &this_value),
+                                                                       unwrap_args<Args...>(ctx, argv))));
+        }
+    }
+    catch(exception)
+    {
+        return JS_EXCEPTION;
+    }
+}
 
-        // free function
-        template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
-        struct js_traits<fwrapper<F, PassThis>>
-        {
-            static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
-            {
-                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                               JSValueConst * argv) noexcept -> JSValue {
-                    if constexpr(PassThis)
-                        return wrap_this_call<R, Args...>(ctx, F, this_value, argv);
-                    else
-                        return wrap_call<R, Args...>(ctx, F, argv);
-                }, fw.name, sizeof...(Args));
+template <class Tuple, std::size_t... I>
+void wrap_args_impl(JSContext * ctx, JSValue * argv, Tuple tuple, std::index_sequence<I...>)
+{
+    ((argv[I] = js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::wrap(ctx, std::get<I>(tuple))), ...);
+}
 
-            }
-        };
+template <typename... Args>
+void wrap_args(JSContext * ctx, JSValue * argv, Args&& ... args)
+{
+    wrap_args_impl(ctx, argv, std::make_tuple(std::forward<Args>(args)...),
+                   std::make_index_sequence<sizeof...(Args)>());
+}
+} // namespace detail
+
+template <auto F, bool PassThis = false /* pass this as the first argument */>
+struct fwrapper
+{
+    const char * name = nullptr;
+};
+
+// free function
+template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
+struct js_traits<fwrapper<F, PassThis>>
+{
+    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
+    {
+        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                       JSValueConst * argv) noexcept -> JSValue {
+            if constexpr(PassThis)
+                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argv);
+            else
+                return detail::wrap_call<R, Args...>(ctx, F, argv);
+        }, fw.name, sizeof...(Args));
 
-        // class member function
+    }
+};
 
-        template <typename R, class T, typename... Args, R (T::*F)(Args...)>
-        struct js_traits<fwrapper<F>>
-        {
-            static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
-            {
-                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                               JSValueConst * argv) noexcept -> JSValue {
-                    return wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
-                }, fw.name, sizeof...(Args));
+// class member function
 
-            }
-        };
+template <typename R, class T, typename... Args, R (T::*F)(Args...)>
+struct js_traits<fwrapper<F>>
+{
+    static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
+    {
+        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                       JSValueConst * argv) noexcept -> JSValue {
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+        }, fw.name, sizeof...(Args));
 
-        template <typename R, class T, typename... Args, R (T::*F)(Args...) const>
-        struct js_traits<fwrapper<F>>
-        {
-            static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
-            {
-                return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                               JSValueConst * argv) noexcept -> JSValue {
-                    return wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
-                }, fw.name, sizeof...(Args));
+    }
+};
 
-            }
-        };
+template <typename R, class T, typename... Args, R (T::*F)(Args...) const>
+struct js_traits<fwrapper<F>>
+{
+    static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
+    {
+        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                       JSValueConst * argv) noexcept -> JSValue {
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+        }, fw.name, sizeof...(Args));
 
-        // class constructor
+    }
+};
 
-        template <class T, typename... Args>
-        struct ctor_wrapper
-        {
-            static_assert(std::is_constructible<T, Args...>::value, "no such constructor!");
-            const char * name = nullptr;
-        };
+// class constructor
 
-        template <class T, typename... Args>
-        struct js_traits<ctor_wrapper<T, Args...>>
-        {
-            static JSValue wrap(JSContext * ctx, ctor_wrapper<T, Args...> cw) noexcept
-            {
-                return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                                JSValueConst * argv) noexcept -> JSValue {
-                    return wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
-                }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
+template <class T, typename... Args>
+struct ctor_wrapper
+{
+    static_assert(std::is_constructible<T, Args...>::value, "no such constructor!");
+    const char * name = nullptr;
+};
 
-            }
-        };
+template <class T, typename... Args>
+struct js_traits<ctor_wrapper<T, Args...>>
+{
+    static JSValue wrap(JSContext * ctx, ctor_wrapper<T, Args...> cw) noexcept
+    {
+        return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                        JSValueConst * argv) noexcept -> JSValue {
+            return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
+        }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
 
+    }
+};
 
-        // SP<T> class
 
-        template <class T>
-        struct js_traits<std::shared_ptr<T>>
-        {
-            inline static JSClassID QJSClassId;
+// SP<T> class
 
-            static void register_class(JSContext * ctx, const char * name, JSValue proto)
-            {
-                JSClassDef def{
-                        name,
-                        // destructor
-                        [](JSRuntime * rt, JSValue obj) noexcept {
-                            auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
-                            assert(pptr);
-                            //delete pptr;
-                            auto alloc = allocator<std::shared_ptr<T>>{rt};
-                            using atraits = std::allocator_traits<decltype(alloc)>;
-                            atraits::destroy(alloc, pptr);
-                            atraits::deallocate(alloc, pptr, 1);
-                        }
-                };
-                int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
-                if(e < 0)
-                    throw exception{};
-                JS_SetClassProto(ctx, QJSClassId, proto);
-            }
+template <class T>
+struct js_traits<std::shared_ptr<T>>
+{
+    inline static JSClassID QJSClassId;
 
-            static JSValue wrap(JSContext * ctx, std::shared_ptr<T> ptr)
-            {
-                if(QJSClassId == 0) // not registered
-                    throw exception{};
-                auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
-                if(JS_IsException(jsobj))
-                {
-                    return jsobj;
+    static void register_class(JSContext * ctx, const char * name, JSValue proto)
+    {
+        JSClassDef def{
+                name,
+                // destructor
+                [](JSRuntime * rt, JSValue obj) noexcept {
+                    auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
+                    assert(pptr);
+                    //delete pptr;
+                    auto alloc = allocator<std::shared_ptr<T>>{rt};
+                    using atraits = std::allocator_traits<decltype(alloc)>;
+                    atraits::destroy(alloc, pptr);
+                    atraits::deallocate(alloc, pptr, 1);
                 }
-                //auto pptr = new std::shared_ptr<T>(std::move(ptr));
-                auto alloc = allocator<std::shared_ptr<T>>{ctx};
-                using atraits = std::allocator_traits<decltype(alloc)>;
-                auto pptr = atraits::allocate(alloc, 1);
-                atraits::construct(alloc, pptr, std::move(ptr));
-
-                JS_SetOpaque(jsobj, pptr);
-                return jsobj;
-            }
-
-            static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
-            {
-                auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
-                if(!ptr)
-                    throw exception{};
-                return *ptr;
-            }
         };
+        int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+        if(e < 0)
+            throw exception{};
+        JS_SetClassProto(ctx, QJSClassId, proto);
+    }
 
-        // T * - non-owning pointer
-        template <class T>
-        struct js_traits<T *>
+    static JSValue wrap(JSContext * ctx, std::shared_ptr<T> ptr)
+    {
+        if(QJSClassId == 0) // not registered
+            throw exception{};
+        auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
+        if(JS_IsException(jsobj))
         {
-            static JSValue wrap(JSContext * ctx, T * ptr)
-            {
-                if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
-                    throw exception{};
-                auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
-                if(JS_IsException(jsobj))
-                {
-                    return jsobj;
-                }
-                //auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
-                auto alloc = allocator<std::shared_ptr<T>>{ctx};
-                using atraits = std::allocator_traits<decltype(alloc)>;
-                auto pptr = atraits::allocate(alloc, 1);
-                atraits::construct(alloc, pptr, ptr, [](T *){}); // shared_ptr with empty deleter
-
-                JS_SetOpaque(jsobj, pptr);
-                return jsobj;
-            }
-
-            static T * unwrap(JSContext * ctx, JSValueConst v)
-            {
-                auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, js_traits<std::shared_ptr<T>>::QJSClassId));
-                if(!ptr)
-                    throw exception{};
-                return ptr->get();
-            }
-        };
+            return jsobj;
+        }
+        //auto pptr = new std::shared_ptr<T>(std::move(ptr));
+        auto alloc = allocator<std::shared_ptr<T>>{ctx};
+        using atraits = std::allocator_traits<decltype(alloc)>;
+        auto pptr = atraits::allocate(alloc, 1);
+        atraits::construct(alloc, pptr, std::move(ptr));
+
+        JS_SetOpaque(jsobj, pptr);
+        return jsobj;
+    }
 
+    static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
+    {
+        auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
+        if(!ptr)
+            throw exception{};
+        return *ptr;
+    }
+};
 
-        struct function // std::function replacement
+// T * - non-owning pointer
+template <class T>
+struct js_traits<T *>
+{
+    static JSValue wrap(JSContext * ctx, T * ptr)
+    {
+        if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
+            throw exception{};
+        auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
+        if(JS_IsException(jsobj))
         {
-            JSValue (*invoker)(function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) = nullptr;
-            void (*destroyer)(function * self) = nullptr;
-            alignas(std::max_align_t) char functor[];
+            return jsobj;
+        }
+        //auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
+        auto alloc = allocator<std::shared_ptr<T>>{ctx};
+        using atraits = std::allocator_traits<decltype(alloc)>;
+        auto pptr = atraits::allocate(alloc, 1);
+        atraits::construct(alloc, pptr, ptr, [](T *) {}); // shared_ptr with empty deleter
+
+        JS_SetOpaque(jsobj, pptr);
+        return jsobj;
+    }
 
-            template <typename Functor>
-            static function * create(JSRuntime * rt, Functor&& f)
-            {
-                auto fptr = reinterpret_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
-                if(!fptr)
-                    throw std::bad_alloc{};
-                new (fptr) function;
+    static T * unwrap(JSContext * ctx, JSValueConst v)
+    {
+        auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v,
+                                                                        js_traits<std::shared_ptr<T>>::QJSClassId));
+        if(!ptr)
+            throw exception{};
+        return ptr->get();
+    }
+};
+
+namespace detail {
+struct function // std::function replacement
+{
+    JSValue
+    (* invoker)(function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) = nullptr;
+
+    void (* destroyer)(function * self) = nullptr;
+
+    alignas(std::max_align_t) char functor[];
+
+    template <typename Functor>
+    static function * create(JSRuntime * rt, Functor&& f)
+    {
+        auto fptr = reinterpret_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
+        if(!fptr)
+            throw std::bad_alloc{};
+        new(fptr) function;
+        auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
+        new(functorptr) Functor(std::forward<Functor>(f));
+        fptr->destroyer = nullptr;
+        if constexpr(!std::is_trivially_destructible_v<Functor>)
+        {
+            fptr->destroyer = [](function * fptr) {
                 auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
-                new(functorptr) Functor(std::forward<Functor>(f));
-                fptr->destroyer = nullptr;
-                if constexpr(!std::is_trivially_destructible_v<Functor>)
-                {
-                    fptr->destroyer = [](function * fptr) {
-                        auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
-                        functorptr->~Functor();
-                    };
+                functorptr->~Functor();
+            };
+        }
+        return fptr;
+    }
+};
+
+static_assert(std::is_trivially_destructible_v<function>);
+}
+
+template <>
+struct js_traits<detail::function>
+{
+    inline static JSClassID QJSClassId;
+
+    static void register_class(JSContext * ctx, const char * name)
+    {
+        JSClassDef def{
+                name,
+                // destructor
+                [](JSRuntime * rt, JSValue obj) noexcept {
+                    auto fptr = reinterpret_cast<detail::function *>(JS_GetOpaque(obj, QJSClassId));
+                    assert(fptr);
+                    if(fptr->destroyer)
+                        fptr->destroyer(fptr);
+                    js_free_rt(rt, fptr);
+                },
+                nullptr, // mark
+                // call
+                [](JSContext * ctx, JSValueConst func_obj, JSValueConst this_val, int argc,
+                   JSValueConst * argv) -> JSValue {
+                    auto ptr = reinterpret_cast<detail::function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
+                    if(!ptr)
+                        return JS_EXCEPTION;
+                    return ptr->invoker(ptr, ctx, this_val, argc, argv);
                 }
-                return fptr;
-            }
         };
-        static_assert(std::is_trivially_destructible_v<function>);
+        int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+        if(e < 0)
+            throw exception{};
+    }
+};
 
 
-        template <>
-        struct js_traits<function>
-        {
-            inline static JSClassID QJSClassId;
-            static void register_class(JSContext * ctx, const char * name)
-            {
-                JSClassDef def{
-                        name,
-                        // destructor
-                        [](JSRuntime * rt, JSValue obj) noexcept {
-                            auto fptr = reinterpret_cast<function *>(JS_GetOpaque(obj, QJSClassId));
-                            assert(fptr);
-                            if(fptr->destroyer)
-                                fptr->destroyer(fptr);
-                            js_free_rt(rt, fptr);
-                        },
-                        nullptr, // mark
-                        // call
-                        [](JSContext *ctx, JSValueConst func_obj, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-                            auto ptr = reinterpret_cast<function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
-                            if(!ptr)
-                                return JS_EXCEPTION;
-                            return ptr->invoker(ptr, ctx, this_val, argc, argv);
-                        }
-                };
-                int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
-                if(e < 0)
-                    throw exception{};
-            }
-        };
+//          properties
 
+template <typename Key>
+struct js_property_traits
+{
+    // static void set_property(JSContext * ctx, JSValue this_obj, R key, JSValue value)
+    // static JSValue get_property(JSContext * ctx, JSValue this_obj, R key)
+};
 
-        //          properties
+template <>
+struct js_property_traits<const char *>
+{
+    static void set_property(JSContext * ctx, JSValue this_obj, const char * name, JSValue value)
+    {
+        int err = JS_SetPropertyStr(ctx, this_obj, name, value);
+        if(err < 0)
+            throw exception{};
+    }
 
-        template <typename Key>
-        struct js_property_traits
-        {
-            // static void set_property(JSContext * ctx, JSValue this_obj, R key, JSValue value)
-            // static JSValue get_property(JSContext * ctx, JSValue this_obj, R key)
-        };
+    static JSValue get_property(JSContext * ctx, JSValue this_obj, const char * name) noexcept
+    {
+        return JS_GetPropertyStr(ctx, this_obj, name);
+    }
+};
 
-        template <>
-        struct js_property_traits<const char *>
-        {
-            static void set_property(JSContext * ctx, JSValue this_obj, const char * name, JSValue value)
-            {
-                int err = JS_SetPropertyStr(ctx, this_obj, name, value);
-                if(err < 0)
-                    throw exception{};
-            }
+template <>
+struct js_property_traits<uint32_t>
+{
+    static void set_property(JSContext * ctx, JSValue this_obj, uint32_t idx, JSValue value)
+    {
+        int err = JS_SetPropertyUint32(ctx, this_obj, idx, value);
+        if(err < 0)
+            throw exception{};
+    }
 
-            static JSValue get_property(JSContext * ctx, JSValue this_obj, const char * name) noexcept
-            {
-                return JS_GetPropertyStr(ctx, this_obj, name);
-            }
-        };
+    static JSValue get_property(JSContext * ctx, JSValue this_obj, uint32_t idx) noexcept
+    {
+        return JS_GetPropertyUint32(ctx, this_obj, idx);
+    }
+};
+
+namespace detail {
+template <typename Key>
+struct property_proxy
+{
+    JSContext * ctx;
+    JSValue this_obj;
+    Key key;
+
+    template <typename Value>
+    operator Value() const
+    {
+        return unwrap_free<Value>(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
+    }
 
-        template <>
-        struct js_property_traits<uint32_t>
-        {
-            static void set_property(JSContext * ctx, JSValue this_obj, uint32_t idx, JSValue value)
-            {
-                int err = JS_SetPropertyUint32(ctx, this_obj, idx, value);
-                if(err < 0)
-                    throw exception{};
-            }
+    template <typename Value>
+    property_proxy& operator =(Value value)
+    {
+        js_property_traits<Key>::set_property(ctx, this_obj, key,
+                                              js_traits<Value>::wrap(ctx, std::move(value)));
+        return *this;
+    }
+};
 
-            static JSValue get_property(JSContext * ctx, JSValue this_obj, uint32_t idx) noexcept
-            {
-                return JS_GetPropertyUint32(ctx, this_obj, idx);
-            }
-        };
 
-        template <typename Key>
-        struct property_proxy
-        {
-            JSContext * ctx;
-            JSValue this_obj;
-            Key key;
+// class member variable getter/setter
+template <auto M>
+struct get_set {};
 
-            template <typename Value>
-            operator Value() const
-            {
-                return unwrap_free<Value>(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
-            }
+template <class T, typename R, R T::*M>
+struct get_set<M>
+{
+    using is_const = std::is_const<R>;
 
-            template <typename Value>
-            property_proxy& operator =(Value value)
-            {
-                js_property_traits<Key>::set_property(ctx, this_obj, key,
-                                                      js_traits<Value>::wrap(ctx, std::move(value)));
-                return *this;
-            }
-        };
+    static const R& get(const std::shared_ptr<T>& ptr)
+    {
+        return *ptr.*M;
+    }
 
+    static R& set(const std::shared_ptr<T>& ptr, R value)
+    {
+        return *ptr.*M = std::move(value);
+    }
 
+};
 
-        // class member variable getter/setter
-        template <auto M>
-        struct get_set
-        {};
+} // namespace detail
 
-        template <class T, typename R, R T::*M>
-        struct get_set<M>
-        {
-            using is_const = std::is_const<R>;
+class Value
+{
+public:
+    JSValue v;
+    JSContext * ctx = nullptr;
 
-            static const R& get(const std::shared_ptr<T>& ptr)
-            {
-                return *ptr.*M;
-            }
+public:
+    template <typename T>
+    Value(JSContext * ctx, T val) : ctx(ctx)
+    {
+        v = js_traits<T>::wrap(ctx, val);
+    }
 
-            static R& set(const std::shared_ptr<T>& ptr, R value)
-            {
-                return *ptr.*M = std::move(value);
-            }
+    Value(const Value& rhs)
+    {
+        ctx = rhs.ctx;
+        v = JS_DupValue(ctx, rhs.v);
+    }
 
-        };
+    Value(Value&& rhs)
+    {
+        std::swap(ctx, rhs.ctx);
+        v = rhs.v;
+    }
 
+    ~Value()
+    {
+        if(ctx) JS_FreeValue(ctx, v);
     }
 
-    class Value
+
+    template <typename T>
+    T cast() const
     {
-    public:
-        JSValue v;
-        JSContext * ctx = nullptr;
+        return js_traits<T>::unwrap(ctx, v);
+    }
 
-    public:
-        template <typename T>
-        Value(JSContext * ctx, T val) : ctx(ctx)
-        {
-            v = detail::js_traits<T>::wrap(ctx, val);
-        }
+    JSValue release() // dont call freevalue
+    {
+        ctx = nullptr;
+        return v;
+    }
 
-        Value(const Value& rhs)
-        {
-            ctx = rhs.ctx;
-            v = JS_DupValue(ctx, rhs.v);
-        }
+    operator JSValue()&&
+    {
+        return release();
+    }
 
-        Value(Value&& rhs)
-        {
-            std::swap(ctx, rhs.ctx);
-            v = rhs.v;
-        }
 
-        ~Value()
-        {
-            if(ctx) JS_FreeValue(ctx, v);
-        }
+    // access properties
+    template <typename Key>
+    detail::property_proxy<Key> operator [](Key key)
+    {
+        return {ctx, v, std::move(key)};
+    }
 
 
-        template <typename T>
-        T cast() const
-        {
-            return detail::js_traits<T>::unwrap(ctx, v);
-        }
+    // add("f", []() {...});
+    template <typename Function>
+    Value& add(const char * name, Function&& f)
+    {
+        (*this)[name] = js_traits<decltype(std::function{std::forward<Function>(f)})>::wrap(ctx,
+                                                                                            std::forward<Function>(f));
+        return *this;
+    }
 
-        JSValue release() // dont call freevalue
-        {
-            ctx = nullptr;
-            return v;
-        }
+    // add<&f>("f");
+    // add<&T::f>("f");
+    template <auto F>
+    std::enable_if_t<!std::is_member_object_pointer_v<decltype(F)>, Value&>
+    add(const char * name)
+    {
+        (*this)[name] = fwrapper<F>{name};
+        return *this;
+    }
 
-        operator JSValue()&&
+    // add<&T::member>("member");
+    template <auto M>
+    std::enable_if_t<std::is_member_object_pointer_v<decltype(M)>, Value&>
+    add(const char * name)
+    {
+        auto prop = JS_NewAtom(ctx, name);
+        using fgetter = fwrapper<detail::get_set<M>::get, true>;
+        int ret;
+        if constexpr (detail::get_set<M>::is_const::value)
         {
-            return release();
+            ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                          js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                          JS_UNDEFINED,
+                                          0 // ?
+            );
+        } else
+        {
+            using fsetter = fwrapper<detail::get_set<M>::set, true>;
+            ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                          js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                          js_traits<fsetter>::wrap(ctx, fsetter{name}),
+                                          JS_PROP_WRITABLE // ?
+            );
         }
+        JS_FreeAtom(ctx, prop);
+        if(ret < 0)
+            throw exception{};
+        return *this;
+    }
 
 
-        // access properties
-        template <typename Key>
-        detail::property_proxy<Key> operator [](Key key)
-        {
-            return {ctx, v, std::move(key)};
-        }
+};
+
+
+class Runtime
+{
+public:
+    JSRuntime * rt;
+
+    Runtime()
+    {
+        rt = JS_NewRuntime();
+        if(!rt)
+            throw exception{};
+    }
+
+    Runtime(const Runtime&) = delete;
 
+    ~Runtime()
+    {
+        JS_FreeRuntime(rt);
+    }
+};
+
+
+class Context
+{
+public:
+    JSContext * ctx;
 
-        // add("f", []() {...});
-        template <typename Function>
-        Value& add(const char * name, Function&& f)
+    //private:
+    class Module
+    {
+        friend class Context;
+
+        JSModuleDef * m;
+        JSContext * ctx;
+        const char * name;
+
+        using nvp = std::pair<const char *, Value>;
+        std::vector<nvp, allocator<nvp>> exports;
+    public:
+        Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
         {
-            (*this)[name] = detail::js_traits<decltype(std::function{std::forward<Function>(f)})>::wrap(ctx, std::forward<Function>(f));
-            return *this;
+            m = JS_NewCModule(ctx, name, [](JSContext * ctx, JSModuleDef * m) noexcept {
+                auto context = reinterpret_cast<Context *>(JS_GetContextOpaque(ctx));
+                if(!context)
+                    return -1;
+                auto it = std::find_if(context->modules.begin(), context->modules.end(),
+                                       [m](const Module& module) { return module.m == m; });
+                if(it == context->modules.end())
+                    return -1;
+                for(const auto& e : it->exports)
+                {
+                    if(JS_SetModuleExport(ctx, m, e.first, JS_DupValue(ctx, e.second.v)) != 0)
+                        return -1;
+                }
+                return 0;
+            });
+            if(!m)
+                throw exception{};
         }
 
-        // add<&f>("f");
-        // add<&T::f>("f");
-        template <auto F>
-        std::enable_if_t<!std::is_member_object_pointer_v<decltype(F)>, Value&>
-        add(const char * name)
+        Module& add(const char * name, JSValue value)
         {
-            (*this)[name] = detail::fwrapper<F>{name};
+            exports.push_back({name, {ctx, value}});
+            JS_AddModuleExport(ctx, m, name);
             return *this;
         }
 
-        // add<&T::member>("member");
-        template <auto M>
-        std::enable_if_t<std::is_member_object_pointer_v<decltype(M)>, Value&>
-        add(const char * name)
+        Module& add(const char * name, Value value)
         {
-            auto prop = JS_NewAtom(ctx, name);
-            using fgetter = detail::fwrapper<detail::get_set<M>::get, true>;
-            int ret;
-            if constexpr (detail::get_set<M>::is_const::value)
-            {
-                ret = JS_DefinePropertyGetSet(ctx, v, prop,
-                                              detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
-                                              JS_UNDEFINED,
-                                              0 // ?
-                );
-            }
-            else
-            {
-                using fsetter = detail::fwrapper<detail::get_set<M>::set, true>;
-                ret = JS_DefinePropertyGetSet(ctx, v, prop,
-                                              detail::js_traits<fgetter>::wrap(ctx, fgetter{name}),
-                                              detail::js_traits<fsetter>::wrap(ctx, fsetter{name}),
-                                              JS_PROP_WRITABLE // ?
-                );
-            }
-            JS_FreeAtom(ctx, prop);
-            if(ret < 0)
-                throw detail::exception{};
+            assert(value.ctx == ctx);
+            exports.push_back({name, std::move(value)});
+            JS_AddModuleExport(ctx, m, name);
             return *this;
         }
 
+        template <typename T>
+        Module& add(const char * name, T value)
+        {
+            return add(name, js_traits<T>::wrap(ctx, std::move(value)));
+        }
 
-    };
+        Module(const Module&) = delete;
 
+        Module(Module&&) = default;
+        //Module& operator=(Module&&) = default;
 
-    class Runtime
-    {
-    public:
-        JSRuntime * rt;
 
-        Runtime()
+        // function wrappers
+        template <auto F>
+        Module& function(const char * name)
         {
-            rt = JS_NewRuntime();
-            if(!rt)
-                throw detail::exception{};
+            return add(name, qjs::fwrapper<F>{name});
         }
 
-        Runtime(const Runtime&) = delete;
-
-        ~Runtime()
+        template <typename F>
+        Module& function(const char * name, F&& f)
         {
-            JS_FreeRuntime(rt);
+            return add(name, js_traits<decltype(std::function{std::forward<F>(f)})>::wrap(std::forward<F>(f)));
         }
-    };
 
-
-    class Context
-    {
-    public:
-        JSContext * ctx;
-
-    //private:
-        class Module
+        // class register wrapper
+    private:
+        template <class T>
+        class class_registrar
         {
-            friend class Context;
-
-            JSModuleDef * m;
-            JSContext * ctx;
             const char * name;
-
-            using nvp = std::pair<const char *, Value>;
-            std::vector<nvp, allocator<nvp>> exports;
+            qjs::Value prototype;
+            qjs::Context::Module& module;
+            qjs::Context& context;
         public:
-            Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
+            explicit class_registrar(const char * name, qjs::Context::Module& module, qjs::Context& context) :
+                    name(name),
+                    prototype(context.newObject()),
+                    module(module),
+                    context(context)
             {
-                m = JS_NewCModule(ctx, name, [](JSContext * ctx, JSModuleDef * m) noexcept {
-                    auto context = reinterpret_cast<Context *>(JS_GetContextOpaque(ctx));
-                    if(!context)
-                        return -1;
-                    auto it = std::find_if(context->modules.begin(), context->modules.end(),
-                                           [m](const Module& module) { return module.m == m; });
-                    if(it == context->modules.end())
-                        return -1;
-                    for(const auto& e : it->exports)
-                    {
-                        if(JS_SetModuleExport(ctx, m, e.first, JS_DupValue(ctx, e.second.v)) != 0)
-                            return -1;
-                    }
-                    return 0;
-                });
-                if(!m)
-                    throw detail::exception{};
             }
 
-            Module& add(const char * name, JSValue value)
+            class_registrar(const class_registrar&) = delete;
+
+            template <typename F>
+            class_registrar& fun(const char * name, F&& f)
             {
-                exports.push_back({name, {ctx, value}});
-                JS_AddModuleExport(ctx, m, name);
+                prototype.add(name, std::forward<F>(f));
                 return *this;
             }
 
-            Module& add(const char * name, Value value)
+            template <auto F>
+            class_registrar& fun(const char * name)
             {
-                assert(value.ctx == ctx);
-                exports.push_back({name, std::move(value)});
-                JS_AddModuleExport(ctx, m, name);
+                prototype.add<F>(name);
                 return *this;
             }
 
-            template <typename T>
-            Module& add(const char * name, T value)
+            template <typename... Args>
+            class_registrar& constructor(const char * name = nullptr)
             {
-                return add(name, detail::js_traits<T>::wrap(ctx, std::move(value)));
+                if(!name)
+                    name = this->name;
+                module.add(name, qjs::ctor_wrapper<T, Args...>{name});
+                return *this;
             }
 
-            Module(const Module&) = delete;
-            Module(Module&&)  = default;
-            //Module& operator=(Module&&) = default;
-
-
-            // function wrappers
-            template <auto F>
-            Module& function(const char * name)
-            {
-                return add(name, qjs::detail::fwrapper<F>{name});
-            }
-            template <typename F>
-            Module& function(const char * name, F&& f)
+            /* TODO: needs casting to base class
+            template <class B>
+            class_registrar& base()
             {
-                return add(name, detail::js_traits<decltype(std::function{std::forward<F>(f)})>::wrap(std::forward<F>(f)));
+                assert(js_traits<std::shared_ptr<B>>::QJSClassId && "base class is not registered");
+                auto base_proto = JS_GetClassProto(context.ctx, js_traits<std::shared_ptr<B>>::QJSClassId);
+                int err = JS_SetPrototype(context.ctx, prototype.v, base_proto);
+                JS_FreeValue(context.ctx, base_proto);
+                if(err < 0)
+                    throw exception{};
+                return *this;
             }
+             */
 
-            // class register wrapper
-        private:
-            template <class T>
-            class class_registrar
+            ~class_registrar()
             {
-                const char * name;
-                qjs::Value prototype;
-                qjs::Context::Module& module;
-                qjs::Context& context;
-            public:
-                explicit class_registrar(const char * name, qjs::Context::Module& module, qjs::Context& context) :
-                        name(name),
-                        prototype(context.newObject()),
-                        module(module),
-                        context(context)
-                {
-                }
-
-                class_registrar(const class_registrar&) = delete;
-
-                template <typename F>
-                class_registrar& fun(const char * name, F&& f)
-                {
-                    prototype.add(name, std::forward<F>(f));
-                    return *this;
-                }
-
-                template <auto F>
-                class_registrar& fun(const char * name)
-                {
-                    prototype.add<F>(name);
-                    return *this;
-                }
-
-                template <typename... Args>
-                class_registrar& constructor(const char * name = nullptr)
-                {
-                    if(!name)
-                        name = this->name;
-                    module.add(name, qjs::detail::ctor_wrapper<T, Args...>{name});
-                    return *this;
-                }
-
-                /* TODO: needs casting to base class
-                template <class B>
-                class_registrar& base()
-                {
-                    assert(detail::js_traits<std::shared_ptr<B>>::QJSClassId && "base class is not registered");
-                    auto base_proto = JS_GetClassProto(context.ctx, detail::js_traits<std::shared_ptr<B>>::QJSClassId);
-                    int err = JS_SetPrototype(context.ctx, prototype.v, base_proto);
-                    JS_FreeValue(context.ctx, base_proto);
-                    if(err < 0)
-                        throw detail::exception{};
-                    return *this;
-                }
-                 */
-
-                ~class_registrar()
-                {
-                    context.registerClass<T>(name, std::move(prototype));
-                }
-            };
-        public:
-            template <class T>
-            class_registrar<T> class_(const char * name)
-            {
-                return class_registrar<T>{name, *this, *reinterpret_cast<qjs::Context *>(JS_GetContextOpaque(ctx))};
+                context.registerClass<T>(name, std::move(prototype));
             }
-
         };
 
-        std::vector<Module, allocator<Module>> modules;
-    private:
-        void init()
-        {
-            JS_SetContextOpaque(ctx, this);
-            detail::js_traits<detail::function>::register_class(ctx, "C++ function");
-        }
     public:
-        Context(Runtime& rt) : Context(rt.rt)
-        {}
-
-        Context(JSRuntime * rt) : modules{rt}
-        {
-            ctx = JS_NewContext(rt);
-            if(!ctx)
-                throw detail::exception{};
-            init();
-        }
-
-        Context(JSContext * ctx) : ctx{ctx}, modules{ctx}
+        template <class T>
+        class_registrar<T> class_(const char * name)
         {
-            init();
+            return class_registrar<T>{name, *this, *reinterpret_cast<qjs::Context *>(JS_GetContextOpaque(ctx))};
         }
 
-        Context(const Context&) = delete;
+    };
 
-        ~Context()
-        {
-            modules.clear();
-            JS_FreeContext(ctx);
-        }
+    std::vector<Module, allocator<Module>> modules;
+private:
+    void init()
+    {
+        JS_SetContextOpaque(ctx, this);
+        js_traits<detail::function>::register_class(ctx, "C++ function");
+    }
 
-        Module& addModule(const char * name)
-        {
-            modules.emplace_back(ctx, name);
-            return modules.back();
-        }
+public:
+    Context(Runtime& rt) : Context(rt.rt)
+    {}
 
-        Value global()
-        {
-            return Value{ctx, JS_GetGlobalObject(ctx)};
-        }
+    Context(JSRuntime * rt) : modules{rt}
+    {
+        ctx = JS_NewContext(rt);
+        if(!ctx)
+            throw exception{};
+        init();
+    }
 
-        Value newObject()
-        {
-            return Value{ctx, JS_NewObject(ctx)};
-        }
+    Context(JSContext * ctx) : ctx{ctx}, modules{ctx}
+    {
+        init();
+    }
 
-        template <class T>
-        void registerClass(const char * name, JSValue proto)
-        {
-            detail::js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
-        }
+    Context(const Context&) = delete;
 
-        Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
-        {
-            JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
-            //if(JS_IsException(v))
-            //throw detail::exception{};
-            return Value{ctx, v};
-        }
+    ~Context()
+    {
+        modules.clear();
+        JS_FreeContext(ctx);
+    }
 
-        Value evalFile(const char * filename, unsigned eval_flags = 0)
-        {
-            size_t buf_len;
-            auto deleter = [this](void * p) { js_free(ctx, p); };
-            auto buf = std::unique_ptr<uint8_t, decltype(deleter)>{js_load_file(ctx, &buf_len, filename), deleter};
-            if(!buf)
-                throw std::runtime_error{std::string{"evalFile: can't read file: "} + filename};
-            return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, eval_flags);
-        }
+    Module& addModule(const char * name)
+    {
+        modules.emplace_back(ctx, name);
+        return modules.back();
+    }
 
-    };
+    Value global()
+    {
+        return Value{ctx, JS_GetGlobalObject(ctx)};
+    }
 
+    Value newObject()
+    {
+        return Value{ctx, JS_NewObject(ctx)};
+    }
 
-    namespace detail {
+    template <class T>
+    void registerClass(const char * name, JSValue proto)
+    {
+        js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
+    }
 
-        template <typename R, typename... Args>
-        struct js_traits<std::function<R (Args...)>>
-        {
-            static std::function<R (Args...)> unwrap(JSContext * ctx, JSValueConst fun_obj)
-            {
-                return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&&... args) -> R {
-                    const int argc = sizeof...(Args);
-                    JSValue argv[argc];
-                    wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
-                    JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
-                    for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
-                    return unwrap_free<R>(jsfun_obj.ctx, result);
-                };
-            }
+    Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
+    {
+        JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
+        //if(JS_IsException(v))
+        //throw exception{};
+        return Value{ctx, v};
+    }
 
-            template <typename Functor>
-            static JSValue wrap(JSContext * ctx, Functor&& functor)
-            {
-                auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
-                if(JS_IsException(obj))
-                    return JS_EXCEPTION;
-                auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
-                fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
-                    assert(self);
-                    auto f = reinterpret_cast<Functor *>(&self->functor);
-                    return wrap_call<R, Args...>(ctx, *f, argv);
-                };
-                JS_SetOpaque(obj, fptr);
-                return obj;
-            }
-        };
+    Value evalFile(const char * filename, unsigned eval_flags = 0)
+    {
+        size_t buf_len;
+        auto deleter = [this](void * p) { js_free(ctx, p); };
+        auto buf = std::unique_ptr<uint8_t, decltype(deleter)>{js_load_file(ctx, &buf_len, filename), deleter};
+        if(!buf)
+            throw std::runtime_error{std::string{"evalFile: can't read file: "} + filename};
+        return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, eval_flags);
+    }
 
-        // std::vector <-> Array
-        template <class T>
-        struct js_traits<std::vector<T>>
-        {
-            static JSValue wrap(JSContext * ctx, const std::vector<T>& arr)
-            {
-                auto jsarray = Value{ctx, JS_NewArray(ctx)};
-                if(JS_IsException(jsarray.v))
-                    throw detail::exception{};
+};
 
-                for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
-                    jsarray[i] = arr[i];
 
-                return std::move(jsarray);
-            }
+template <typename R, typename... Args>
+struct js_traits<std::function<R(Args...)>>
+{
+    static std::function<R(Args...)> unwrap(JSContext * ctx, JSValueConst fun_obj)
+    {
+        return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
+            const int argc = sizeof...(Args);
+            JSValue argv[argc];
+            detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
+            JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst *>(argv));
+            for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
+            return detail::unwrap_free<R>(jsfun_obj.ctx, result);
+        };
+    }
 
-            static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)
-            {
-                if(!JS_IsArray(ctx, jsarr))
-                    throw exception{};
-                Value jsarray {ctx, JS_DupValue(ctx, jsarr)};
-                std::vector<T> arr;
-                int32_t len = jsarray["length"];
-                arr.reserve((uint32_t)len);
-                for(uint32_t i = 0; i < (uint32_t)len; i++)
-                    arr.push_back(jsarray[i]);
-                return arr;
-            }
+    template <typename Functor>
+    static JSValue wrap(JSContext * ctx, Functor&& functor)
+    {
+        using detail::function;
+        auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
+        if(JS_IsException(obj))
+            return JS_EXCEPTION;
+        auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
+        fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
+            assert(self);
+            auto f = reinterpret_cast<Functor *>(&self->functor);
+            return detail::wrap_call<R, Args...>(ctx, *f, argv);
         };
+        JS_SetOpaque(obj, fptr);
+        return obj;
+    }
+};
+
+// std::vector <-> Array
+template <class T>
+struct js_traits<std::vector<T>>
+{
+    static JSValue wrap(JSContext * ctx, const std::vector<T>& arr)
+    {
+        auto jsarray = Value{ctx, JS_NewArray(ctx)};
+        if(JS_IsException(jsarray.v))
+            throw exception{};
 
+        for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
+            jsarray[i] = arr[i];
 
+        return std::move(jsarray);
     }
 
+    static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)
+    {
+        if(!JS_IsArray(ctx, jsarr))
+            throw exception{};
+        Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
+        std::vector<T> arr;
+        int32_t len = jsarray["length"];
+        arr.reserve((uint32_t) len);
+        for(uint32_t i = 0; i < (uint32_t) len; i++)
+            arr.push_back(jsarray[i]);
+        return arr;
+    }
+};
+
+
 }
\ No newline at end of file

From 11c0ac6e5a874dc8fab04d06389c993b7539dd4b Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 29 Aug 2019 14:44:16 +0300
Subject: [PATCH 019/185] add documentation

---
 quickjspp.hpp | 206 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 174 insertions(+), 32 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 496302f20f..23e0c355e4 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -17,7 +17,8 @@ extern "C" {
 
 namespace qjs {
 
-
+/** A custom allocator that uses js_malloc_rt and js_free_rt
+ */
 template <typename T>
 struct allocator
 {
@@ -53,17 +54,31 @@ struct allocator
     bool operator !=(const allocator<U>& other) const
     { return rt != other.rt; }
 };
-
+/** Exception type.
+ * Indicates that exception has occured in JS context.
+ */
 class exception {};
 
+/** Javascript conversion traits.
+ * Describes how to convert type R to/from JSValue.
+ */
 template <typename R>
 struct js_traits
 {
-    //static R unwrap(JSContext * ctx, JSValueConst v);
-    //static JSValue wrap(JSContext * ctx, R value);
+    /** Create an object of C++ type R given JSValue v and JSContext.
+     * This function is intentionally not implemented. User should implement this function for their own type.
+     * @param v This value is passed as JSValueConst so it should be freed by the caller.
+     */
+    static R unwrap(JSContext * ctx, JSValueConst v);
+    /** Create JSValue from an object of type R and JSContext.
+     * This function is intentionally not implemented. User should implement this function for their own type.
+     * @return Returns JSValue which should be freed by the caller.
+     */
+    static JSValue wrap(JSContext * ctx, R value);
 };
 
-// identity
+/** Conversion traits for JSValue (identity).
+ */
 template <>
 struct js_traits<JSValue>
 {
@@ -78,9 +93,13 @@ struct js_traits<JSValue>
     }
 };
 
+/** Conversion traits for int32.
+ */
 template <>
 struct js_traits<int32_t>
 {
+
+    /// @throws exception
     static int32_t unwrap(JSContext * ctx, JSValueConst v)
     {
         int32_t r;
@@ -95,6 +114,8 @@ struct js_traits<int32_t>
     }
 };
 
+/** Conversion traits for boolean.
+ */
 template <>
 struct js_traits<bool>
 {
@@ -109,19 +130,25 @@ struct js_traits<bool>
     }
 };
 
+/** Conversion trait for void.
+ */
 template <>
 struct js_traits<void>
 {
+    /// @throws exception if jsvalue is neither undefined nor null
     static void unwrap(JSContext * ctx, JSValueConst undefined)
     {
-        if(!JS_IsUndefined(undefined))
+        if(!JS_IsUndefined(undefined) && !JS_IsNull(undefined))
             throw exception{};
     }
 };
 
+/** Conversion traits for float64/double.
+ */
 template <>
 struct js_traits<double>
 {
+    /// @throws exception
     static double unwrap(JSContext * ctx, JSValueConst v)
     {
         double r;
@@ -137,6 +164,8 @@ struct js_traits<double>
 };
 
 namespace detail {
+/** Fake std::string_view which frees the string on destruction.
+*/
 class js_string : public std::string_view
 {
     using Base = std::string_view;
@@ -163,6 +192,7 @@ class js_string : public std::string_view
 };
 } // namespace detail
 
+/** Conversion traits from std::string_view and to detail::js_string. */
 template <>
 struct js_traits<std::string_view>
 {
@@ -181,6 +211,7 @@ struct js_traits<std::string_view>
     }
 };
 
+/** Conversion traits for std::string */
 template <> // slower
 struct js_traits<std::string>
 {
@@ -198,7 +229,7 @@ struct js_traits<std::string>
 
 namespace detail {
 
-// unwrap and free value
+/** Helper function to convert and then free JSValue. */
 template <typename T>
 T unwrap_free(JSContext * ctx, JSValue val)
 {
@@ -228,12 +259,24 @@ Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence
     return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
 }
 
+/** Helper function to convert an array of JSValues to a tuple.
+ * @tparam Args C++ types of the argv array
+ */
 template <typename... Args>
 std::tuple<Args...> unwrap_args(JSContext * ctx, JSValueConst * argv)
 {
     return unwrap_args_impl<std::tuple<Args...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
 }
 
+/** Helper function to call f with an array of JSValues.
+ * @tparam R return type of f
+ * @tparam Args argument types of f
+ * @tparam Callable type of f (inferred)
+ * @param ctx JSContext
+ * @param f callable object
+ * @param argv array of JSValue's
+ * @return converted return value of f or JS_NULL if f returns void
+ */
 template <typename R, typename... Args, typename Callable>
 JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
 {
@@ -242,7 +285,7 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
         if constexpr(std::is_same_v<R, void>)
         {
             std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
-            return JS_UNDEFINED;
+            return JS_NULL;
         } else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
@@ -256,6 +299,9 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
     }
 }
 
+/** Same as wrap_call, but pass this_value as first argument.
+ * @tparam FirstArg type of this_value
+ */
 template <typename R, typename FirstArg, typename... Args, typename Callable>
 JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
 {
@@ -265,7 +311,7 @@ JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, J
         {
             std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
                                                                  unwrap_args<Args...>(ctx, argv)));
-            return JS_UNDEFINED;
+            return JS_NULL;
         } else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
@@ -287,6 +333,10 @@ void wrap_args_impl(JSContext * ctx, JSValue * argv, Tuple tuple, std::index_seq
     ((argv[I] = js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::wrap(ctx, std::get<I>(tuple))), ...);
 }
 
+/** Converts C++ args to JSValue array.
+ * @tparam Args argument types
+ * @param argv array of size at least sizeof...(Args)
+ */
 template <typename... Args>
 void wrap_args(JSContext * ctx, JSValue * argv, Args&& ... args)
 {
@@ -295,13 +345,19 @@ void wrap_args(JSContext * ctx, JSValue * argv, Args&& ... args)
 }
 } // namespace detail
 
+/** A wrapper type for free and class member functions.
+ * Pointer to function F is a template argument.
+ * @tparam F either a pointer to free function or a pointer to class member function
+ * @tparam PassThis if true and F is a pointer to free function, passes Javascript "this" value as first argument:
+ */
 template <auto F, bool PassThis = false /* pass this as the first argument */>
 struct fwrapper
 {
+    /// "name" property of the JS function object (not defined if nullptr)
     const char * name = nullptr;
 };
 
-// free function
+/** Conversion to JSValue for free function in fwrapper. */
 template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
 struct js_traits<fwrapper<F, PassThis>>
 {
@@ -318,8 +374,7 @@ struct js_traits<fwrapper<F, PassThis>>
     }
 };
 
-// class member function
-
+/** Conversion to JSValue for class member function in fwrapper. */
 template <typename R, class T, typename... Args, R (T::*F)(Args...)>
 struct js_traits<fwrapper<F>>
 {
@@ -333,6 +388,7 @@ struct js_traits<fwrapper<F>>
     }
 };
 
+/** Conversion to JSValue for const class member function in fwrapper. */
 template <typename R, class T, typename... Args, R (T::*F)(Args...) const>
 struct js_traits<fwrapper<F>>
 {
@@ -346,15 +402,19 @@ struct js_traits<fwrapper<F>>
     }
 };
 
-// class constructor
-
+/** A wrapper type for constructor of type T with arguments Args.
+ * Compilation fails if no such constructor is defined.
+ * @tparam Args constructor arguments
+ */
 template <class T, typename... Args>
 struct ctor_wrapper
 {
     static_assert(std::is_constructible<T, Args...>::value, "no such constructor!");
+    /// "name" property of JS constructor object
     const char * name = nullptr;
 };
 
+/** Conversion to JSValue for ctor_wrapper. */
 template <class T, typename... Args>
 struct js_traits<ctor_wrapper<T, Args...>>
 {
@@ -364,18 +424,27 @@ struct js_traits<ctor_wrapper<T, Args...>>
                                         JSValueConst * argv) noexcept -> JSValue {
             return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
         }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
-
     }
 };
 
 
-// SP<T> class
-
+/** Conversions for std::shared_ptr<T>.
+ * T should be registered to a context before conversions.
+ * @tparam T class type
+ */
 template <class T>
 struct js_traits<std::shared_ptr<T>>
 {
+    /// Registered class id in QuickJS.
     inline static JSClassID QJSClassId;
 
+    /** Register class in QuickJS context.
+     *
+     * @param ctx context
+     * @param name class name
+     * @param proto class prototype
+     * @throws exception
+     */
     static void register_class(JSContext * ctx, const char * name, JSValue proto)
     {
         JSClassDef def{
@@ -397,6 +466,10 @@ struct js_traits<std::shared_ptr<T>>
         JS_SetClassProto(ctx, QJSClassId, proto);
     }
 
+    /** Create a JSValue from std::shared_ptr<T>.
+     * Creates an object with class if #QJSClassId and sets its opaque pointer to a new copy of #ptr.
+     * @throws exception if class T is not registered or error on object creation
+     */
     static JSValue wrap(JSContext * ctx, std::shared_ptr<T> ptr)
     {
         if(QJSClassId == 0) // not registered
@@ -416,6 +489,7 @@ struct js_traits<std::shared_ptr<T>>
         return jsobj;
     }
 
+    /// @throws exception if #v doesn't have the correct class id
     static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
     {
         auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
@@ -459,7 +533,10 @@ struct js_traits<T *>
 };
 
 namespace detail {
-struct function // std::function replacement
+/** A faster std::function-like object with type erasure.
+ * Used to convert any callable objects (including lambdas) to JSValue.
+ */
+struct function
 {
     JSValue
     (* invoker)(function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) = nullptr;
@@ -614,6 +691,13 @@ struct get_set<M>
 
 } // namespace detail
 
+/** JSValue with RAAI semantics.
+ * A wrapper over (JSValue v, JSContext * ctx).
+ * Calls JS_FreeValue(ctx, v) on destruction. Can be copied and moved.
+ * A JSValue can be released by either JSValue x = std::move(value); or JSValue x = value.release(), then the Value becomes invalid and FreeValue won't be called
+ * Can be converted to C++ type, for example: auto string = value.as<std::string>(); qjs::exception would be thrown on error
+ * Properties can be accessed (read/write): value["property1"] = 1; value[2] = "2";
+ */
 class Value
 {
 public:
@@ -648,7 +732,13 @@ class Value
     template <typename T>
     T cast() const
     {
-        return js_traits<T>::unwrap(ctx, v);
+        return js_traits<std::decay_t<T>>::unwrap(ctx, v);
+    }
+
+    template <typename T>
+    T as() const
+    {
+        return cast<T>();
     }
 
     JSValue release() // dont call freevalue
@@ -703,7 +793,7 @@ class Value
             ret = JS_DefinePropertyGetSet(ctx, v, prop,
                                           js_traits<fgetter>::wrap(ctx, fgetter{name}),
                                           JS_UNDEFINED,
-                                          0 // ?
+                                          JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE
             );
         } else
         {
@@ -711,7 +801,7 @@ class Value
             ret = JS_DefinePropertyGetSet(ctx, v, prop,
                                           js_traits<fgetter>::wrap(ctx, fgetter{name}),
                                           js_traits<fsetter>::wrap(ctx, fsetter{name}),
-                                          JS_PROP_WRITABLE // ?
+                                          JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE
             );
         }
         JS_FreeAtom(ctx, prop);
@@ -723,7 +813,9 @@ class Value
 
 };
 
-
+/** Thin wrapper over JSRuntime * rt
+ * Calls JS_FreeRuntime on destruction. noncopyable.
+ */
 class Runtime
 {
 public:
@@ -744,13 +836,17 @@ class Runtime
     }
 };
 
-
+/** Wrapper over JSContext * ctx
+ * Calls JS_SetContextOpaque(ctx, this); on construction and JS_FreeContext on destruction
+ */
 class Context
 {
 public:
     JSContext * ctx;
 
-    //private:
+    /** Module wrapper
+     * Workaround for lack of opaque pointer for module load function by keeping a list of modules in qjs::Context.
+     */
     class Module
     {
         friend class Context;
@@ -765,12 +861,10 @@ class Context
         Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
         {
             m = JS_NewCModule(ctx, name, [](JSContext * ctx, JSModuleDef * m) noexcept {
-                auto context = reinterpret_cast<Context *>(JS_GetContextOpaque(ctx));
-                if(!context)
-                    return -1;
-                auto it = std::find_if(context->modules.begin(), context->modules.end(),
+                auto& context = Context::get(ctx);
+                auto it = std::find_if(context.modules.begin(), context.modules.end(),
                                        [m](const Module& module) { return module.m == m; });
-                if(it == context->modules.end())
+                if(it == context.modules.end())
                     return -1;
                 for(const auto& e : it->exports)
                 {
@@ -811,12 +905,21 @@ class Context
 
 
         // function wrappers
+
+        /** Add free function F.
+         * Example:
+         * module.function<static_cast<double (*)(double)>(&::sin)>("sin");
+         */
         template <auto F>
         Module& function(const char * name)
         {
             return add(name, qjs::fwrapper<F>{name});
         }
 
+        /** Add function object f.
+         * Slower than template version.
+         * Example: module.function("sin", [](double x) { return ::sin(x); });
+         */
         template <typename F>
         Module& function(const char * name, F&& f)
         {
@@ -825,6 +928,10 @@ class Context
 
         // class register wrapper
     private:
+        /** Helper class to register class members and constructors.
+         * See \fun, \constructor.
+         * Actual registration occurs at object destruction.
+         */
         template <class T>
         class class_registrar
         {
@@ -843,6 +950,8 @@ class Context
 
             class_registrar(const class_registrar&) = delete;
 
+            /** Add functional object f
+             */
             template <typename F>
             class_registrar& fun(const char * name, F&& f)
             {
@@ -850,6 +959,12 @@ class Context
                 return *this;
             }
 
+            /** Add class member function or class member variable F
+             * Example:
+             * struct T { int var; int func(); }
+             * auto& module = context.addModule("module");
+             * module.class_<T>("T").fun<&T::var>("var").fun<&T::func>("func");
+             */
             template <auto F>
             class_registrar& fun(const char * name)
             {
@@ -857,6 +972,10 @@ class Context
                 return *this;
             }
 
+            /** Add class constructor
+             * @tparam Args contructor arguments
+             * @param name constructor name (if not specified class name will be used)
+             */
             template <typename... Args>
             class_registrar& constructor(const char * name = nullptr)
             {
@@ -887,10 +1006,13 @@ class Context
         };
 
     public:
+        /** Add class to module.
+         * See \class_registrar.
+         */
         template <class T>
         class_registrar<T> class_(const char * name)
         {
-            return class_registrar<T>{name, *this, *reinterpret_cast<qjs::Context *>(JS_GetContextOpaque(ctx))};
+            return class_registrar<T>{name, *this, qjs::Context::get(ctx)};
         }
 
     };
@@ -928,6 +1050,7 @@ class Context
         JS_FreeContext(ctx);
     }
 
+    /** Create module and return a reference to it */
     Module& addModule(const char * name)
     {
         modules.emplace_back(ctx, name);
@@ -944,6 +1067,12 @@ class Context
         return Value{ctx, JS_NewObject(ctx)};
     }
 
+    /** Register class \T for conversions to/from std::shared_ptr<T> to work.
+     * Wherever possible module.class_<T>("T")... should be used instead.
+     * @tparam T class type
+     * @param name class name in JS engine
+     * @param proto JS class prototype or JS_UNDEFINED
+     */
     template <class T>
     void registerClass(const char * name, JSValue proto)
     {
@@ -968,9 +1097,19 @@ class Context
         return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, eval_flags);
     }
 
+    /** Get qjs::Context from JSContext opaque pointer */
+    static Context& get(JSContext * ctx)
+    {
+        void * ptr = JS_GetContextOpaque(ctx);
+        assert(ptr);
+        return *reinterpret_cast<Context *>(ptr);
+    }
 };
 
-
+/** Convert to/from std::function
+ * @tparam R return type
+ * @tparam Args argument types
+ */
 template <typename R, typename... Args>
 struct js_traits<std::function<R(Args...)>>
 {
@@ -986,6 +1125,9 @@ struct js_traits<std::function<R(Args...)>>
         };
     }
 
+    /** Convert from function object \functor to JSValue.
+     * Uses detail::function for type-erasure.
+     */
     template <typename Functor>
     static JSValue wrap(JSContext * ctx, Functor&& functor)
     {
@@ -1004,7 +1146,7 @@ struct js_traits<std::function<R(Args...)>>
     }
 };
 
-// std::vector <-> Array
+/** Convert from std::vector<T> to Array and vice-versa. If Array holds objects that are non-convertible to \T throws qjs::exception */
 template <class T>
 struct js_traits<std::vector<T>>
 {

From ba9866a4a6efdd8a9b7135fb8834fd721a2d48cc Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 29 Aug 2019 11:57:49 +0000
Subject: [PATCH 020/185] add github CI

---
 .github/workflows/cxx.yml | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .github/workflows/cxx.yml

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
new file mode 100644
index 0000000000..2cdb87f9d6
--- /dev/null
+++ b/.github/workflows/cxx.yml
@@ -0,0 +1,26 @@
+name: CMake C/C++ CI
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        compiler: [native, second] # second - clang for linux, mingw gcc for win
+        include:
+          - os: ubuntu-latest
+            compiler: second
+            cmake_opts: -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+          - os: windows-latest
+            compiler: second
+            cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
+    steps:
+    - uses: actions/checkout@v1
+    - name: configure
+      run: cmake . -Wdev ${{ matrix.cmake_opts }}
+    - name: build
+      run: cmake --build . # --verbose
+    - name: test
+      run: ctest --extra-verbose

From 11326d67549e2d0f3a4cbea1d95fb00ad5bc659b Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 29 Aug 2019 12:05:05 +0000
Subject: [PATCH 021/185] lower minimum cmake version

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2808e3e46e..3951eef502 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.8)
 project(quickjspp)
 
 set(CMAKE_CXX_STANDARD 17)

From 262cca2592f41c7dfd8bdbe021001447277fa1aa Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 31 Aug 2019 11:12:35 +0000
Subject: [PATCH 022/185] exclude MSVS CI

---
 .github/workflows/cxx.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index 2cdb87f9d6..aca66f8a39 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -16,6 +16,9 @@ jobs:
           - os: windows-latest
             compiler: second
             cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
+        exclude: # msvs
+          - os: windows-latest
+            compiler: native
     steps:
     - uses: actions/checkout@v1
     - name: configure

From 6356b5902cd1382c8ba214b28a751f540bf1ed26 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 12 Sep 2019 09:06:59 +0000
Subject: [PATCH 023/185] update quickjs to 2019-09-01

---
 quickjs/VERSION          |    2 +-
 quickjs/cutils.c         |    1 -
 quickjs/quickjs-atom.h   |    2 +
 quickjs/quickjs-libc.c   |  481 +++++++++++++-
 quickjs/quickjs-libc.h   |    2 +
 quickjs/quickjs-opcode.h |    5 +-
 quickjs/quickjs.c        | 1296 +++++++++++++++++++++++++-------------
 quickjs/quickjs.h        |   34 +-
 8 files changed, 1346 insertions(+), 477 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index c88c1f0c71..bbe29cb5e2 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-08-10
+2019-09-01
diff --git a/quickjs/cutils.c b/quickjs/cutils.c
index 869b79c4e1..64a32d362f 100644
--- a/quickjs/cutils.c
+++ b/quickjs/cutils.c
@@ -572,7 +572,6 @@ void rqsort(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
              */
             span = plt - ptr;
             span2 = pi - plt;
-            plt = pi - span;
             lt = i - lt;
             if (span > span2)
                 span = span2;
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 6bbc3b2982..233294c6cd 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -151,6 +151,7 @@ DEF(brand, "<brand>")
 DEF(hash_constructor, "#constructor")
 DEF(as, "as")
 DEF(from, "from")
+DEF(meta, "meta")
 DEF(_default_, "*default*")
 DEF(_star_, "*")
 DEF(Module, "Module")
@@ -165,6 +166,7 @@ DEF(exec, "exec")
 DEF(groups, "groups")
 DEF(status, "status")
 DEF(reason, "reason")
+DEF(globalThis, "globalThis")
 #ifdef CONFIG_BIGNUM
 DEF(bigint, "bigint")
 DEF(bigfloat, "bigfloat")
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index a4a4c1c8d4..37da67b97b 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -34,6 +34,9 @@
 #include <sys/time.h>
 #include <time.h>
 #include <signal.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <dirent.h>
 #if defined(_WIN32)
 #include <windows.h>
 #include <conio.h>
@@ -300,18 +303,40 @@ uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
     FILE *f;
     uint8_t *buf;
     size_t buf_len;
-
+    long lret;
+    
     f = fopen(filename, "rb");
     if (!f)
         return NULL;
-    fseek(f, 0, SEEK_END);
-    buf_len = ftell(f);
-    fseek(f, 0, SEEK_SET);
+    if (fseek(f, 0, SEEK_END) < 0)
+        goto fail;
+    lret = ftell(f);
+    if (lret < 0)
+        goto fail;
+    /* XXX: on Linux, ftell() return LONG_MAX for directories */
+    if (lret == LONG_MAX) {
+        errno = EISDIR;
+        goto fail;
+    }
+    buf_len = lret;
+    if (fseek(f, 0, SEEK_SET) < 0)
+        goto fail;
     if (ctx)
         buf = js_malloc(ctx, buf_len + 1);
     else
         buf = malloc(buf_len + 1);
-    fread(buf, 1, buf_len, f);
+    if (!buf)
+        goto fail;
+    if (fread(buf, 1, buf_len, f) != buf_len) {
+        errno = EIO;
+        if (ctx)
+            js_free(ctx, buf);
+        else
+            free(buf);
+    fail:
+        fclose(f);
+        return NULL;
+    }
     buf[buf_len] = '\0';
     fclose(f);
     *pbuf_len = buf_len;
@@ -405,6 +430,56 @@ static JSModuleDef *js_module_loader_so(JSContext *ctx,
 }
 #endif /* !_WIN32 */
 
+int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
+                              JS_BOOL use_realpath, JS_BOOL is_main)
+{
+    JSModuleDef *m;
+    char buf[PATH_MAX + 16], *res;
+    JSValue meta_obj;
+    JSAtom module_name_atom;
+    const char *module_name;
+    
+    assert(JS_VALUE_GET_TAG(func_val) == JS_TAG_MODULE);
+    m = JS_VALUE_GET_PTR(func_val);
+
+    module_name_atom = JS_GetModuleName(ctx, m);
+    module_name = JS_AtomToCString(ctx, module_name_atom);
+    JS_FreeAtom(ctx, module_name_atom);
+    if (!module_name)
+        return -1;
+    if (!strchr(module_name, ':')) {
+        strcpy(buf, "file://");
+        /* realpath() cannot be used with modules compiled with qjsc
+           because the corresponding module source code is not
+           necessarily present */
+        if (use_realpath) {
+            res = realpath(module_name, buf + strlen(buf));
+            if (!res) {
+                JS_ThrowTypeError(ctx, "realpath failure");
+                JS_FreeCString(ctx, module_name);
+                return -1;
+            }
+        } else {
+            pstrcat(buf, sizeof(buf), module_name);
+        }
+    } else {
+        pstrcpy(buf, sizeof(buf), module_name);
+    }
+    JS_FreeCString(ctx, module_name);
+    
+    meta_obj = JS_GetImportMeta(ctx, m);
+    if (JS_IsException(meta_obj))
+        return -1;
+    JS_DefinePropertyValueStr(ctx, meta_obj, "url",
+                              JS_NewString(ctx, buf),
+                              JS_PROP_C_W_E);
+    JS_DefinePropertyValueStr(ctx, meta_obj, "main",
+                              JS_NewBool(ctx, is_main),
+                              JS_PROP_C_W_E);
+    JS_FreeValue(ctx, meta_obj);
+    return 0;
+}
+
 JSModuleDef *js_module_loader(JSContext *ctx,
                               const char *module_name, void *opaque)
 {
@@ -430,6 +505,8 @@ JSModuleDef *js_module_loader(JSContext *ctx,
         js_free(ctx, buf);
         if (JS_IsException(func_val))
             return NULL;
+        /* XXX: could propagate the exception */
+        js_module_set_import_meta(ctx, func_val, TRUE, FALSE);
         /* the module is already referenced, so we must free it */
         m = JS_VALUE_GET_PTR(func_val);
         JS_FreeValue(ctx, func_val);
@@ -506,14 +583,19 @@ static JSClassID js_std_file_class_id;
 typedef struct {
     FILE *f;
     BOOL close_in_finalizer;
+    BOOL is_popen;
 } JSSTDFile;
 
 static void js_std_file_finalizer(JSRuntime *rt, JSValue val)
 {
     JSSTDFile *s = JS_GetOpaque(val, js_std_file_class_id);
     if (s) {
-        if (s->f && s->close_in_finalizer)
-            fclose(s->f);
+        if (s->f && s->close_in_finalizer) {
+            if (s->is_popen)
+                pclose(s->f);
+            else
+                fclose(s->f);
+        }
         js_free_rt(rt, s);
     }
 }
@@ -559,7 +641,9 @@ static JSValue js_std_throw_errno(JSContext *ctx, int err)
     return JS_Throw(ctx, obj);
 }
 
-static JSValue js_new_std_file(JSContext *ctx, FILE *f, BOOL close_in_finalizer)
+static JSValue js_new_std_file(JSContext *ctx, FILE *f,
+                               BOOL close_in_finalizer,
+                               BOOL is_popen)
 {
     JSSTDFile *s;
     JSValue obj;
@@ -572,6 +656,7 @@ static JSValue js_new_std_file(JSContext *ctx, FILE *f, BOOL close_in_finalizer)
         return JS_EXCEPTION;
     }
     s->close_in_finalizer = close_in_finalizer;
+    s->is_popen = is_popen;
     s->f = f;
     JS_SetOpaque(obj, s);
     return obj;
@@ -599,7 +684,36 @@ static JSValue js_std_open(JSContext *ctx, JSValueConst this_val,
     JS_FreeCString(ctx, mode);
     if (!f)
         return js_std_throw_errno(ctx, errno);
-    return js_new_std_file(ctx, f, TRUE);
+    return js_new_std_file(ctx, f, TRUE, FALSE);
+ fail:
+    JS_FreeCString(ctx, filename);
+    JS_FreeCString(ctx, mode);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv)
+{
+    const char *filename, *mode = NULL;
+    FILE *f;
+
+    filename = JS_ToCString(ctx, argv[0]);
+    if (!filename)
+        goto fail;
+    mode = JS_ToCString(ctx, argv[1]);
+    if (!mode)
+        goto fail;
+    if (mode[strspn(mode, "rw")] != '\0') {
+        js_std_throw_errno(ctx, EINVAL);
+        goto fail;
+    }
+
+    f = popen(filename, mode);
+    JS_FreeCString(ctx, filename);
+    JS_FreeCString(ctx, mode);
+    if (!f)
+        return js_std_throw_errno(ctx, errno);
+    return js_new_std_file(ctx, f, TRUE, TRUE);
  fail:
     JS_FreeCString(ctx, filename);
     JS_FreeCString(ctx, mode);
@@ -613,7 +727,7 @@ static JSValue js_std_tmpfile(JSContext *ctx, JSValueConst this_val,
     f = tmpfile();
     if (!f)
         return js_std_throw_errno(ctx, errno);
-    return js_new_std_file(ctx, f, TRUE);
+    return js_new_std_file(ctx, f, TRUE, FALSE);
 }
 
 static JSValue js_std_sprintf(JSContext *ctx, JSValueConst this_val,
@@ -673,7 +787,11 @@ static JSValue js_std_file_close(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (!s->f)
         return js_std_throw_errno(ctx, EBADF);
-    fclose(s->f);
+    /* XXX: could return exit code */
+    if (s->is_popen)
+        pclose(s->f);
+    else
+        fclose(s->f);
     s->f = NULL;
     return JS_UNDEFINED;
 }
@@ -1084,6 +1202,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
 
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
+    JS_CFUNC_DEF("popen", 2, js_std_popen ),
     JS_CFUNC_DEF("tmpfile", 0, js_std_tmpfile ),
     JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 0 ),
     JS_CFUNC_DEF("printf", 1, js_std_printf ),
@@ -1147,9 +1266,9 @@ static int js_std_init(JSContext *ctx, JSModuleDef *m)
 
     JS_SetModuleExportList(ctx, m, js_std_funcs,
                            countof(js_std_funcs));
-    JS_SetModuleExport(ctx, m, "in", js_new_std_file(ctx, stdin, FALSE));
-    JS_SetModuleExport(ctx, m, "out", js_new_std_file(ctx, stdout, FALSE));
-    JS_SetModuleExport(ctx, m, "err", js_new_std_file(ctx, stderr, FALSE));
+    JS_SetModuleExport(ctx, m, "in", js_new_std_file(ctx, stdin, FALSE, FALSE));
+    JS_SetModuleExport(ctx, m, "out", js_new_std_file(ctx, stdout, FALSE, FALSE));
+    JS_SetModuleExport(ctx, m, "err", js_new_std_file(ctx, stderr, FALSE, FALSE));
     
     obj = JS_NewCFunction2(ctx, js_std_error_constructor,
                            "Error", 1, JS_CFUNC_constructor, 0);
@@ -1157,8 +1276,6 @@ static int js_std_init(JSContext *ctx, JSModuleDef *m)
                                countof(js_std_error_funcs));
     JS_SetModuleExport(ctx, m, "Error", obj);
 
-    /* global object */
-    JS_SetModuleExport(ctx, m, "global", JS_GetGlobalObject(ctx));
     return 0;
 }
 
@@ -1172,7 +1289,6 @@ JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name)
     JS_AddModuleExport(ctx, m, "in");
     JS_AddModuleExport(ctx, m, "out");
     JS_AddModuleExport(ctx, m, "err");
-    JS_AddModuleExport(ctx, m, "global");
     JS_AddModuleExport(ctx, m, "Error");
     return m;
 }
@@ -1815,6 +1931,285 @@ static int js_os_poll(JSContext *ctx)
 }
 #endif /* !_WIN32 */
 
+static JSValue make_obj_error(JSContext *ctx,
+                              JSValue obj,
+                              int err)
+{
+    JSValue arr;
+    if (JS_IsException(obj))
+        return obj;
+    arr = JS_NewArray(ctx);
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    JS_DefinePropertyValueUint32(ctx, arr, 0, obj,
+                                 JS_PROP_C_W_E);
+    JS_DefinePropertyValueUint32(ctx, arr, 1, JS_NewInt32(ctx, err),
+                                 JS_PROP_C_W_E);
+    return arr;
+}
+
+static JSValue make_string_error(JSContext *ctx,
+                                 const char *buf,
+                                 int err)
+{
+    return make_obj_error(ctx, JS_NewString(ctx, buf), err);
+}
+
+/* return [cwd, errorcode] */
+static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv)
+{
+    char buf[PATH_MAX];
+    int err;
+    
+    if (!getcwd(buf, sizeof(buf))) {
+        buf[0] = '\0';
+        err = -errno;
+    } else {
+        err = 0;
+    }
+    return make_string_error(ctx, buf, err);
+}
+
+/* return [path, errorcode] */
+static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    const char *path;
+    char buf[PATH_MAX], *res;
+    int err;
+
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    res = realpath(path, buf);
+    JS_FreeCString(ctx, path);
+    if (!res) {
+        buf[0] = '\0';
+        err = -errno;
+    } else {
+        err = 0;
+    }
+    return make_string_error(ctx, buf, err);
+}
+
+static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
+{
+    int mode, ret;
+    const char *path;
+    
+    if (argc >= 2) {
+        if (JS_ToInt32(ctx, &mode, argv[1]))
+            return JS_EXCEPTION;
+    } else {
+        mode = 0777;
+    }
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    ret = mkdir(path, mode);
+    JS_FreeCString(ctx, path);
+    return js_os_return(ctx, ret);
+}
+
+static int64_t timespec_to_ms(const struct timespec *tv)
+{
+    return (int64_t)tv->tv_sec * 1000 + (tv->tv_nsec / 1000000);
+}
+
+/* return [obj, errcode] */
+static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv, int is_lstat)
+{
+    const char *path;
+    int err, res;
+    struct stat st;
+    JSValue obj;
+
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    if (is_lstat)
+        res = lstat(path, &st);
+    else
+        res = stat(path, &st);
+    JS_FreeCString(ctx, path);
+    if (res < 0) {
+        err = -errno;
+        obj = JS_NULL;
+    } else {
+        err = 0;
+        obj = JS_NewObject(ctx);
+        if (JS_IsException(obj))
+            return JS_EXCEPTION;
+        JS_DefinePropertyValueStr(ctx, obj, "dev",
+                                  JS_NewInt64(ctx, st.st_dev),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "ino",
+                                  JS_NewInt64(ctx, st.st_ino),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "mode",
+                                  JS_NewInt32(ctx, st.st_mode),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "nlink",
+                                  JS_NewInt64(ctx, st.st_nlink),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "uid",
+                                  JS_NewInt64(ctx, st.st_uid),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "gid",
+                                  JS_NewInt64(ctx, st.st_gid),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "rdev",
+                                  JS_NewInt64(ctx, st.st_rdev),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "size",
+                                  JS_NewInt64(ctx, st.st_size),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "blocks",
+                                  JS_NewInt64(ctx, st.st_blocks),
+                                  JS_PROP_C_W_E);
+#if defined(__APPLE__)
+        JS_DefinePropertyValueStr(ctx, obj, "atime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_atimespec)),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "mtime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_mtimespec)),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "ctime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_ctimespec)),
+                                  JS_PROP_C_W_E);
+#else
+        JS_DefinePropertyValueStr(ctx, obj, "atime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_atim)),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "mtime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_mtim)),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "ctime",
+                                  JS_NewInt64(ctx, timespec_to_ms(&st.st_ctim)),
+                                  JS_PROP_C_W_E);
+#endif
+    }
+    return make_obj_error(ctx, obj, err);
+}
+
+static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    const char *target, *linkpath;
+    int err;
+    
+    target = JS_ToCString(ctx, argv[0]);
+    if (!target)
+        return JS_EXCEPTION;
+    linkpath = JS_ToCString(ctx, argv[1]);
+    if (!linkpath) {
+        JS_FreeCString(ctx, target);
+        return JS_EXCEPTION;
+    }
+    err = symlink(target, linkpath);
+    JS_FreeCString(ctx, target);
+    JS_FreeCString(ctx, linkpath);
+    return js_os_return(ctx, err);
+}
+
+/* return [path, errorcode] */
+static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    const char *path;
+    char buf[PATH_MAX];
+    int err;
+    ssize_t res;
+    
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    res = readlink(path, buf, sizeof(buf) - 1);
+    JS_FreeCString(ctx, path);
+    if (res < 0) {
+        buf[0] = '\0';
+        err = -errno;
+    } else {
+        buf[res] = '\0';
+        err = 0;
+    }
+    return make_string_error(ctx, buf, err);
+}
+
+/* return [array, errorcode] */
+static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    const char *path;
+    DIR *f;
+    struct dirent *d;
+    JSValue obj;
+    int err;
+    uint32_t len;
+    
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    obj = JS_NewArray(ctx);
+    if (JS_IsException(obj)) {
+        JS_FreeCString(ctx, path);
+        return JS_EXCEPTION;
+    }
+    f = opendir(path);
+    JS_FreeCString(ctx, path);
+    err = 0;
+    if (!f) {
+        err = -errno;
+        goto done;
+    }
+    len = 0;
+    for(;;) {
+        errno = 0;
+        d = readdir(f);
+        if (!d) {
+            err = -errno;
+            break;
+        }
+        JS_DefinePropertyValueUint32(ctx, obj, len++,
+                                     JS_NewString(ctx, d->d_name),
+                                     JS_PROP_C_W_E);
+    }
+    closedir(f);
+ done:
+    return make_obj_error(ctx, obj, err);
+}
+
+static void ms_to_timeval(struct timeval *tv, uint64_t v)
+{
+    tv->tv_sec = v / 1000;
+    tv->tv_usec = (v % 1000) * 1000;
+}
+
+static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv)
+{
+    const char *path;
+    int64_t atime, mtime;
+    int ret;
+    struct timeval times[2];
+    
+    if (JS_ToInt64(ctx, &atime, argv[1]))
+        return JS_EXCEPTION;
+    if (JS_ToInt64(ctx, &mtime, argv[2]))
+        return JS_EXCEPTION;
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    ms_to_timeval(&times[0], atime);
+    ms_to_timeval(&times[1], mtime);
+    ret = utimes(path, times);
+    JS_FreeCString(ctx, path);
+    return js_os_return(ctx, ret);
+}
+
 #if defined(_WIN32)
 #define OS_PLATFORM "win32"
 #elif defined(__APPLE__)
@@ -1861,7 +2256,26 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_CFUNC_DEF("setTimeout", 2, js_os_setTimeout ),
     JS_CFUNC_DEF("clearTimeout", 1, js_os_clearTimeout ),
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
-    /* stat, readlink, opendir, closedir, ... */
+    JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
+    JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
+    JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
+    JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
+    JS_CFUNC_MAGIC_DEF("lstat", 1, js_os_stat, 1 ),
+    /* st_mode constants */
+    OS_FLAG(S_IFMT),
+    OS_FLAG(S_IFIFO),
+    OS_FLAG(S_IFCHR),
+    OS_FLAG(S_IFDIR),
+    OS_FLAG(S_IFBLK),
+    OS_FLAG(S_IFREG),
+    OS_FLAG(S_IFSOCK),
+    OS_FLAG(S_IFLNK),
+    OS_FLAG(S_ISGID),
+    OS_FLAG(S_ISUID),
+    JS_CFUNC_DEF("symlink", 2, js_os_symlink ),
+    JS_CFUNC_DEF("readlink", 1, js_os_readlink ),
+    JS_CFUNC_DEF("readdir", 1, js_os_readdir ),
+    JS_CFUNC_DEF("utimes", 3, js_os_utimes ),
 };
 
 static int js_os_init(JSContext *ctx, JSModuleDef *m)
@@ -2010,13 +2424,30 @@ void js_std_loop(JSContext *ctx)
 }
 
 void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
-                        int flags)
+                        int load_only)
 {
-    JSValue val;
-    val = JS_EvalBinary(ctx, buf, buf_len, flags);
-    if (JS_IsException(val)) {
-        js_std_dump_error(ctx);
-        exit(1);
+    JSValue obj, val;
+    obj = JS_ReadObject(ctx, buf, buf_len, JS_READ_OBJ_BYTECODE);
+    if (JS_IsException(obj))
+        goto exception;
+    if (load_only) {
+        if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
+            js_module_set_import_meta(ctx, obj, FALSE, FALSE);
+        }
+    } else {
+        if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
+            if (JS_ResolveModule(ctx, obj) < 0) {
+                JS_FreeValue(ctx, obj);
+                goto exception;
+            }
+            js_module_set_import_meta(ctx, obj, FALSE, TRUE);
+        }
+        val = JS_EvalFunction(ctx, obj);
+        if (JS_IsException(val)) {
+        exception:
+            js_std_dump_error(ctx);
+            exit(1);
+        }
+        JS_FreeValue(ctx, val);
     }
-    JS_FreeValue(ctx, val);
 }
diff --git a/quickjs/quickjs-libc.h b/quickjs/quickjs-libc.h
index 35ca4cffe7..ac7947e4fe 100644
--- a/quickjs/quickjs-libc.h
+++ b/quickjs/quickjs-libc.h
@@ -36,6 +36,8 @@ void js_std_loop(JSContext *ctx);
 void js_std_free_handlers(JSRuntime *rt);
 void js_std_dump_error(JSContext *ctx);
 uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename);
+int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
+                              JS_BOOL use_realpath, JS_BOOL is_main);
 JSModuleDef *js_module_loader(JSContext *ctx,
                               const char *module_name, void *opaque);
 void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 0ea029eecf..0981453666 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -155,7 +155,8 @@ DEF(         append, 1, 3, 2, none) /* append enumerated object, update length *
 DEF(copy_data_properties, 2, 3, 3, u8)
 DEF(  define_method, 6, 2, 1, atom_u8)
 DEF(define_method_computed, 2, 3, 1, u8) /* must come after define_method */
-DEF(   define_class, 6, 2, 2, atom_u8)
+DEF(   define_class, 6, 2, 2, atom_u8) /* parent ctor -> ctor proto */
+DEF(   define_class_computed, 6, 3, 3, atom_u8) /* field_name parent ctor -> field_name ctor proto (class with computed name) */
 
 DEF(        get_loc, 3, 0, 1, loc)
 DEF(        put_loc, 3, 1, 0, loc) /* must come after get_loc */
@@ -284,6 +285,8 @@ def(scope_get_private_field, 7, 1, 1, atom_u16) /* obj -> value, emitted in phas
 def(scope_get_private_field2, 7, 1, 2, atom_u16) /* obj -> obj value, emitted in phase 1, removed in phase 2 */
 def(scope_put_private_field, 7, 1, 1, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
 
+def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
+    
 def(       line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
 
 #if SHORT_OPCODES
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 7bb20cb4db..d5c1c8342d 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -434,6 +434,9 @@ typedef struct JSVarScope {
 typedef enum {
     /* XXX: add more variable kinds here instead of using bit fields */
     JS_VAR_NORMAL,
+    JS_VAR_FUNCTION_DECL, /* lexical var with function declaration */
+    JS_VAR_NEW_FUNCTION_DECL, /* lexical var with async/generator
+                                 function declaration */
     JS_VAR_CATCH,
     JS_VAR_PRIVATE_FIELD,
     JS_VAR_PRIVATE_METHOD,
@@ -447,13 +450,17 @@ typedef struct JSVarDef {
     int scope_level;   /* index into fd->scopes of this variable lexical scope */
     int scope_next;    /* index into fd->vars of the next variable in the
                         * same or enclosing lexical scope */
-    uint8_t is_function : 1; /* only used for debug */
     uint8_t is_func_var : 1; /* used for the function self reference */
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
     uint8_t is_captured : 1;
-    uint8_t var_kind : 3; /* see JSVarKindEnum */
-    int func_pool_idx : 24; /* only used during compilation */
+    uint8_t var_kind : 4; /* see JSVarKindEnum */
+    /* only used during compilation: function pool index for lexical
+       variables with var_kind =
+       JS_VAR_FUNCTION_DECL/JS_VAR_NEW_FUNCTION_DECL or scope level of
+       the definition of the 'var' variables (they have scope_level =
+       0) */
+    int func_pool_or_scope_idx : 24; /* only used during compilation */
 } JSVarDef;
 
 /* for the encoding of the pc2line table */
@@ -643,6 +650,7 @@ struct JSModuleDef {
        eval_exception */
     BOOL eval_has_exception : 8; 
     JSValue eval_exception;
+    JSValue meta_obj; /* for import.meta */
 };
 
 typedef struct JSJobEntry {
@@ -980,6 +988,7 @@ static JSValue JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                const char *input, size_t input_len,
                                const char *filename, int flags, int scope_idx);
 static void js_free_module_def(JSContext *ctx, JSModuleDef *m);
+static JSValue js_import_meta(JSContext *ctx);
 static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier);
 static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref);
 static JSValue js_new_promise_capability(JSContext *ctx,
@@ -4460,15 +4469,13 @@ JSValue JS_NewObject(JSContext *ctx)
 }
 
 static void js_function_set_properties(JSContext *ctx, JSValueConst func_obj,
-                                       JSValue name, int len)
+                                       JSAtom name, int len)
 {
     /* ES6 feature non compatible with ES5.1: length is configurable */
     JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_length, JS_NewInt32(ctx, len),
                            JS_PROP_CONFIGURABLE);
-    if (!JS_IsUndefined(name)) {
-        JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, name,
-                               JS_PROP_CONFIGURABLE);
-    }
+    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name,
+                           JS_AtomToString(ctx, name), JS_PROP_CONFIGURABLE);
 }
 
 static BOOL js_class_has_bytecode(JSClassID class_id)
@@ -4557,9 +4564,10 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
                                 int length, JSCFunctionEnum cproto, int magic,
                                 JSValueConst proto_val)
 {
-    JSValue func_obj, name_val;
+    JSValue func_obj;
     JSObject *p;
-
+    JSAtom name_atom;
+    
     func_obj = JS_NewObjectProtoClass(ctx, proto_val, JS_CLASS_C_FUNCTION);
     if (JS_IsException(func_obj))
         return func_obj;
@@ -4572,11 +4580,11 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
                          cproto == JS_CFUNC_constructor_magic ||
                          cproto == JS_CFUNC_constructor_or_func ||
                          cproto == JS_CFUNC_constructor_or_func_magic);
-    if (name)
-        name_val = JS_NewAtomString(ctx, name);
-    else
-        name_val = JS_UNDEFINED;
-    js_function_set_properties(ctx, func_obj, name_val, length);
+    if (!name)
+        name = "";
+    name_atom = JS_NewAtom(ctx, name);
+    js_function_set_properties(ctx, func_obj, name_atom, length);
+    JS_FreeAtom(ctx, name_atom);
     return func_obj;
 }
 
@@ -4669,7 +4677,8 @@ JSValue JS_NewCFunctionData(JSContext *ctx, JSCFunctionData *func,
     for(i = 0; i < data_len; i++)
         s->data[i] = JS_DupValue(ctx, data[i]);
     JS_SetOpaque(func_obj, s);
-    js_function_set_properties(ctx, func_obj, JS_UNDEFINED, length);
+    js_function_set_properties(ctx, func_obj,
+                               JS_ATOM_empty_string, length);
     return func_obj;
 }
 
@@ -8729,12 +8738,33 @@ static int JS_CreateDataPropertyUint32(JSContext *ctx, JSValueConst this_obj,
                                        JS_PROP_ENUMERABLE | JS_PROP_WRITABLE);
 }
 
+
+/* return TRUE if 'obj' has a non empty 'name' string */
+static BOOL js_object_has_name(JSContext *ctx, JSValueConst obj)
+{
+    JSProperty *pr;
+    JSShapeProperty *prs;
+    JSValueConst val;
+    JSString *p;
+    
+    prs = find_own_property(&pr, JS_VALUE_GET_OBJ(obj), JS_ATOM_name);
+    if (!prs)
+        return FALSE;
+    if ((prs->flags & JS_PROP_TMASK) != JS_PROP_NORMAL)
+        return TRUE;
+    val = pr->u.value;
+    if (JS_VALUE_GET_TAG(val) != JS_TAG_STRING)
+        return TRUE;
+    p = JS_VALUE_GET_STRING(val);
+    return (p->len != 0);
+}
+
 static int JS_DefineObjectName(JSContext *ctx, JSValueConst obj,
                                JSAtom name, int flags)
 {
     if (name != JS_ATOM_NULL
     &&  JS_IsObject(obj)
-    &&  !find_own_property1(JS_VALUE_GET_OBJ(obj), JS_ATOM_name)
+    &&  !js_object_has_name(ctx, obj)
     &&  JS_DefinePropertyValue(ctx, obj, JS_ATOM_name, JS_AtomToString(ctx, name), flags) < 0) {
         return -1;
     }
@@ -8745,7 +8775,7 @@ static int JS_DefineObjectNameComputed(JSContext *ctx, JSValueConst obj,
                                        JSValueConst str, int flags)
 {
     if (JS_IsObject(obj) &&
-        !find_own_property1(JS_VALUE_GET_OBJ(obj), JS_ATOM_name)) {
+        !js_object_has_name(ctx, obj)) {
         JSAtom prop;
         JSValue name_str;
         prop = js_value_to_atom(ctx, str);
@@ -12210,11 +12240,6 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
             bf_delete(b);
         JS_FreeValue(ctx, op1);
         JS_FreeValue(ctx, op2);
-        if (unlikely(ret)) {
-            bf_delete(r);
-            throw_bf_exception(ctx, ret);
-            goto exception;
-        }
         sp[-2] = JS_NewBigFloat(ctx, r);
     }
     return 0;
@@ -14354,7 +14379,7 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
                           JSStackFrame *sf)
 {
     JSFunctionBytecode *b;
-    JSValue name_val, func_obj;
+    JSValue func_obj;
     JSAtom name_atom;
     static const uint16_t func_kind_to_class_id[] = {
         [JS_FUNC_NORMAL] = JS_CLASS_BYTECODE_FUNCTION,
@@ -14374,11 +14399,10 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
         /* bfunc has been freed */
         goto fail;
     }
-    name_val = JS_UNDEFINED;
     name_atom = b->func_name;
-    if (name_atom != JS_ATOM_NULL)
-        name_val = JS_AtomToString(ctx, name_atom);
-    js_function_set_properties(ctx, func_obj, name_val,
+    if (name_atom == JS_ATOM_NULL)
+        name_atom = JS_ATOM_empty_string;
+    js_function_set_properties(ctx, func_obj, name_atom,
                                b->defined_arg_count);
 
     if (b->func_kind & JS_FUNC_GENERATOR) {
@@ -14416,7 +14440,7 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
 static int js_op_define_class(JSContext *ctx, JSValue *sp,
                               JSAtom class_name, int class_flags,
                               JSVarRef **cur_var_refs,
-                              JSStackFrame *sf)
+                              JSStackFrame *sf, BOOL is_computed_name)
 {
     JSValue bfunc, parent_class, proto = JS_UNDEFINED;
     JSValue ctor = JS_UNDEFINED, parent_proto = JS_UNDEFINED;
@@ -14468,6 +14492,15 @@ static int js_op_define_class(JSContext *ctx, JSValue *sp,
                            JS_NewInt32(ctx, b->defined_arg_count),
                            JS_PROP_CONFIGURABLE);
 
+    if (is_computed_name) {
+        if (JS_DefineObjectNameComputed(ctx, ctor, sp[-3],
+                                        JS_PROP_CONFIGURABLE) < 0)
+            goto fail;
+    } else {
+        if (JS_DefineObjectName(ctx, ctor, class_name, JS_PROP_CONFIGURABLE) < 0)
+            goto fail;
+    }
+
     /* the constructor property must be first. It can be overriden by
        computed property names */
     if (JS_DefinePropertyValue(ctx, proto, JS_ATOM_constructor,
@@ -14482,11 +14515,6 @@ static int js_op_define_class(JSContext *ctx, JSValue *sp,
     set_cycle_flag(ctx, ctor);
     set_cycle_flag(ctx, proto);
 
-    if (class_name != JS_ATOM_NULL) {
-        if (JS_DefineObjectName(ctx, ctor, class_name, JS_PROP_CONFIGURABLE) < 0)
-            goto fail;
-    }
-    
     JS_FreeValue(ctx, parent_proto);
     JS_FreeValue(ctx, parent_class);
 
@@ -14746,6 +14774,7 @@ typedef enum {
     OP_SPECIAL_OBJECT_NEW_TARGET,
     OP_SPECIAL_OBJECT_HOME_OBJECT,
     OP_SPECIAL_OBJECT_VAR_OBJECT,
+    OP_SPECIAL_OBJECT_IMPORT_META,
 } OPSpecialObjectEnum;
 
 #define FUNC_RET_AWAIT      0
@@ -15015,6 +15044,11 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     if (unlikely(JS_IsException(sp[-1])))
                         goto exception;
                     break;
+                case OP_SPECIAL_OBJECT_IMPORT_META:
+                    *sp++ = js_import_meta(ctx);
+                    if (unlikely(JS_IsException(sp[-1])))
+                        goto exception;
+                    break;
                 default:
                     abort();
                 }
@@ -16278,6 +16312,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             BREAK;
 
         CASE(OP_define_class):
+        CASE(OP_define_class_computed):
             {
                 int class_flags;
                 JSAtom atom;
@@ -16286,7 +16321,8 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 class_flags = pc[4];
                 pc += 5;
                 if (js_op_define_class(ctx, sp, atom, class_flags,
-                                       var_refs, sf) < 0)
+                                       var_refs, sf,
+                                       (opcode == OP_define_class_computed)) < 0)
                     goto exception;
             }
             BREAK;
@@ -18461,7 +18497,6 @@ typedef struct JSHoistedDef {
     uint8_t force_init : 1; /* initialize to undefined */
     uint8_t is_lexical : 1; /* global let/const definition */
     uint8_t is_const   : 1; /* const definition */
-    uint8_t is_for_of  : 1; /* variable defined in for-of */
     int var_idx;   /* function object index if cpool_idx >= 0 */
     int scope_level;    /* scope of definition */
     JSAtom var_name;  /* variable name if cpool_idx < 0 */
@@ -19025,32 +19060,6 @@ static inline BOOL token_is_pseudo_keyword(JSParseState *s, JSAtom atom) {
         !s->token.u.ident.has_escape;
 }
 
-#if 0
-/* return TRUE if a regexp literal is allowed after this token */
-static BOOL is_regexp_allowed(JSParseState *s)
-{
-    switch (s->token.val) {
-    case TOK_NUMBER:
-    case TOK_STRING:
-    case TOK_REGEXP:
-    case TOK_DEC:
-    case TOK_INC:
-    case TOK_NULL:
-    case TOK_FALSE:
-    case TOK_TRUE:
-    case TOK_THIS:
-    case ')':
-    case ']':
-    case '}':
-        return FALSE;
-    case TOK_IDENT:
-        return token_is_pseudo_keyword(s, JS_ATOM_of) || token_is_pseudo_keyword(s, JS_ATOM_yield);
-    default:
-        return TRUE;
-    }
-}
-#endif
-
 static __exception int js_parse_regexp(JSParseState *s)
 {
     const uint8_t *p;
@@ -19259,16 +19268,7 @@ static __exception int next_token(JSParseState *s)
                 }
             }
             goto redo;
-        }
-#if 0
-        else if (is_regexp_allowed(s)) {
-            s->buf_ptr = p;
-            if (js_parse_regexp(s))
-                goto fail;
-            p = s->buf_ptr;
-        }
-#endif
-        else if (p[1] == '=') {
+        } else if (p[1] == '=') {
             p += 2;
             s->token.val = TOK_DIV_ASSIGN;
         } else {
@@ -19761,15 +19761,17 @@ static __exception int next_token(JSParseState *s)
     return -1;
 }
 
-/* only used for ':' and '=>', 'let' or 'function' look-ahead */
+/* only used for ':' and '=>', 'let' or 'function' look-ahead. *pp is
+   only set if TOK_IMPORT is returned */
 /* XXX: handle all unicode cases */
-static int peek_token(JSParseState *s, BOOL no_line_terminator)
+static int simple_next_token(const uint8_t **pp, BOOL no_line_terminator)
 {
     const uint8_t *p;
     uint32_t c;
-
+    
     /* skip spaces and comments */
-    for (p = s->buf_ptr;;) {
+    p = *pp;
+    for (;;) {
         switch(c = *p++) {
         case '\r':
         case '\n':
@@ -19807,16 +19809,24 @@ static int peek_token(JSParseState *s, BOOL no_line_terminator)
             break;
         default:
             if (lre_js_is_ident_first(c)) {
-                if (c == 'i' && *p == 'n' && !lre_js_is_ident_next(p[1]))
-                    return TOK_IN;
-                if (c == 'o' && *p == 'f' && !lre_js_is_ident_next(p[1]))
+                if (c == 'i') {
+                    if (p[0] == 'n' && !lre_js_is_ident_next(p[1])) {
+                        return TOK_IN;
+                    }
+                    if (p[0] == 'm' && p[1] == 'p' && p[2] == 'o' &&
+                        p[3] == 'r' && p[4] == 't' &&
+                        !lre_js_is_ident_next(p[5])) {
+                        *pp = p + 5;
+                        return TOK_IMPORT;
+                    }
+                } else if (c == 'o' && *p == 'f' && !lre_js_is_ident_next(p[1])) {
                     return TOK_OF;
-                else if (c == 'f' && p[0] == 'u' && p[1] == 'n' &&
+                } else if (c == 'f' && p[0] == 'u' && p[1] == 'n' &&
                          p[2] == 'c' && p[3] == 't' && p[4] == 'i' &&
-                         p[5] == 'o' && p[6] == 'n' && !lre_js_is_ident_next(p[7]))
+                         p[5] == 'o' && p[6] == 'n' && !lre_js_is_ident_next(p[7])) {
                     return TOK_FUNCTION;
-                else
-                    return TOK_IDENT;
+                }
+                return TOK_IDENT;
             }
             break;
         }
@@ -19824,6 +19834,28 @@ static int peek_token(JSParseState *s, BOOL no_line_terminator)
     }
 }
 
+static int peek_token(JSParseState *s, BOOL no_line_terminator)
+{
+    const uint8_t *p = s->buf_ptr;
+    return simple_next_token(&p, no_line_terminator);
+}
+
+/* return true if 'input' contains the source of a module
+   (heuristic). 'input' must be a zero terminated.
+
+   Heuristic: skip comments and expect 'import' keyword not followed
+   by '(' or '.'
+*/
+BOOL JS_DetectModule(const char *input, size_t input_len)
+{
+    const uint8_t *p = (const uint8_t *)input;
+    int tok;
+    if (simple_next_token(&p, FALSE) != TOK_IMPORT)
+        return FALSE;
+    tok = simple_next_token(&p, FALSE);
+    return (tok != '.' && tok != '(');
+}
+
 static inline int get_prev_opcode(JSFunctionDef *fd) {
     if (fd->last_opcode_pos < 0)
         return OP_invalid;
@@ -20030,6 +20062,36 @@ static int find_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     return find_arg(ctx, fd, name);
 }
 
+/* return true if scope == parent_scope or if scope is a child of
+   parent_scope */
+static BOOL is_child_scope(JSContext *ctx, JSFunctionDef *fd,
+                           int scope, int parent_scope)
+{
+    while (scope >= 0) {
+        if (scope == parent_scope)
+            return TRUE;
+        scope = fd->scopes[scope].parent;
+    }
+    return FALSE;
+}
+
+/* find a 'var' declaration in the same scope or a child scope */
+static int find_var_in_child_scope(JSContext *ctx, JSFunctionDef *fd,
+                                   JSAtom name, int scope_level)
+{
+    int i;
+    for(i = 0; i < fd->var_count; i++) {
+        JSVarDef *vd = &fd->vars[i];
+        if (vd->var_name == name && vd->scope_level == 0) {
+            if (is_child_scope(ctx, fd, vd->func_pool_or_scope_idx,
+                               scope_level))
+                return i;
+        }
+    }
+    return -1;
+}
+
+
 static JSHoistedDef *find_hoisted_def(JSFunctionDef *fd, JSAtom name)
 {
     int i;
@@ -20165,6 +20227,21 @@ static int add_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     return fd->var_count - 1;
 }
 
+static int add_scope_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name,
+                         JSVarKindEnum var_kind)
+{
+    int idx = add_var(ctx, fd, name);
+    if (idx >= 0) {
+        JSVarDef *vd = &fd->vars[idx];
+        vd->var_kind = var_kind;
+        vd->scope_level = fd->scope_level;
+        vd->scope_next = fd->scope_first;
+        fd->scopes[fd->scope_level].first = idx;
+        fd->scope_first = idx;
+    }
+    return idx;
+}
+
 static int add_func_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
 {
     int idx = fd->func_var_idx;
@@ -20239,7 +20316,6 @@ static JSHoistedDef *add_hoisted_def(JSContext *ctx,
     hf->force_init = 0;
     hf->is_lexical = is_lexical;
     hf->is_const = FALSE;
-    hf->is_for_of = FALSE;
     hf->var_idx = var_idx;
     hf->scope_level = s->scope_level;
     hf->var_name = JS_ATOM_NULL;
@@ -20249,102 +20325,113 @@ static JSHoistedDef *add_hoisted_def(JSContext *ctx,
     return hf;
 }
 
-static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name, int tok)
+typedef enum {
+    JS_VAR_DEF_WITH,
+    JS_VAR_DEF_LET,
+    JS_VAR_DEF_CONST,
+    JS_VAR_DEF_FUNCTION_DECL, /* function declaration */
+    JS_VAR_DEF_NEW_FUNCTION_DECL, /* async/generator function declaration */
+    JS_VAR_DEF_CATCH,
+    JS_VAR_DEF_VAR,
+} JSVarDefEnum;
+
+static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
+                      JSVarDefEnum var_def_type)
 {
     JSContext *ctx = s->ctx;
     JSVarDef *vd;
     int idx;
 
-    switch (tok) {
-    case TOK_WITH:
-        idx = add_var(ctx, fd, name);
-        if (idx >= 0) {
-            vd = &fd->vars[idx];
-            vd->scope_level = fd->scope_level;
-            vd->scope_next = fd->scope_first;
-            fd->scopes[fd->scope_level].first = idx;
-            fd->scope_first = idx;
-        }
+    switch (var_def_type) {
+    case JS_VAR_DEF_WITH:
+        idx = add_scope_var(ctx, fd, name, JS_VAR_NORMAL);
         break;
 
-    case TOK_LET:
-    case TOK_CONST:
-    case TOK_FUNCTION:
+    case JS_VAR_DEF_LET:
+    case JS_VAR_DEF_CONST:
+    case JS_VAR_DEF_FUNCTION_DECL:
+    case JS_VAR_DEF_NEW_FUNCTION_DECL:
         idx = find_lexical_decl(ctx, fd, name, fd->scope_first, TRUE);
         if (idx >= 0) {
-            if ((idx < GLOBAL_VAR_OFFSET &&
-                 (fd->vars[idx].scope_level == fd->scope_level ||
-                  (fd->vars[idx].var_kind == JS_VAR_CATCH && (fd->vars[idx].scope_level + 2) == fd->scope_level))) ||
-                (idx == GLOBAL_VAR_OFFSET && fd->scope_level == 1)) {
-                /* redefining a scoped var in the same scope: error */
-                return js_parse_error(s, "invalid redefinition of lexical identifier");
+            if (idx < GLOBAL_VAR_OFFSET) {
+                if (fd->vars[idx].scope_level == fd->scope_level) {
+                    /* same scope: in non strict mode, functions
+                       can be redefined (annex B.3.3.4). */
+                    if (!(!(fd->js_mode & JS_MODE_STRICT) &&
+                          var_def_type == JS_VAR_DEF_FUNCTION_DECL &&
+                          fd->vars[idx].var_kind == JS_VAR_FUNCTION_DECL)) {
+                        goto redef_lex_error;
+                    }
+                } else if (fd->vars[idx].var_kind == JS_VAR_CATCH && (fd->vars[idx].scope_level + 2) == fd->scope_level) {
+                    goto redef_lex_error;
+                }
+            } else {
+                if (fd->scope_level == 1) {
+                redef_lex_error:
+                    /* redefining a scoped var in the same scope: error */
+                    return js_parse_error(s, "invalid redefinition of lexical identifier");
+                }
             }
         }
-        if (tok != TOK_FUNCTION &&
+        if (var_def_type != JS_VAR_DEF_FUNCTION_DECL &&
+            var_def_type != JS_VAR_DEF_NEW_FUNCTION_DECL &&
             (fd->func_kind == JS_FUNC_ASYNC ||
              fd->func_kind == JS_FUNC_GENERATOR ||
              fd->func_kind == JS_FUNC_ASYNC_GENERATOR ||
-             fd->func_type == JS_PARSE_FUNC_METHOD) &&
+             fd->func_type == JS_PARSE_FUNC_METHOD ||
+             fd->scope_level == 1) &&
             find_arg(ctx, fd, name) >= 0) {
             /* lexical variable redefines a parameter name */
             return js_parse_error(s, "invalid redefinition of parameter name");
         }
 
+        if (find_var_in_child_scope(ctx, fd, name, fd->scope_level) >= 0) {
+            return js_parse_error(s, "invalid redefinition of a variable");
+        }
+        
+        if (fd->is_global_var) {
+            JSHoistedDef *hf;
+            hf = find_hoisted_def(fd, name);
+            if (hf && is_child_scope(ctx, fd, hf->scope_level,
+                                     fd->scope_level)) {
+                return js_parse_error(s, "invalid redefinition of global identifier");
+            }
+        }
+        
         if (fd->is_eval &&
             (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
              fd->eval_type == JS_EVAL_TYPE_MODULE) &&
             fd->scope_level == 1) {
             JSHoistedDef *hf;
-            hf = find_hoisted_def(fd, name);
-            /* XXX: should check scope chain */
-            if (hf && hf->scope_level == fd->scope_level) {
-                return js_parse_error(s, "invalid redefinition of global identifier");
-            }
             hf = add_hoisted_def(s->ctx, fd, -1, name, -1, TRUE);
             if (!hf)
                 return -1;
-            hf->is_const = (tok == TOK_CONST);
+            hf->is_const = (var_def_type == JS_VAR_DEF_CONST);
             idx = GLOBAL_VAR_OFFSET;
         } else {
-            if (fd->is_global_var) {
-                JSHoistedDef *hf;
-                hf = find_hoisted_def(fd, name);
-                /* XXX: should check scope chain */
-                if (hf && hf->scope_level == fd->scope_level) {
-                    return js_parse_error(s, "invalid redefinition of global identifier");
-                }
-            }
-            /* XXX: should also fail at scope_level 1 if name duplicates argument or var name */
-            idx = add_var(ctx, fd, name);
+            JSVarKindEnum var_kind;
+            if (var_def_type == JS_VAR_DEF_FUNCTION_DECL)
+                var_kind = JS_VAR_FUNCTION_DECL;
+            else if (var_def_type == JS_VAR_DEF_NEW_FUNCTION_DECL)
+                var_kind = JS_VAR_NEW_FUNCTION_DECL;
+            else
+                var_kind = JS_VAR_NORMAL;
+            idx = add_scope_var(ctx, fd, name, var_kind);
             if (idx >= 0) {
                 vd = &fd->vars[idx];
                 vd->is_lexical = 1;
-                vd->is_function = (tok == TOK_FUNCTION);
-                vd->is_const = (tok == TOK_CONST);
-                vd->scope_level = fd->scope_level;
-                vd->scope_next = fd->scope_first;
-                fd->scopes[fd->scope_level].first = idx;
-                fd->scope_first = idx;
+                vd->is_const = (var_def_type == JS_VAR_DEF_CONST);
             }
         }
         break;
 
-    case TOK_CATCH:
-        idx = add_var(ctx, fd, name);
-        if (idx >= 0) {
-            vd = &fd->vars[idx];
-            vd->var_kind = JS_VAR_CATCH;
-            vd->scope_level = fd->scope_level;
-            vd->scope_next = fd->scope_first;
-            fd->scopes[fd->scope_level].first = idx;
-            fd->scope_first = idx;
-        }
+    case JS_VAR_DEF_CATCH:
+        idx = add_scope_var(ctx, fd, name, JS_VAR_CATCH);
         break;
 
-    default:
-        /* TOK_VAR, TOK_FOR (used for for-of variable definition) */
+    case JS_VAR_DEF_VAR:
         if (find_lexical_decl(ctx, fd, name, fd->scope_first,
-                              (tok == TOK_FOR)) >= 0) {
+                              FALSE) >= 0) {
        invalid_lexical_redefinition:
             /* error to redefine a var that inside a lexical scope */
             return js_parse_error(s, "invalid redefinition of lexical identifier");
@@ -20359,7 +20446,6 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name, int tok)
             hf = add_hoisted_def(s->ctx, fd, -1, name, -1, FALSE);
             if (!hf)
                 return -1;
-            hf->is_for_of = (tok == TOK_FOR);
             idx = GLOBAL_VAR_OFFSET;
         } else {
             /* if the variable already exists, don't add it again  */
@@ -20370,13 +20456,33 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name, int tok)
             if (idx >= 0) {
                 if (name == JS_ATOM_arguments && fd->has_arguments_binding)
                     fd->arguments_var_idx = idx;
+                fd->vars[idx].func_pool_or_scope_idx = fd->scope_level;
             }
         }
         break;
+    default:
+        abort();
     }
     return idx;
 }
 
+/* add a private field variable in the current scope */
+static int add_private_class_field(JSParseState *s, JSFunctionDef *fd,
+                                   JSAtom name, JSVarKindEnum var_kind)
+{
+    JSContext *ctx = s->ctx;
+    JSVarDef *vd;
+    int idx;
+
+    idx = add_scope_var(ctx, fd, name, var_kind);
+    if (idx < 0)
+        return idx;
+    vd = &fd->vars[idx];
+    vd->is_lexical = 1;
+    vd->is_const = 1;
+    return idx;
+}
+
 static __exception int js_parse_expr(JSParseState *s);
 static __exception int js_parse_function_decl(JSParseState *s,
                                               JSParseFunctionEnum func_type,
@@ -20556,6 +20662,7 @@ static int __exception js_parse_property_name(JSParseState *s,
                                               BOOL allow_private)
 {
     int is_private = 0;
+    BOOL is_non_reserved_ident;
     JSAtom name;
     int prop_type;
     
@@ -20568,8 +20675,10 @@ static int __exception js_parse_property_name(JSParseState *s,
             if (next_token(s))
                 goto fail1;
             if (s->token.val == ':' || s->token.val == ',' ||
-                s->token.val == '}' || s->token.val == '(')
-                goto done;
+                s->token.val == '}' || s->token.val == '(') {
+                is_non_reserved_ident = TRUE;
+                goto ident_found;
+            }
             prop_type = PROP_TYPE_GET + (name == JS_ATOM_set);
             JS_FreeAtom(s->ctx, name);
         } else if (s->token.val == '*') {
@@ -20582,8 +20691,10 @@ static int __exception js_parse_property_name(JSParseState *s,
             if (next_token(s))
                 goto fail1;
             if (s->token.val == ':' || s->token.val == ',' ||
-                s->token.val == '}' || s->token.val == '(')
-                goto done;
+                s->token.val == '}' || s->token.val == '(') {
+                is_non_reserved_ident = TRUE;
+                goto ident_found;
+            }
             JS_FreeAtom(s->ctx, name);
             if (s->token.val == '*') {
                 if (next_token(s))
@@ -20597,17 +20708,20 @@ static int __exception js_parse_property_name(JSParseState *s,
 
     if (token_is_ident(s->token.val)) {
         /* variable can only be a non-reserved identifier */
-        if (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved &&
-            prop_type == PROP_TYPE_IDENT && allow_var) {
-            int tok = peek_token(s, FALSE);
-            if (!(tok == ':' || (tok == '(' && allow_method))) {
-                prop_type = PROP_TYPE_VAR;
-            }
-        }
+        is_non_reserved_ident =
+            (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved);
         /* keywords and reserved words have a valid atom */
         name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
         if (next_token(s))
             goto fail1;
+    ident_found:
+        if (is_non_reserved_ident &&
+            prop_type == PROP_TYPE_IDENT && allow_var) {
+            if (!(s->token.val == ':' ||
+                  (s->token.val == '(' && allow_method))) {
+                prop_type = PROP_TYPE_VAR;
+            }
+        }
     } else if (s->token.val == TOK_STRING) {
         name = js_value_to_atom(s->ctx, s->token.u.str.str);
         if (name == JS_ATOM_NULL)
@@ -20658,7 +20772,6 @@ static int __exception js_parse_property_name(JSParseState *s,
         js_parse_error(s, "invalid property name");
         goto fail;
     }
- done:
     *pname = name;
     return prop_type | is_private;
  fail1:
@@ -20693,6 +20806,29 @@ static __exception int js_parse_seek_token(JSParseState *s, const JSParsePos *sp
     return next_token(s);
 }
 
+/* return TRUE if a regexp literal is allowed after this token */
+static BOOL is_regexp_allowed(int tok)
+{
+    switch (tok) {
+    case TOK_NUMBER:
+    case TOK_STRING:
+    case TOK_REGEXP:
+    case TOK_DEC:
+    case TOK_INC:
+    case TOK_NULL:
+    case TOK_FALSE:
+    case TOK_TRUE:
+    case TOK_THIS:
+    case ')':
+    case ']':
+    case '}': /* XXX: regexp may occur after */
+    case TOK_IDENT:
+        return FALSE;
+    default:
+        return TRUE;
+    }
+}
+
 #define SKIP_HAS_SEMI      (1 << 0)
 #define SKIP_HAS_ELLIPSIS  (1 << 1)
 
@@ -20704,13 +20840,14 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
     char state[256];
     size_t level = 0;
     JSParsePos pos;
-    int tok = TOK_EOF;
-    int bits = 0;
+    int last_tok, tok = TOK_EOF;
+    int tok_len, bits = 0;
 
     /* protect from underflow */
     state[level++] = 0;
 
     js_parse_get_pos(s, &pos);
+    last_tok = 0;
     for (;;) {
         switch(s->token.val) {
         case '(':
@@ -20744,6 +20881,29 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 bits |= SKIP_HAS_ELLIPSIS;
             }
             break;
+
+        case TOK_DIV_ASSIGN:
+            tok_len = 2;
+            goto parse_regexp;
+        case '/':
+            tok_len = 1;
+        parse_regexp:
+            if (is_regexp_allowed(last_tok)) {
+                s->buf_ptr -= tok_len;
+                if (js_parse_regexp(s)) {
+                    /* XXX: should clear the exception */
+                    goto done;
+                }
+            }
+            break;
+        }
+        /* last_tok is only used to recognize regexps */
+        if (s->token.val == TOK_IDENT &&
+            (token_is_pseudo_keyword(s, JS_ATOM_of) ||
+             token_is_pseudo_keyword(s, JS_ATOM_yield))) {
+            last_tok = TOK_OF;
+        } else {
+            last_tok = s->token.val;
         }
         if (next_token(s)) {
             /* XXX: should clear the exception generated by next_token() */
@@ -20767,30 +20927,52 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
     return tok;
 }
 
-static BOOL set_object_name(JSParseState *s, JSAtom name)
+static void set_object_name(JSParseState *s, JSAtom name)
 {
     JSFunctionDef *fd = s->cur_func;
+    int opcode;
 
-    if (get_prev_opcode(fd) == OP_set_name) {
+    opcode = get_prev_opcode(fd);
+    if (opcode == OP_set_name) {
         /* XXX: should free atom after OP_set_name? */
         fd->byte_code.size = fd->last_opcode_pos;
         fd->last_opcode_pos = -1;
         emit_op(s, OP_set_name);
         emit_atom(s, name);
-        return TRUE;
+    } else if (opcode == OP_set_class_name) {
+        int define_class_pos;
+        JSAtom atom;
+        define_class_pos = fd->last_opcode_pos + 1 -
+            get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
+        assert(fd->byte_code.buf[define_class_pos] == OP_define_class);
+        /* for consistency we free the previous atom which is
+           JS_ATOM_empty_string */
+        atom = get_u32(fd->byte_code.buf + define_class_pos + 1);
+        JS_FreeAtom(s->ctx, atom);
+        put_u32(fd->byte_code.buf + define_class_pos + 1,
+                JS_DupAtom(s->ctx, name));
+        fd->last_opcode_pos = -1;
     }
-    return FALSE;
 }
 
 static void set_object_name_computed(JSParseState *s)
 {
     JSFunctionDef *fd = s->cur_func;
+    int opcode;
 
-    if (get_prev_opcode(fd) == OP_set_name) {
+    opcode = get_prev_opcode(fd);
+    if (opcode == OP_set_name) {
         /* XXX: should free atom after OP_set_name? */
         fd->byte_code.size = fd->last_opcode_pos;
         fd->last_opcode_pos = -1;
         emit_op(s, OP_set_name_computed);
+    } else if (opcode == OP_set_class_name) {
+        int define_class_pos;
+        define_class_pos = fd->last_opcode_pos + 1 -
+            get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
+        assert(fd->byte_code.buf[define_class_pos] == OP_define_class);
+        fd->byte_code.buf[define_class_pos] = OP_define_class_computed;
+        fd->last_opcode_pos = -1;
     }
 }
 
@@ -20961,28 +21143,6 @@ static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
     return -1;
 }
 
-/* add field in the current scope */
-static int add_private_class_field(JSParseState *s, JSFunctionDef *fd,
-                                   JSAtom name, JSVarKindEnum var_kind)
-{
-    JSContext *ctx = s->ctx;
-    JSVarDef *vd;
-    int idx;
-
-    idx = add_var(ctx, fd, name);
-    if (idx < 0)
-        return idx;
-    vd = &fd->vars[idx];
-    vd->is_lexical = 1;
-    vd->is_const = 1;
-    vd->var_kind = var_kind;
-    vd->scope_level = fd->scope_level;
-    vd->scope_next = fd->scope_first;
-    fd->scopes[fd->scope_level].first = idx;
-    fd->scope_first = idx;
-    return idx;
-}
-
 /* initialize the class fields, called by the constructor. Note:
    super() can be called in an arrow function, so <this> and
    <class_fields_init> can be variable references */
@@ -21098,7 +21258,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     JSAtom class_var_name = JS_ATOM_NULL;
     JSFunctionDef *method_fd, *ctor_fd;
     int saved_js_mode, class_name_var_idx, prop_type, ctor_cpool_offset;
-    int class_flags = 0, i;
+    int class_flags = 0, i, define_class_offset;
     BOOL is_static, is_private;
     const uint8_t *class_start_ptr = s->token.ptr;
     const uint8_t *start_ptr;
@@ -21144,7 +21304,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
 
     /* add a 'const' definition for the class name */
     if (class_name != JS_ATOM_NULL) {
-        class_name_var_idx = define_var(s, fd, class_name, TOK_CONST);
+        class_name_var_idx = define_var(s, fd, class_name, JS_VAR_DEF_CONST);
         if (class_name_var_idx < 0)
             goto fail;
     }
@@ -21159,14 +21319,19 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     ctor_cpool_offset = fd->byte_code.size;
     emit_u32(s, 0); /* will be patched at the end of the class parsing */
 
-    if (class_var_name != JS_ATOM_NULL && class_name == JS_ATOM_NULL)
-        class_name1 = JS_ATOM_default;
-    else
+    if (class_name == JS_ATOM_NULL) {
+        if (class_var_name != JS_ATOM_NULL)
+            class_name1 = JS_ATOM_default;
+        else
+            class_name1 = JS_ATOM_empty_string;
+    } else {
         class_name1 = class_name;
+    }
     
     emit_op(s, OP_define_class);
     emit_atom(s, class_name1);
     emit_u8(s, class_flags);
+    define_class_offset = fd->last_opcode_pos;
 
     for(i = 0; i < 2; i++) {
         ClassFieldsDef *cf = &class_fields[i];
@@ -21300,7 +21465,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 field_var_name = js_atom_concat_num(ctx, JS_ATOM_computed_field + is_static, cf->computed_fields_count);
                 if (field_var_name == JS_ATOM_NULL)
                     goto fail;
-                if (define_var(s, fd, field_var_name, TOK_CONST) < 0) {
+                if (define_var(s, fd, field_var_name, JS_VAR_DEF_CONST) < 0) {
                     JS_FreeAtom(ctx, field_var_name);
                     goto fail;
                 }
@@ -21445,7 +21610,8 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         ClassFieldsDef *cf = &class_fields[0];
         int var_idx;
         
-        var_idx = define_var(s, fd, JS_ATOM_class_fields_init, TOK_CONST);
+        var_idx = define_var(s, fd, JS_ATOM_class_fields_init,
+                             JS_VAR_DEF_CONST);
         if (var_idx < 0)
             goto fail;
         if (cf->fields_init_fd) {
@@ -21485,18 +21651,18 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
 
     /* the class statements have a block level scope */
     if (class_var_name != JS_ATOM_NULL) {
-        if (define_var(s, fd, class_var_name, TOK_LET) < 0)
+        if (define_var(s, fd, class_var_name, JS_VAR_DEF_LET) < 0)
             goto fail;
         emit_op(s, OP_scope_put_var_init);
         emit_atom(s, class_var_name);
         emit_u16(s, fd->scope_level);
     } else {
         if (class_name == JS_ATOM_NULL) {
-            /* XXX: should be done before calling the initializers. It
-               could be done with a specific opcode to patch the code
-               before */
-            emit_op(s, OP_set_name);
-            emit_atom(s, class_name); /* will be patched by assignment */
+            /* cannot use OP_set_name because the name of the class
+               must be defined before the static initializers are
+               executed */
+            emit_op(s, OP_set_class_name);
+            emit_u32(s, fd->last_opcode_pos + 1 - define_class_offset);
         }
     }
 
@@ -21908,7 +22074,8 @@ static int js_unsupported_keyword(JSParseState *s, JSAtom atom)
 static __exception int js_define_var(JSParseState *s, JSAtom name, int tok)
 {
     JSFunctionDef *fd = s->cur_func;
-
+    JSVarDefEnum var_def_type;
+    
     if (name == JS_ATOM_yield && fd->func_kind == JS_FUNC_GENERATOR) {
         return js_parse_error(s, "yield is a reserved identifier");
     }
@@ -21920,7 +22087,23 @@ static __exception int js_define_var(JSParseState *s, JSAtom name, int tok)
     &&  (tok == TOK_LET || tok == TOK_CONST)) {
         return js_parse_error(s, "invalid lexical variable name");
     }
-    if (define_var(s, fd, name, tok) < 0)
+    switch(tok) {
+    case TOK_LET:
+        var_def_type = JS_VAR_DEF_LET;
+        break;
+    case TOK_CONST:
+        var_def_type = JS_VAR_DEF_CONST;
+        break;
+    case TOK_VAR:
+        var_def_type = JS_VAR_DEF_VAR;
+        break;
+    case TOK_CATCH:
+        var_def_type = JS_VAR_DEF_CATCH;
+        break;
+    default:
+        abort();
+    }
+    if (define_var(s, fd, name, var_def_type) < 0)
         return -1;
     return 0;
 }
@@ -22666,17 +22849,30 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         }
         break;
     case TOK_IMPORT:
-        if (!accept_lparen)
-            return js_parse_error(s, "invalid use of 'import'");
         if (next_token(s))
             return -1;
-        if (js_parse_expect(s, '('))
-            return -1;
-        if (js_parse_assign_expr(s, TRUE))
-            return -1;
-        if (js_parse_expect(s, ')'))
-            return -1;
-        emit_op(s, OP_import);
+        if (s->token.val == '.') {
+            if (next_token(s))
+                return -1;
+            if (!token_is_pseudo_keyword(s, JS_ATOM_meta))
+                return js_parse_error(s, "meta expected");
+            if (!s->is_module)
+                return js_parse_error(s, "import.meta only valid in module code");
+            if (next_token(s))
+                return -1;
+            emit_op(s, OP_special_object);
+            emit_u8(s, OP_SPECIAL_OBJECT_IMPORT_META);
+        } else {
+            if (js_parse_expect(s, '('))
+                return -1;
+            if (!accept_lparen)
+                return js_parse_error(s, "invalid use of 'import()'");
+            if (js_parse_assign_expr(s, TRUE))
+                return -1;
+            if (js_parse_expect(s, ')'))
+                return -1;
+            emit_op(s, OP_import);
+        }
         break;
     default:
         return js_parse_error(s, "unexpected token in expression: '%.*s'",
@@ -24028,9 +24224,6 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
                 JS_FreeAtom(s->ctx, var_name);
                 return -1;
             }
-            /* Note: if there is a '=' after, it cannot be a for-of. */
-            if (tok == TOK_VAR && token_is_pseudo_keyword(s, JS_ATOM_of))
-                tok = TOK_FOR;
             if (js_define_var(s, var_name, tok)) {
                 JS_FreeAtom(s->ctx, var_name);
                 return -1;
@@ -24833,7 +25026,8 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                 goto fail;
 
             push_scope(s);
-            with_idx = define_var(s, s->cur_func, JS_ATOM__with_, TOK_WITH);
+            with_idx = define_var(s, s->cur_func, JS_ATOM__with_,
+                                  JS_VAR_DEF_WITH);
             if (with_idx < 0)
                 goto fail;
             emit_op(s, OP_to_object);
@@ -24896,6 +25090,13 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
         break;
 
     case TOK_DEBUGGER:
+        /* currently no debugger, so just skip the keyword */
+        if (next_token(s))
+            goto fail;
+        if (js_parse_expect_semi(s))
+            goto fail;
+        break;
+        
     case TOK_ENUM:
     case TOK_EXPORT:
     case TOK_EXTENDS:
@@ -24940,6 +25141,7 @@ static JSModuleDef *js_new_module_def(JSContext *ctx, JSAtom name)
     m->module_ns = JS_UNDEFINED;
     m->func_obj = JS_UNDEFINED;
     m->eval_exception = JS_UNDEFINED;
+    m->meta_obj = JS_UNDEFINED;
     list_add_tail(&m->link, &ctx->loaded_modules);
     return m;
 }
@@ -24976,6 +25178,7 @@ static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
     JS_FreeValue(ctx, m->module_ns);
     JS_FreeValue(ctx, m->func_obj);
     JS_FreeValue(ctx, m->eval_exception);
+    JS_FreeValue(ctx, m->meta_obj);
     list_del(&m->link);
     js_free(ctx, m);
 }
@@ -25201,13 +25404,26 @@ static char *js_default_module_normalize_name(JSContext *ctx,
     return filename;
 }
 
+static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name)
+{
+    struct list_head *el;
+    JSModuleDef *m;
+    
+    /* first look at the loaded modules */
+    list_for_each(el, &ctx->loaded_modules) {
+        m = list_entry(el, JSModuleDef, link);
+        if (m->module_name == name)
+            return m;
+    }
+    return NULL;
+}
+
 /* return NULL in case of exception (e.g. module could not be loaded) */
 static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
                                                     JSAtom base_module_name,
                                                     JSAtom module_name1)
 {
     JSRuntime *rt = ctx->rt;
-    struct list_head *el;
     JSModuleDef *m;
     char *cname;
     const char *base_cname, *cname1;
@@ -25240,13 +25456,11 @@ static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
     }
 
     /* first look at the loaded modules */
-    list_for_each(el, &ctx->loaded_modules) {
-        m = list_entry(el, JSModuleDef, link);
-        if (m->module_name == module_name) {
-            js_free(ctx, cname);
-            JS_FreeAtom(ctx, module_name);
-            return m;
-        }
+    m = js_find_loaded_module(ctx, module_name);
+    if (m) {
+        js_free(ctx, cname);
+        JS_FreeAtom(ctx, module_name);
+        return m;
     }
 
     JS_FreeAtom(ctx, module_name);
@@ -25953,20 +26167,12 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     return -1;
 }
 
-static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+/* warning: the returned atom is not allocated */
+static JSAtom js_get_script_or_module_name(JSContext *ctx)
 {
     JSStackFrame *sf;
     JSFunctionBytecode *b;
     JSObject *p;
-    JSModuleDef *m;
-    JSAtom basename, filename;
-    JSValue promise, resolving_funcs[2];
-    JSValue specifierString, ret, func_obj, err, ns;
-    
-    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
-    if (JS_IsException(promise))
-        return promise;
-    
     /* XXX: currently we just use the filename of the englobing
        function. It does not work for eval(). Need to add a
        ScriptOrModule info in JSFunctionBytecode */
@@ -25976,11 +26182,66 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     p = JS_VALUE_GET_OBJ(sf->cur_func);
     assert(js_class_has_bytecode(p->class_id));
     b = p->u.func.function_bytecode;
-    if (!b->has_debug) {
+    if (!b->has_debug)
+        return JS_ATOM_NULL;
+    return b->debug.filename;
+}
+
+JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m)
+{
+    return JS_DupAtom(ctx, m->module_name);
+}
+
+JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m)
+{
+    JSValue obj;
+    /* allocate meta_obj only if requested to save memory */
+    obj = m->meta_obj;
+    if (JS_IsUndefined(obj)) {
+        obj = JS_NewObjectProto(ctx, JS_NULL);
+        if (JS_IsException(obj))
+            return JS_EXCEPTION;
+        m->meta_obj = obj;
+    }
+    return JS_DupValue(ctx, obj);
+}
+
+static JSValue js_import_meta(JSContext *ctx)
+{
+    JSAtom filename;
+    JSModuleDef *m;
+    
+    filename = js_get_script_or_module_name(ctx);
+    if (filename == JS_ATOM_NULL)
+        goto fail;
+
+    /* XXX: inefficient, need to add a module or script pointer in
+       JSFunctionBytecode */
+    m = js_find_loaded_module(ctx, filename);
+    if (!m) {
+    fail:
+        JS_ThrowTypeError(ctx, "import.meta not supported in this context");
+        return JS_EXCEPTION;
+    }
+    return JS_GetImportMeta(ctx, m);
+}
+
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+{
+    JSModuleDef *m;
+    JSAtom basename, filename;
+    JSValue promise, resolving_funcs[2];
+    JSValue specifierString, ret, func_obj, err, ns;
+    
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return promise;
+    
+    basename = js_get_script_or_module_name(ctx);
+    if (basename == JS_ATOM_NULL) {
         JS_ThrowTypeError(ctx, "no function filename for import()");
         goto exception;
     }
-    basename = b->debug.filename;
 
     specifierString = JS_ToString(ctx, specifier);
     if (JS_IsException(specifierString))
@@ -26003,7 +26264,7 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
 
     /* Evaluate the module code */
     func_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
-    ret = JS_EvalFunction(ctx, func_obj, ctx->global_obj);
+    ret = JS_EvalFunction(ctx, func_obj);
     if (JS_IsException(ret))
         goto exception;
     JS_FreeValue(ctx, ret);
@@ -26253,7 +26514,7 @@ static __exception int js_parse_export(JSParseState *s)
         /* store the value in the _default_ global variable and export
            it */
         local_name = JS_ATOM__default_;
-        if (define_var(s, s->cur_func, local_name, TOK_LET) < 0)
+        if (define_var(s, s->cur_func, local_name, JS_VAR_DEF_LET) < 0)
             return -1;
         emit_op(s, OP_scope_put_var_init);
         emit_atom(s, local_name);
@@ -26428,7 +26689,8 @@ static __exception int js_parse_import(JSParseState *s)
 static __exception int js_parse_source_element(JSParseState *s)
 {
     JSFunctionDef *fd = s->cur_func;
-
+    int tok;
+    
     if (s->token.val == TOK_FUNCTION ||
         (token_is_pseudo_keyword(s, JS_ATOM_async) &&
          peek_token(s, TRUE) == TOK_FUNCTION)) {
@@ -26440,9 +26702,9 @@ static __exception int js_parse_source_element(JSParseState *s)
         if (js_parse_export(s))
             return -1;
     } else if (s->token.val == TOK_IMPORT && fd->module &&
-               peek_token(s, FALSE) != '(') {
+               ((tok = peek_token(s, FALSE)) != '(' && tok != '.'))  {
         /* the peek_token is needed to avoid confusion with ImportCall
-           (dynamic import) */
+           (dynamic import) or import.meta */
         if (js_parse_import(s))
             return -1;
     } else {
@@ -26978,7 +27240,8 @@ static __attribute__((unused)) void js_dump_function_bytecode(JSContext *ctx, JS
             JSVarDef *vd = &b->vardefs[b->arg_count + i];
             printf("%5d: %s %s", i,
                    vd->var_kind == JS_VAR_CATCH ? "catch" :
-                   vd->is_function ? "function" :
+                   (vd->var_kind == JS_VAR_FUNCTION_DECL ||
+                    vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) ? "function" :
                    vd->is_const ? "const" :
                    vd->is_lexical ? "let" : "var",
                    JS_AtomGetStr(ctx, atom_buf, sizeof(atom_buf), vd->var_name));
@@ -27765,12 +28028,13 @@ static int find_private_class_field_all(JSContext *ctx, JSFunctionDef *fd,
 
 static void get_loc_or_ref(DynBuf *bc, BOOL is_ref, int idx)
 {
+    /* Note: the private field can be uninitialized, so the _check is
+       necessary */
     if (is_ref) 
-        dbuf_putc(bc, OP_get_var_ref);
+        dbuf_putc(bc, OP_get_var_ref_check);
     else
-        dbuf_putc(bc, OP_get_loc);
+        dbuf_putc(bc, OP_get_loc_check);
     dbuf_put_u16(bc, idx);
-    
 }
 
 static int resolve_scope_private_field1(JSContext *ctx,
@@ -28469,8 +28733,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                     JSClosureVar *cv = &s->closure_var[idx];
                     if (cv->var_name == hf->var_name) {
                         if (s->eval_type == JS_EVAL_TYPE_DIRECT &&
-                            (cv->is_lexical ||
-                             (cv->var_kind == JS_VAR_CATCH && hf->is_for_of))) {
+                            cv->is_lexical) {
                             /* Check if a lexical variable is
                                redefined as 'var'. XXX: Could abort
                                compilation here, but for consistency
@@ -28664,10 +28927,11 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                 for(scope_idx = s->scopes[scope].first; scope_idx >= 0;) {
                     JSVarDef *vd = &s->vars[scope_idx];
                     if (vd->scope_level == scope) {
-                        if (vd->is_function) {
+                        if (vd->var_kind == JS_VAR_FUNCTION_DECL ||
+                            vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) {
                             /* Initialize lexical variable upon entering scope */
                             dbuf_putc(&bc_out, OP_fclosure);
-                            dbuf_put_u32(&bc_out, vd->func_pool_idx);
+                            dbuf_put_u32(&bc_out, vd->func_pool_or_scope_idx);
                             dbuf_putc(&bc_out, OP_put_loc);
                             dbuf_put_u16(&bc_out, scope_idx);
                         } else {
@@ -28754,7 +29018,10 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         case OP_nop:
             /* remove erased code */
             break;
-
+        case OP_set_class_name:
+            /* only used during parsing */
+            break;
+            
         default:
         no_change:
             dbuf_put(&bc_out, bc_buf + pos, len);
@@ -30639,7 +30906,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             /* Always create a lexical name, fail if at the same scope as
                existing name */
             /* Lexical variable will be initialized upon entering scope */
-            lexical_func_idx = define_var(s, fd, func_name, TOK_FUNCTION);
+            lexical_func_idx = define_var(s, fd, func_name,
+                                          func_kind != JS_FUNC_NORMAL ?
+                                          JS_VAR_DEF_NEW_FUNCTION_DECL :
+                                          JS_VAR_DEF_FUNCTION_DECL);
             if (lexical_func_idx < 0) {
                 JS_FreeAtom(ctx, func_name);
                 return -1;
@@ -30960,6 +31230,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     hf = add_hoisted_def(ctx, s->cur_func, -1, func_name, -1, FALSE);
                     if (!hf)
                         goto fail;
+                    /* it is considered as defined at the top level
+                       (needed for annex B.3.3.4 and B.3.3.5
+                       checks) */
+                    hf->scope_level = 0; 
                     hf->force_init = ((s->cur_func->js_mode & JS_MODE_STRICT) != 0);
                     /* store directly into global var, bypass lexical scope */
                     emit_op(s, OP_dup);
@@ -30983,7 +31257,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             }
             if (lexical_func_idx >= 0) {
                 /* lexical variable will be initialized upon entering scope */
-                s->cur_func->vars[lexical_func_idx].func_pool_idx = idx;
+                s->cur_func->vars[lexical_func_idx].func_pool_or_scope_idx = idx;
                 emit_op(s, OP_drop);
             } else {
                 /* store function object into its lexical name */
@@ -30994,7 +31268,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             }
         } else {
             if (!s->cur_func->is_global_var) {
-                int var_idx = define_var(s, s->cur_func, func_name, TOK_VAR);
+                int var_idx = define_var(s, s->cur_func, func_name, JS_VAR_DEF_VAR);
 
                 if (var_idx < 0)
                     goto fail;
@@ -31124,9 +31398,9 @@ static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
     return ret_val;
 }
 
-JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj, JSValueConst this_obj)
+JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj)
 {
-    return JS_EvalFunctionInternal(ctx, fun_obj, this_obj, NULL, NULL);
+    return JS_EvalFunctionInternal(ctx, fun_obj, ctx->global_obj, NULL, NULL);
 }
 
 static void skip_shebang(JSParseState *s)
@@ -31303,27 +31577,16 @@ JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
     return ret;
 }
 
-JSValue JS_EvalBinary(JSContext *ctx,
-                      const uint8_t *buf, size_t buf_len, int flags)
+int JS_ResolveModule(JSContext *ctx, JSValueConst obj)
 {
-    JSValue obj;
-    obj = JS_ReadObject(ctx, buf, buf_len, JS_READ_OBJ_BYTECODE);
-    if (JS_IsException(obj))
-        return obj;
-    if (flags & JS_EVAL_BINARY_LOAD_ONLY) {
-        return obj;
-    } else {
-        /* if a module, we load the dependencies here */
-        if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
-            JSModuleDef *m = JS_VALUE_GET_PTR(obj);
-            if (js_resolve_module(ctx, m) < 0) {
-                JS_FreeValue(ctx, obj);
-                js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
-                return JS_EXCEPTION;
-            }
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
+        JSModuleDef *m = JS_VALUE_GET_PTR(obj);
+        if (js_resolve_module(ctx, m) < 0) {
+            js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
+            return -1;
         }
-        return JS_EvalFunction(ctx, obj, ctx->global_obj);
     }
+    return 0;
 }
 
 /*******************************************************************/
@@ -31689,8 +31952,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                     bc_put_leb128(s, vd->scope_level);
                     bc_put_leb128(s, vd->scope_next + 1);
                     flags = idx = 0;
-                    bc_set_flags(&flags, &idx, vd->var_kind, 3);
-                    bc_set_flags(&flags, &idx, vd->is_function, 1);
+                    bc_set_flags(&flags, &idx, vd->var_kind, 4);
                     bc_set_flags(&flags, &idx, vd->is_func_var, 1);
                     bc_set_flags(&flags, &idx, vd->is_const, 1);
                     bc_set_flags(&flags, &idx, vd->is_lexical, 1);
@@ -31711,7 +31973,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                 bc_set_flags(&flags, &idx, cv->is_arg, 1);
                 bc_set_flags(&flags, &idx, cv->is_const, 1);
                 bc_set_flags(&flags, &idx, cv->is_lexical, 1);
-                bc_set_flags(&flags, &idx, cv->var_kind, 3);
+                bc_set_flags(&flags, &idx, cv->var_kind, 4);
                 assert(idx <= 8);
                 bc_put_u8(s, flags);
             }
@@ -32454,8 +32716,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
                     if (bc_get_u8(s, &v8))
                         goto fail;
                     idx = 0;
-                    vd->var_kind = bc_get_flags(v8, &idx, 3);
-                    vd->is_function = bc_get_flags(v8, &idx, 1);
+                    vd->var_kind = bc_get_flags(v8, &idx, 4);
                     vd->is_func_var = bc_get_flags(v8, &idx, 1);
                     vd->is_const = bc_get_flags(v8, &idx, 1);
                     vd->is_lexical = bc_get_flags(v8, &idx, 1);
@@ -32484,7 +32745,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
                     cv->is_arg = bc_get_flags(v8, &idx, 1);
                     cv->is_const = bc_get_flags(v8, &idx, 1);
                     cv->is_lexical = bc_get_flags(v8, &idx, 1);
-                    cv->var_kind = bc_get_flags(v8, &idx, 3);
+                    cv->var_kind = bc_get_flags(v8, &idx, 4);
 #ifdef DUMP_READ_OBJECT
                     bc_read_trace(s, "name: "); print_atom(s->ctx, cv->var_name); printf("\n");
 #endif
@@ -34441,17 +34702,65 @@ static JSValue js_function_proto(JSContext *ctx, JSValueConst this_val,
     return JS_UNDEFINED;
 }
 
+/* insert a '\n' at unicode character position 'pos' in the source of
+   'func_obj' */
+static int patch_function_constructor_source(JSContext *ctx,
+                                             JSValueConst func_obj,
+                                             size_t pos)
+{
+    JSObject *p;
+    JSFunctionBytecode *b;
+    char *r, *r_end, *new_source;
+    int c;
+    size_t idx, len;
+    
+    if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
+        return 0;
+    p = JS_VALUE_GET_OBJ(func_obj);
+    if (!js_class_has_bytecode(p->class_id))
+        return 0;
+    b = p->u.func.function_bytecode;
+    if (!b->has_debug)
+        return 0;
+    r = b->debug.source;
+    r_end = b->debug.source + b->debug.source_len;
+    idx = 0;
+    while (r < r_end) {
+        if (idx == pos) {
+            /* add the '\n' */
+            new_source = js_realloc(ctx, b->debug.source,
+                                    b->debug.source_len + 2);
+            if (!new_source)
+                return -1;
+            len = r - b->debug.source;
+            memmove(new_source + len + 1, new_source + len,
+                    b->debug.source_len + 1 - len);
+            new_source[len] = '\n';
+            b->debug.source = new_source;
+            b->debug.source_len++;
+            break;
+        }
+        c = unicode_from_utf8((const uint8_t *)r, UTF8_CHAR_LEN_MAX,
+                              (const uint8_t **)&r);
+        if (c < 0)
+            break;
+        idx++;
+    }
+    return 0;
+}
+                                             
+/* XXX: add a specific eval mode so that Function("}), ({") is rejected */
 static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
                                        int argc, JSValueConst *argv, int magic)
 {
     JSFunctionKindEnum func_kind = magic;
-    int i, n, ret;
+    int i, n, ret, func_start_pos;
     JSValue s, proto, obj = JS_UNDEFINED;
     StringBuffer b_s, *b = &b_s;
 
     string_buffer_init(ctx, b, 0);
     string_buffer_putc8(b, '(');
-
+    
     if (func_kind == JS_FUNC_ASYNC || func_kind == JS_FUNC_ASYNC_GENERATOR) {
         string_buffer_puts8(b, "async ");
     }
@@ -34470,7 +34779,13 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
         if (string_buffer_concat_value(b, argv[i]))
             goto fail;
     }
-    string_buffer_puts8(b, "\n) {\n");
+    string_buffer_puts8(b, "\n) {");
+    /* Annex B HTML comments: We don't add a '\n' after "{" so that
+       "-->" is not considered as an HTML comment. It is necessary
+       because in the spec the function body is parsed separately. */
+    /* XXX: find a simpler way or be deliberately incompatible to
+       simplify the code ? */
+    func_start_pos = b->len - 1; /* the leading '(' is not in the source */
     if (n >= 0) {
         if (string_buffer_concat_value(b, argv[n]))
             goto fail;
@@ -34484,6 +34799,8 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
     JS_FreeValue(ctx, s);
     if (JS_IsException(obj))
         goto fail1;
+    if (patch_function_constructor_source(ctx, obj, func_start_pos) < 0)
+        goto fail1;
     if (!JS_IsUndefined(new_target)) {
         /* set the prototype */
         proto = js_get_prototype_from_ctor(ctx, new_target, JS_UNDEFINED);
@@ -41052,18 +41369,6 @@ static JSValue JS_ToQuotedStringFree(JSContext *ctx, JSValue val) {
     return r;
 }
 
-static JSValue js_json_unbox(JSContext *ctx, JSValue val) {
-    if (JS_IsObject(val)) {
-        JSObject *p = JS_VALUE_GET_OBJ(val);
-        if (p->class_id == JS_CLASS_STRING || p->class_id == JS_CLASS_NUMBER) {
-            JSValue r = JS_DupValue(ctx, p->u.object_data);
-            JS_FreeValue(ctx, val);
-            val = r;
-        }
-    }
-    return val;
-}
-
 #ifdef CONFIG_BIGNUM
 static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v);
 #endif
@@ -41133,13 +41438,14 @@ static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
 
 static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
                           JSValueConst holder, JSValue val,
-                          JSValueConst key, JSValueConst indent)
+                          JSValueConst indent)
 {
     JSValue indent1, sep, sep1, tab, v, prop;
     JSObject *p;
     int64_t i, len;
-    int cl, res;
-
+    int cl, ret;
+    BOOL has_content;
+    
     indent1 = JS_UNDEFINED;
     sep = JS_UNDEFINED;
     sep1 = JS_UNDEFINED;
@@ -41151,15 +41457,22 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         p = JS_VALUE_GET_OBJ(val);
         cl = p->class_id;
         if (cl == JS_CLASS_STRING) {
-            val = JS_InvokeFree(ctx, val, JS_ATOM_toString, 0, NULL);
+            val = JS_ToStringFree(ctx, val);
             if (JS_IsException(val))
                 goto exception;
             val = JS_ToQuotedStringFree(ctx, val);
             if (JS_IsException(val))
                 goto exception;
             return string_buffer_concat_value_free(jsc->b, val);
-        } else if (cl == JS_CLASS_NUMBER || cl == JS_CLASS_BOOLEAN) {
+        } else if (cl == JS_CLASS_NUMBER) {
+            val = JS_ToNumberFree(ctx, val);
+            if (JS_IsException(val))
+                goto exception;
             return string_buffer_concat_value_free(jsc->b, val);
+        } else if (cl == JS_CLASS_BOOLEAN) {
+            ret = string_buffer_concat_value(jsc->b, p->u.object_data);
+            JS_FreeValue(ctx, val);
+            return ret;
         }
 #ifdef CONFIG_BIGNUM
         else if (cl == JS_CLASS_BIG_FLOAT) {
@@ -41169,10 +41482,10 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
             goto exception;
         }
 #endif
-        res = JS_ToBoolFree(ctx, js_array_includes(ctx, jsc->stack, 1, (JSValueConst *)&val));
-        if (res < 0)
+        v = js_array_includes(ctx, jsc->stack, 1, (JSValueConst *)&val);
+        if (JS_IsException(v))
             goto exception;
-        if (res) {
+        if (JS_ToBoolFree(ctx, v)) {
             JS_ThrowTypeError(ctx, "circular reference");
             goto exception;
         }
@@ -41180,7 +41493,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         if (JS_IsException(indent1))
             goto exception;
         if (!JS_IsEmptyString(jsc->gap)) {
-            sep = JS_ConcatString3(ctx, "\n", JS_DupValue(ctx, indent), "");
+            sep = JS_ConcatString3(ctx, "\n", JS_DupValue(ctx, indent1), "");
             if (JS_IsException(sep))
                 goto exception;
             sep1 = JS_NewString(ctx, " ");
@@ -41193,7 +41506,10 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         v = js_array_push(ctx, jsc->stack, 1, (JSValueConst *)&val, 0);
         if (check_exception_free(ctx, v))
             goto exception;
-        if (JS_IsArray(ctx, val)) {
+        ret = JS_IsArray(ctx, val);
+        if (ret < 0)
+            goto exception;
+        if (ret) {
             if (js_get_length64(ctx, &len, val))
                 goto exception;
             string_buffer_putc8(jsc->b, '[');
@@ -41204,12 +41520,18 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
                 v = JS_GetPropertyInt64(ctx, val, i);
                 if (JS_IsException(v))
                     goto exception;
-                v = js_json_check(ctx, jsc, val, v, JS_NewInt32(ctx, i));
+                /* XXX: could do this string conversion only when needed */
+                prop = JS_ToStringFree(ctx, JS_NewInt64(ctx, i));
+                if (JS_IsException(prop))
+                    goto exception;
+                v = js_json_check(ctx, jsc, val, v, prop);
+                JS_FreeValue(ctx, prop);
+                prop = JS_UNDEFINED;
                 if (JS_IsException(v))
                     goto exception;
                 if (JS_IsUndefined(v))
                     v = JS_NULL;
-                if (js_json_to_str(ctx, jsc, val, v, JS_NewInt32(ctx, i), indent1))
+                if (js_json_to_str(ctx, jsc, val, v, indent1))
                     goto exception;
             }
             if (len > 0 && !JS_IsEmptyString(jsc->gap)) {
@@ -41227,6 +41549,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
             if (js_get_length64(ctx, &len, tab))
                 goto exception;
             string_buffer_putc8(jsc->b, '{');
+            has_content = FALSE;
             for(i = 0; i < len; i++) {
                 JS_FreeValue(ctx, prop);
                 prop = JS_GetPropertyInt64(ctx, tab, i);
@@ -41239,7 +41562,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
                 if (JS_IsException(v))
                     goto exception;
                 if (!JS_IsUndefined(v)) {
-                    if (i > 0)
+                    if (has_content)
                         string_buffer_putc8(jsc->b, ',');
                     prop = JS_ToQuotedStringFree(ctx, prop);
                     if (JS_IsException(prop)) {
@@ -41250,11 +41573,12 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
                     string_buffer_concat_value(jsc->b, prop);
                     string_buffer_putc8(jsc->b, ':');
                     string_buffer_concat_value(jsc->b, sep1);
-                    if (js_json_to_str(ctx, jsc, val, v, prop, indent1))
+                    if (js_json_to_str(ctx, jsc, val, v, indent1))
                         goto exception;
+                    has_content = TRUE;
                 }
             }
-            if (len > 0 && JS_VALUE_GET_STRING(jsc->gap)->len != 0) {
+            if (has_content && JS_VALUE_GET_STRING(jsc->gap)->len != 0) {
                 string_buffer_putc8(jsc->b, '\n');
                 string_buffer_concat_value(jsc->b, indent);
             }
@@ -41273,14 +41597,19 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         val = JS_ToQuotedStringFree(ctx, val);
         if (JS_IsException(val))
             goto exception;
-        /* fall thru */
-    case JS_TAG_INT:
+        goto concat_value;
     case JS_TAG_FLOAT64:
+        if (!isfinite(JS_VALUE_GET_FLOAT64(val))) {
+            val = JS_NULL;
+        }
+        goto concat_value;
+    case JS_TAG_INT:
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
 #endif
     case JS_TAG_BOOL:
     case JS_TAG_NULL:
+    concat_value:
         return string_buffer_concat_value_free(jsc->b, val);
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
@@ -41309,7 +41638,7 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
     StringBuffer b_s;
     JSONStringifyContext jsc_s, *jsc = &jsc_s;
     JSValueConst replacer = argv[1];
-    JSValue val, v, space, ret;
+    JSValue val, v, space, ret, wrapper;
     int res;
     int64_t i, j, n;
 
@@ -41320,6 +41649,7 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
     jsc->b = &b_s;
     jsc->empty = JS_AtomToString(ctx, JS_ATOM_empty_string);
     ret = JS_UNDEFINED;
+    wrapper = JS_UNDEFINED;
 
     string_buffer_init(ctx, jsc->b, 0);
     jsc->stack = JS_NewArray(ctx);
@@ -41339,21 +41669,56 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
             if (js_get_length64(ctx, &n, replacer))
                 goto exception;
             for (i = j = 0; i < n; i++) {
+                JSValue present;
                 v = JS_GetPropertyInt64(ctx, replacer, i);
                 if (JS_IsException(v))
                     goto exception;
-                v = js_json_unbox(ctx, v);
-                if (JS_IsNumber(v)) {
+                if (JS_IsObject(v)) {
+                    JSObject *p = JS_VALUE_GET_OBJ(v);
+                    if (p->class_id == JS_CLASS_STRING ||
+                        p->class_id == JS_CLASS_NUMBER) {
+                        v = JS_ToStringFree(ctx, v);
+                        if (JS_IsException(v))
+                            goto exception;
+                    } else {
+                        JS_FreeValue(ctx, v);
+                        continue;
+                    }
+                } else if (JS_IsNumber(v)) {
                     v = JS_ToStringFree(ctx, v);
+                    if (JS_IsException(v))
+                        goto exception;
                 } else if (!JS_IsString(v)) {
                     JS_FreeValue(ctx, v);
                     continue;
                 }
-                JS_SetPropertyInt64(ctx, jsc->property_list, j++, v);
+                present = js_array_includes(ctx, jsc->property_list,
+                                            1, (JSValueConst *)&v);
+                if (JS_IsException(present)) {
+                    JS_FreeValue(ctx, v);
+                    goto exception;
+                }
+                if (!JS_ToBoolFree(ctx, present)) {
+                    JS_SetPropertyInt64(ctx, jsc->property_list, j++, v);
+                } else {
+                    JS_FreeValue(ctx, v);
+                }
             }
         }
     }
-    space = js_json_unbox(ctx, JS_DupValue(ctx, argv[2]));
+    space = JS_DupValue(ctx, argv[2]);
+    if (JS_IsObject(space)) {
+        JSObject *p = JS_VALUE_GET_OBJ(space);
+        if (p->class_id == JS_CLASS_NUMBER) {
+            space = JS_ToNumberFree(ctx, space);
+        } else if (p->class_id == JS_CLASS_STRING) {
+            space = JS_ToStringFree(ctx, space);
+        }
+        if (JS_IsException(space)) {
+            JS_FreeValue(ctx, space);
+            goto exception;
+        }
+    }
     if (JS_IsNumber(space)) {
         int n;
         if (JS_ToInt32Clamp(ctx, &n, space, 0, 10, 0))
@@ -41368,15 +41733,22 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
     JS_FreeValue(ctx, space);
     if (JS_IsException(jsc->gap))
         goto exception;
+    wrapper = JS_NewObject(ctx);
+    if (JS_IsException(wrapper))
+        goto exception;
+    if (JS_DefinePropertyValue(ctx, wrapper, JS_ATOM_empty_string,
+                               JS_DupValue(ctx, argv[0]), JS_PROP_C_W_E) < 0)
+        goto exception;
     val = JS_DupValue(ctx, argv[0]);
-    val = js_json_check(ctx, jsc, JS_NULL, val, jsc->empty);
+                           
+    val = js_json_check(ctx, jsc, wrapper, val, jsc->empty);
     if (JS_IsException(val))
         goto exception;
     if (JS_IsUndefined(val)) {
         ret = JS_UNDEFINED;
         goto done1;
     }
-    if (js_json_to_str(ctx, jsc, JS_NULL, val, jsc->empty, jsc->empty))
+    if (js_json_to_str(ctx, jsc, wrapper, val, jsc->empty))
         goto exception;
 
     ret = string_buffer_end(jsc->b);
@@ -41387,6 +41759,7 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
 done1:
     string_buffer_free(jsc->b);
 done:
+    JS_FreeValue(ctx, wrapper);
     JS_FreeValue(ctx, jsc->empty);
     JS_FreeValue(ctx, jsc->gap);
     JS_FreeValue(ctx, jsc->property_list);
@@ -41967,11 +42340,11 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
                                      JSValueConst obj, JSAtom prop)
 {
     JSProxyData *s;
-    JSValue method, ret1, prop_val;
-    int res, target_res, ret;
+    JSValue method, trap_result_obj, prop_val;
+    int res, target_desc_ret, ret;
     JSObject *p;
     JSValueConst args[2];
-    JSPropertyDescriptor desc, target_desc;
+    JSPropertyDescriptor result_desc, target_desc;
 
     s = get_proxy_method(ctx, &method, obj, JS_ATOM_getOwnPropertyDescriptor);
     if (!s)
@@ -41987,38 +42360,43 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
     }
     args[0] = s->target;
     args[1] = prop_val;
-    ret1 = JS_CallFree(ctx, method, s->handler, 2, args);
+    trap_result_obj = JS_CallFree(ctx, method, s->handler, 2, args);
     JS_FreeValue(ctx, prop_val);
-    if (JS_IsException(ret1))
+    if (JS_IsException(trap_result_obj))
         return -1;
-    if (!JS_IsObject(ret1) && !JS_IsUndefined(ret1)) {
-        JS_FreeValue(ctx, ret1);
+    if (!JS_IsObject(trap_result_obj) && !JS_IsUndefined(trap_result_obj)) {
+        JS_FreeValue(ctx, trap_result_obj);
         goto fail;
     }
-    target_res = JS_GetOwnPropertyInternal(ctx, &target_desc, p, prop);
-    if (target_res < 0) {
-        JS_FreeValue(ctx, ret1);
+    target_desc_ret = JS_GetOwnPropertyInternal(ctx, &target_desc, p, prop);
+    if (target_desc_ret < 0) {
+        JS_FreeValue(ctx, trap_result_obj);
         return -1;
     }
-    if (target_res)
+    if (target_desc_ret)
         js_free_desc(ctx, &target_desc);
-    if (JS_IsUndefined(ret1)) {
-        if (target_res) {
+    if (JS_IsUndefined(trap_result_obj)) {
+        if (target_desc_ret) {
             if (!(target_desc.flags & JS_PROP_CONFIGURABLE) || !p->extensible)
                 goto fail;
         }
         ret = FALSE;
     } else {
-        int flags1;
-
-        res = js_obj_to_desc(ctx, &desc, ret1);
-        JS_FreeValue(ctx, ret1);
+        int flags1, extensible_target;
+        extensible_target = JS_IsExtensible(ctx, s->target);
+        if (extensible_target < 0) {
+            JS_FreeValue(ctx, trap_result_obj);
+            return -1;
+        }
+        res = js_obj_to_desc(ctx, &result_desc, trap_result_obj);
+        JS_FreeValue(ctx, trap_result_obj);
         if (res < 0)
             return -1;
-        if (target_res) {
-            /* convert desc.flags to defineProperty flags */
-            flags1 = desc.flags | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE;
-            if (desc.flags & JS_PROP_GETSET)
+        
+        if (target_desc_ret) {
+            /* convert result_desc.flags to defineProperty flags */
+            flags1 = result_desc.flags | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE;
+            if (result_desc.flags & JS_PROP_GETSET)
                 flags1 |= JS_PROP_HAS_GET | JS_PROP_HAS_SET;
             else
                 flags1 |= JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE;
@@ -42027,23 +42405,29 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
             if (!check_define_prop_flags(target_desc.flags, flags1))
                 goto fail1;
         } else {
-            if (!p->extensible)
+            if (!extensible_target)
                 goto fail1;
         }
-        res = (!(desc.flags & JS_PROP_CONFIGURABLE) &&
-               (!target_res || (target_desc.flags & JS_PROP_CONFIGURABLE)));
-        if (res) {
-        fail1:
-            js_free_desc(ctx, &desc);
-        fail:
-            JS_ThrowTypeError(ctx, "proxy: inconsistent getOwnPropertyDescriptor");
-            return -1;
+        if (!(result_desc.flags & JS_PROP_CONFIGURABLE)) {
+            if (!target_desc_ret || (target_desc.flags & JS_PROP_CONFIGURABLE))
+                goto fail1;
+            if ((result_desc.flags &
+                 (JS_PROP_GETSET | JS_PROP_WRITABLE)) == 0 &&
+                target_desc_ret &&
+                (target_desc.flags & JS_PROP_WRITABLE) != 0) {
+                /* proxy-missing-checks */
+            fail1:
+                js_free_desc(ctx, &result_desc);
+            fail:
+                JS_ThrowTypeError(ctx, "proxy: inconsistent getOwnPropertyDescriptor");
+                return -1;
+            }
         }
         ret = TRUE;
         if (pdesc) {
-            *pdesc = desc;
+            *pdesc = result_desc;
         } else {
-            js_free_desc(ctx, &desc);
+            js_free_desc(ctx, &result_desc);
         }
     }
     return ret;
@@ -42124,8 +42508,19 @@ static int js_proxy_define_own_property(JSContext *ctx, JSValueConst obj,
                 }
             }
         } else if (flags & JS_PROP_HAS_VALUE) {
-            if ((desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0 &&
+            if ((desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) ==
+                JS_PROP_WRITABLE && !(flags & JS_PROP_WRITABLE)) {
+                /* missing-proxy-check feature */
+                goto fail1;
+            } else if ((desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0 &&
                 !js_same_value(ctx, val, desc.value)) {
+                goto fail1;
+            }
+        }
+        if (flags & JS_PROP_HAS_WRITABLE) {
+            if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE |
+                               JS_PROP_WRITABLE)) == JS_PROP_WRITABLE) {
+                /* proxy-missing-checks */
             fail1:
                 js_free_desc(ctx, &desc);
             fail:
@@ -42143,7 +42538,7 @@ static int js_proxy_delete_property(JSContext *ctx, JSValueConst obj,
 {
     JSProxyData *s;
     JSValue method, ret, atom_val;
-    int res, res2;
+    int res, res2, is_extensible;
     JSValueConst args[2];
 
     s = get_proxy_method(ctx, &method, obj, JS_ATOM_deleteProperty);
@@ -42170,12 +42565,20 @@ static int js_proxy_delete_property(JSContext *ctx, JSValueConst obj,
         if (res2 < 0)
             return -1;
         if (res2) {
-            res2 = !(desc.flags & JS_PROP_CONFIGURABLE);
-            js_free_desc(ctx, &desc);
-            if (res2) {
+            if (!(desc.flags & JS_PROP_CONFIGURABLE))
+                goto fail;
+            is_extensible = JS_IsExtensible(ctx, s->target);
+            if (is_extensible < 0)
+                goto fail1;
+            if (!is_extensible) {
+                /* proxy-missing-checks */
+            fail:
                 JS_ThrowTypeError(ctx, "proxy: inconsistent deleteProperty");
+            fail1:
+                js_free_desc(ctx, &desc);
                 return -1;
             }
+            js_free_desc(ctx, &desc);
         }
     }
     return res;
@@ -42322,8 +42725,10 @@ static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
     s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
     if (!s)
         return JS_EXCEPTION;
-    if (!s->is_func)
+    if (!s->is_func) {
+        JS_FreeValue(ctx, method);
         return JS_ThrowTypeError(ctx, "not a function");
+    }
     if (JS_IsUndefined(method))
         return JS_Call(ctx, s->target, this_obj, argc, argv);
     arg_array = js_create_array(ctx, argc, argv);
@@ -43608,8 +44013,7 @@ static int js_create_resolving_functions(JSContext *ctx,
         s->presolved = sr;
         s->promise = JS_DupValue(ctx, promise);
         JS_SetOpaque(obj, s);
-        JS_DefinePropertyValue(ctx, obj, JS_ATOM_length, JS_NewInt32(ctx, 1),
-                               JS_PROP_CONFIGURABLE);
+        js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
         resolving_funcs[i] = obj;
     }
     js_promise_resolve_function_free_resolved(ctx->rt, sr);
@@ -44383,25 +44787,23 @@ static const JSCFunctionListEntry js_async_function_proto_funcs[] = {
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "AsyncFunction", JS_PROP_CONFIGURABLE ),
 };
 
-static JSValue js_async_from_async_iterator_unwrap(JSContext *ctx,
-                                                   JSValueConst this_val,
-                                                   int argc, JSValueConst *argv,
-                                                   int magic, JSValue *func_data)
+static JSValue js_async_from_sync_iterator_unwrap(JSContext *ctx,
+                                                  JSValueConst this_val,
+                                                  int argc, JSValueConst *argv,
+                                                  int magic, JSValue *func_data)
 {
-    return js_create_iterator_result(ctx, JS_DupValue(ctx, func_data[0]),
-                                     JS_ToBool(ctx, func_data[1]));
+    return js_create_iterator_result(ctx, JS_DupValue(ctx, argv[0]),
+                                     JS_ToBool(ctx, func_data[0]));
 }
 
-static JSValue js_async_from_async_iterator_unwrap_func_create(JSContext *ctx,
-                                                JSValueConst value,
-                                                BOOL done)
+static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
+                                                              BOOL done)
 {
-    JSValueConst func_data[2];
+    JSValueConst func_data[1];
 
-    func_data[0] = value;
-    func_data[1] = (JSValueConst)JS_NewBool(ctx, done);
-    return JS_NewCFunctionData(ctx, js_async_from_async_iterator_unwrap,
-                               0, 0, 2, func_data);
+    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
+    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
+                               1, 0, 1, func_data);
 }
 
 /* AsyncIteratorPrototype */
@@ -44539,7 +44941,8 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
             goto reject;
         }
 
-        resolve_reject[0] = js_async_from_async_iterator_unwrap_func_create(ctx, value, done);
+        resolve_reject[0] =
+            js_async_from_sync_iterator_unwrap_func_create(ctx, done);
         if (JS_IsException(resolve_reject[0])) {
             JS_FreeValue(ctx, value_wrapper_promise);
             goto fail;
@@ -46887,6 +47290,10 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     /* global properties */
     JS_SetPropertyFunctionList(ctx, ctx->global_obj, js_global_funcs,
                                countof(js_global_funcs));
+
+    JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_globalThis,
+                           JS_DupValue(ctx, ctx->global_obj),
+                           JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
 }
 
 /* Typed Arrays */
@@ -48283,7 +48690,7 @@ static int js_cmp_doubles(double x, double y)
     if (x > y)       return 1;
     if (x != 0)      return 0;
     if (signbit(x))  return signbit(y) ? 0 : -1;
-    else             return signbit(y) ? -1 : 0;
+    else             return signbit(y) ? 1 : 0;
 }
 
 static int js_TA_cmp_int8(const void *a, const void *b, void *opaque) {
@@ -48378,51 +48785,32 @@ static JSValue js_TA_get_float64(JSContext *ctx, const void *a) {
     return __JS_NewFloat64(ctx, *(const double *)a);
 }
 
-static void js_TA_swap_uint8(void *a, void *b) {
-    uint8_t x = *(uint8_t *)a;
-    *(uint8_t *)a = *(uint8_t *)b;
-    *(uint8_t *)b = x;
-}
-
-static void js_TA_swap_uint16(void *a, void *b) {
-    uint16_t x = *(uint16_t *)a;
-    *(uint16_t *)a = *(uint16_t *)b;
-    *(uint16_t *)b = x;
-}
-
-static void js_TA_swap_uint32(void *a, void *b) {
-    uint32_t x = *(uint32_t *)a;
-    *(uint32_t *)a = *(uint32_t *)b;
-    *(uint32_t *)b = x;
-}
-
-static void js_TA_swap_uint64(void *a, void *b) {
-    uint64_t x = *(uint64_t *)a;
-    *(uint64_t *)a = *(uint64_t *)b;
-    *(uint64_t *)b = x;
-}
-
 struct TA_sort_context {
     JSContext *ctx;
     int exception;
     JSValueConst arr;
     JSValueConst cmp;
     JSValue (*getfun)(JSContext *ctx, const void *a);
-    int (*cmpfun)(const void *a, const void *b, void *opaque);
-    void (*swapfun)(void *a, void *b);
+    void *array_ptr; /* cannot change unless the array is detached */
+    int elt_size;
 };
 
 static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
     struct TA_sort_context *psc = opaque;
     JSContext *ctx = psc->ctx;
+    uint32_t a_idx, b_idx;
     JSValueConst argv[2];
     JSValue res;
     int cmp;
 
     cmp = 0;
     if (!psc->exception) {
-        argv[0] = psc->getfun(ctx, a);
-        argv[1] = psc->getfun(ctx, b);
+        a_idx = *(uint32_t *)a;
+        b_idx = *(uint32_t *)b;
+        argv[0] = psc->getfun(ctx, psc->array_ptr +
+                              a_idx * (size_t)psc->elt_size);
+        argv[1] = psc->getfun(ctx, psc->array_ptr +
+                              b_idx * (size_t)(psc->elt_size));
         res = JS_Call(ctx, psc->cmp, JS_UNDEFINED, 2, argv);
         if (JS_IsException(res)) {
             psc->exception = 1;
@@ -48440,6 +48828,10 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
                 cmp = (val > 0) - (val < 0);
             }
         }
+        if (cmp == 0) {
+            /* make sort stable: compare array offsets */
+            cmp = (a_idx > b_idx) - (a_idx < b_idx);
+        }
         if (validate_typed_array(ctx, psc->arr) < 0) {
             psc->exception = 1;
         }
@@ -48454,9 +48846,10 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
                                    int argc, JSValueConst *argv)
 {
     JSObject *p;
-    int len, elt_size;
+    int len;
+    size_t elt_size;
     struct TA_sort_context tsc;
-    void *array_ptr, *array_copy = NULL, *array_org;
+    void *array_ptr;
     int (*cmpfun)(const void *a, const void *b, void *opaque);
 
     tsc.ctx = ctx;
@@ -48475,81 +48868,110 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
         switch (p->class_id) {
         case JS_CLASS_INT8_ARRAY:
             tsc.getfun = js_TA_get_int8;
-            tsc.cmpfun = js_TA_cmp_int8;
-            tsc.swapfun = js_TA_swap_uint8;
+            cmpfun = js_TA_cmp_int8;
             break;
         case JS_CLASS_UINT8C_ARRAY:
         case JS_CLASS_UINT8_ARRAY:
             tsc.getfun = js_TA_get_uint8;
-            tsc.cmpfun = js_TA_cmp_uint8;
-            tsc.swapfun = js_TA_swap_uint8;
+            cmpfun = js_TA_cmp_uint8;
             break;
         case JS_CLASS_INT16_ARRAY:
             tsc.getfun = js_TA_get_int16;
-            tsc.cmpfun = js_TA_cmp_int16;
-            tsc.swapfun = js_TA_swap_uint16;
+            cmpfun = js_TA_cmp_int16;
             break;
         case JS_CLASS_UINT16_ARRAY:
             tsc.getfun = js_TA_get_uint16;
-            tsc.cmpfun = js_TA_cmp_uint16;
-            tsc.swapfun = js_TA_swap_uint16;
+            cmpfun = js_TA_cmp_uint16;
             break;
         case JS_CLASS_INT32_ARRAY:
             tsc.getfun = js_TA_get_int32;
-            tsc.cmpfun = js_TA_cmp_int32;
-            tsc.swapfun = js_TA_swap_uint32;
+            cmpfun = js_TA_cmp_int32;
             break;
         case JS_CLASS_UINT32_ARRAY:
             tsc.getfun = js_TA_get_uint32;
-            tsc.cmpfun = js_TA_cmp_uint32;
-            tsc.swapfun = js_TA_swap_uint32;
+            cmpfun = js_TA_cmp_uint32;
             break;
 #ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT64_ARRAY:
             tsc.getfun = js_TA_get_int64;
-            tsc.cmpfun = js_TA_cmp_int64;
-            tsc.swapfun = js_TA_swap_uint64;
+            cmpfun = js_TA_cmp_int64;
             break;
         case JS_CLASS_BIG_UINT64_ARRAY:
             tsc.getfun = js_TA_get_uint64;
-            tsc.cmpfun = js_TA_cmp_uint64;
-            tsc.swapfun = js_TA_swap_uint64;
+            cmpfun = js_TA_cmp_uint64;
             break;
 #endif
         case JS_CLASS_FLOAT32_ARRAY:
             tsc.getfun = js_TA_get_float32;
-            tsc.cmpfun = js_TA_cmp_float32;
-            tsc.swapfun = js_TA_swap_uint32;
+            cmpfun = js_TA_cmp_float32;
             break;
         case JS_CLASS_FLOAT64_ARRAY:
             tsc.getfun = js_TA_get_float64;
-            tsc.cmpfun = js_TA_cmp_float64;
-            tsc.swapfun = js_TA_swap_uint64;
+            cmpfun = js_TA_cmp_float64;
             break;
         default:
             abort();
         }
-        array_ptr = array_org = p->u.array.u.ptr;
+        array_ptr = p->u.array.u.ptr;
         elt_size = 1 << typed_array_size_log2(p->class_id);
-        cmpfun = tsc.cmpfun;
         if (!JS_IsUndefined(tsc.cmp)) {
-            /* must copy internal array if user defined comparison function to
-               avoid crash if the array gets reallocated by the compare function */
-            array_copy = js_malloc(ctx, len * elt_size);
-            if (array_copy == NULL)
+            uint32_t *array_idx;
+            void *array_tmp;
+            size_t i, j;
+            
+            /* XXX: a stable sort would use less memory */
+            array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
+            if (!array_idx)
+                return JS_EXCEPTION;
+            for(i = 0; i < len; i++)
+                array_idx[i] = i;
+            tsc.array_ptr = array_ptr;
+            tsc.elt_size = elt_size;
+            rqsort(array_idx, len, sizeof(array_idx[0]),
+                   js_TA_cmp_generic, &tsc);
+            if (tsc.exception)
+                goto fail;
+            array_tmp = js_malloc(ctx, len * elt_size);
+            if (!array_tmp) {
+            fail:
+                js_free(ctx, array_idx);
+                return JS_EXCEPTION;
+            }
+            memcpy(array_tmp, array_ptr, len * elt_size);
+            switch(elt_size) {
+            case 1:
+                for(i = 0; i < len; i++) {
+                    j = array_idx[i];
+                    ((uint8_t *)array_ptr)[i] = ((uint8_t *)array_tmp)[j];
+                }
+                break;
+            case 2:
+                for(i = 0; i < len; i++) {
+                    j = array_idx[i];
+                    ((uint16_t *)array_ptr)[i] = ((uint16_t *)array_tmp)[j];
+                }
+                break;
+            case 4:
+                for(i = 0; i < len; i++) {
+                    j = array_idx[i];
+                    ((uint32_t *)array_ptr)[i] = ((uint32_t *)array_tmp)[j];
+                }
+                break;
+            case 8:
+                for(i = 0; i < len; i++) {
+                    j = array_idx[i];
+                    ((uint64_t *)array_ptr)[i] = ((uint64_t *)array_tmp)[j];
+                }
+                break;
+            default:
+                abort();
+            }
+            js_free(ctx, array_tmp);
+            js_free(ctx, array_idx);
+        } else {
+            rqsort(array_ptr, len, elt_size, cmpfun, &tsc);
+            if (tsc.exception)
                 return JS_EXCEPTION;
-            array_ptr = memcpy(array_copy, array_ptr, len * elt_size);
-            cmpfun = js_TA_cmp_generic;
-        }
-        rqsort(array_ptr, len, elt_size, cmpfun, &tsc);
-        if (tsc.exception) {
-            js_free(ctx, array_copy);
-            return JS_EXCEPTION;
-        }
-        if (array_ptr == array_copy) {
-            if (array_org == p->u.array.u.ptr)
-                memcpy(array_org, array_copy, len * elt_size);
-            js_free(ctx, array_copy);
         }
     }
     return JS_DupValue(ctx, this_val);
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 5936032725..206516b04a 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -28,6 +28,10 @@
 #include <stdio.h>
 #include <stdint.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #if defined(__GNUC__) || defined(__clang__)
 #define js_likely(x)          __builtin_expect(!!(x), 1)
 #define js_unlikely(x)        __builtin_expect(!!(x), 0)
@@ -201,13 +205,8 @@ typedef struct JSValue {
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
 
-#ifdef __cplusplus
-#define JS_MKVAL(tag, val) JSValue{ JSValueUnion{.int32 = val}, tag }
-#define JS_MKPTR(tag, p) JSValue{ JSValueUnion{.ptr = p}, tag }
-#else
-#define JS_MKVAL(tag, val) (JSValue){ .u.int32 = val, tag }
-#define JS_MKPTR(tag, p) (JSValue){ .u.ptr = p, tag }
-#endif
+#define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
+#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
 
 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
 
@@ -280,7 +279,10 @@ static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
 
 #define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
 #define JS_EVAL_FLAG_STRIP    (1 << 4) /* force 'strip' mode */
-#define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5) /* internal use */
+/* compile but do not run. The result is an object with a
+   JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
+   with JS_EvalFunction(). */
+#define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5)
 
 typedef JSValue JSCFunction(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
@@ -692,11 +694,10 @@ JSValue JS_CallConstructor(JSContext *ctx, JSValueConst func_obj,
 JSValue JS_CallConstructor2(JSContext *ctx, JSValueConst func_obj,
                             JSValueConst new_target,
                             int argc, JSValueConst *argv);
+JS_BOOL JS_DetectModule(const char *input, size_t input_len);
 JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
                 const char *filename, int eval_flags);
-#define JS_EVAL_BINARY_LOAD_ONLY (1 << 0) /* only load the module */
-JSValue JS_EvalBinary(JSContext *ctx,
-                      const uint8_t *buf, size_t buf_len, int flags);
+JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);
 JSValue JS_GetGlobalObject(JSContext *ctx);
 int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj);
 int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
@@ -746,6 +747,9 @@ typedef JSModuleDef *JSModuleLoaderFunc(JSContext *ctx,
 void JS_SetModuleLoaderFunc(JSRuntime *rt,
                             JSModuleNormalizeFunc *module_normalize,
                             JSModuleLoaderFunc *module_loader, void *opaque);
+/* return the import.meta object of a module */
+JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m);
+JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m);
 
 /* JS Job support */
 
@@ -764,7 +768,9 @@ uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
 #define JS_READ_OBJ_ROM_DATA  (1 << 1) /* avoid duplicating 'buf' data */
 JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                       int flags);
-JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj, JSValueConst this_obj);
+/* load the dependencies of the module 'obj'. Useful when JS_ReadObject()
+   returns a module. */
+int JS_ResolveModule(JSContext *ctx, JSValueConst obj);
 
 /* C function definition */
 typedef enum JSCFunctionEnum {  /* XXX: should rename for namespace isolation */
@@ -900,4 +906,8 @@ int JS_SetModuleExportList(JSContext *ctx, JSModuleDef *m,
 #undef js_unlikely
 #undef js_force_inline
 
+#ifdef __cplusplus
+} /* extern "C" { */
+#endif
+
 #endif /* QUICKJS_H */

From d9538a75b47310961469b276cca74474ffd9ad53 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 12 Sep 2019 09:24:37 +0000
Subject: [PATCH 024/185] globalThis

---
 main.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/main.cpp b/main.cpp
index 186d65ed4f..13e163cf36 100644
--- a/main.cpp
+++ b/main.cpp
@@ -110,9 +110,9 @@ int main(int argc, char ** argv)
     const char * str = "import * as std from 'std';\n"
                        "import * as os from 'os';\n"
                        "import * as test from 'test';\n"
-                       "std.global.std = std;\n"
-                       "std.global.test = test;\n"
-                       "std.global.os = os;\n";
+                       "globalThis.std = std;\n"
+                       "globalThis.test = test;\n"
+                       "globalThis.os = os;\n";
     context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
     const char * filename = argv[1];
 

From 5c026b98e93a5e9c0098f63797bd82b545182840 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 19 Sep 2019 06:24:48 +0000
Subject: [PATCH 025/185] updated quickjs to 2019-09-18

---
 quickjs/VERSION          |   2 +-
 quickjs/cplusplus.patch  |  54 ------
 quickjs/cutils.h         |   1 +
 quickjs/libbf.c          |   5 +-
 quickjs/libregexp.c      |   2 +-
 quickjs/libunicode.c     |   2 +-
 quickjs/quickjs-libc.c   | 351 +++++++++++++++++++++++++++++++++++++--
 quickjs/quickjs-opcode.h |   4 +-
 quickjs/quickjs.c        | 286 ++++++++++++++++++++-----------
 quickjs/quickjs.h        |   1 +
 10 files changed, 531 insertions(+), 177 deletions(-)
 delete mode 100644 quickjs/cplusplus.patch

diff --git a/quickjs/VERSION b/quickjs/VERSION
index bbe29cb5e2..80c17d9faf 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-09-01
+2019-09-18
diff --git a/quickjs/cplusplus.patch b/quickjs/cplusplus.patch
deleted file mode 100644
index 159dd92f88..0000000000
--- a/quickjs/cplusplus.patch
+++ /dev/null
@@ -1,54 +0,0 @@
-diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
-index 60cd0e7..4cb62b5 100644
---- a/quickjs/quickjs.h
-+++ b/quickjs/quickjs.h
-@@ -201,8 +201,13 @@ typedef struct JSValue {
- #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
- #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
- 
-+#ifdef __cplusplus
-+#define JS_MKVAL(tag, val) JSValue{ JSValueUnion{.int32 = val}, tag }
-+#define JS_MKPTR(tag, p) JSValue{ JSValueUnion{.ptr = p}, tag }
-+#else
- #define JS_MKVAL(tag, val) (JSValue){ .u.int32 = val, tag }
- #define JS_MKPTR(tag, p) (JSValue){ .u.ptr = p, tag }
-+#endif
- 
- #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
- 
-@@ -555,7 +560,7 @@ void __JS_FreeValue(JSContext *ctx, JSValue v);
- static inline void JS_FreeValue(JSContext *ctx, JSValue v)
- {
-     if (JS_VALUE_HAS_REF_COUNT(v)) {
--        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
-+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         if (--p->ref_count <= 0) {
-             __JS_FreeValue(ctx, v);
-         }
-@@ -565,7 +570,7 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v);
- static inline void JS_FreeValueRT(JSRuntime *rt, JSValue v)
- {
-     if (JS_VALUE_HAS_REF_COUNT(v)) {
--        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
-+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         if (--p->ref_count <= 0) {
-             __JS_FreeValueRT(rt, v);
-         }
-@@ -575,7 +580,7 @@ static inline void JS_FreeValueRT(JSRuntime *rt, JSValue v)
- static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
- {
-     if (JS_VALUE_HAS_REF_COUNT(v)) {
--        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
-+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         p->ref_count++;
-     }
-     return (JSValue)v;
-@@ -584,7 +589,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
- static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
- {
-     if (JS_VALUE_HAS_REF_COUNT(v)) {
--        JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
-+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         p->ref_count++;
-     }
-     return (JSValue)v;
diff --git a/quickjs/cutils.h b/quickjs/cutils.h
index fdbf44a881..26c68ee617 100644
--- a/quickjs/cutils.h
+++ b/quickjs/cutils.h
@@ -35,6 +35,7 @@
 #define unlikely(x)     __builtin_expect(!!(x), 0)
 #define force_inline inline __attribute__((always_inline))
 #define no_inline __attribute__((noinline))
+#define __maybe_unused __attribute__((unused))
 
 #define xglue(x, y) x ## y
 #define glue(x, y) xglue(x, y)
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index cbabf9525d..17418097fa 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -41,7 +41,6 @@
 #define USE_FFT_MUL
 
 //#define inline __attribute__((always_inline))
-#define unused __attribute__((unused))
 
 #ifdef __AVX2__
 #define FFT_MUL_THRESHOLD 100 /* in limbs of the smallest factor */
@@ -613,7 +612,7 @@ int bf_round(bf_t *r, limb_t prec, bf_flags_t flags)
 }
 
 /* for debugging */
-static unused void dump_limbs(const char *str, const limb_t *tab, limb_t n)
+static __maybe_unused void dump_limbs(const char *str, const limb_t *tab, limb_t n)
 {
     limb_t i;
     printf("%s: len=%" PRId_LIMB "\n", str, n);
@@ -1570,7 +1569,7 @@ int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     return ret;
 }
 
-static unused inline limb_t mul_mod(limb_t a, limb_t b, limb_t m)
+static __maybe_unused inline limb_t mul_mod(limb_t a, limb_t b, limb_t m)
 {
     dlimb_t t;
     t = (dlimb_t)a * (dlimb_t)b;
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index ad1e6bf065..4425ce55b8 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -269,7 +269,7 @@ static int cr_canonicalize(CharRange *cr)
 }
 
 #ifdef DUMP_REOP
-static __attribute__((unused)) void lre_dump_bytecode(const uint8_t *buf,
+static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
                                                      int buf_len)
 {
     int pos, len, opcode, bc_len, re_flags, i;
diff --git a/quickjs/libunicode.c b/quickjs/libunicode.c
index 6fe6945d5a..96ff002072 100644
--- a/quickjs/libunicode.c
+++ b/quickjs/libunicode.c
@@ -271,7 +271,7 @@ BOOL lre_is_case_ignorable(uint32_t c)
 
 /* character range */
 
-static __attribute__((unused)) void cr_dump(CharRange *cr)
+static __maybe_unused void cr_dump(CharRange *cr)
 {
     int i;
     for(i = 0; i < cr->len; i++)
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 37da67b97b..eba52cfd10 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -44,6 +44,7 @@
 #include <dlfcn.h>
 #include <termios.h>
 #include <sys/ioctl.h>
+#include <sys/wait.h>
 #if defined(__APPLE__)
 typedef sig_t sighandler_t;
 #endif
@@ -59,7 +60,7 @@ static void js_std_dbuf_init(JSContext *ctx, DynBuf *s)
 }
 
 /* TODO:
-   - add exec() wrapper
+   - add worker
    - add minimal VT100 emulation for win32
    - add socket calls
 */
@@ -434,7 +435,7 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
                               JS_BOOL use_realpath, JS_BOOL is_main)
 {
     JSModuleDef *m;
-    char buf[PATH_MAX + 16], *res;
+    char buf[PATH_MAX + 16];
     JSValue meta_obj;
     JSAtom module_name_atom;
     const char *module_name;
@@ -449,17 +450,20 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
         return -1;
     if (!strchr(module_name, ':')) {
         strcpy(buf, "file://");
+#if !defined(_WIN32)
         /* realpath() cannot be used with modules compiled with qjsc
            because the corresponding module source code is not
            necessarily present */
         if (use_realpath) {
-            res = realpath(module_name, buf + strlen(buf));
+            char *res = realpath(module_name, buf + strlen(buf));
             if (!res) {
                 JS_ThrowTypeError(ctx, "realpath failure");
                 JS_FreeCString(ctx, module_name);
                 return -1;
             }
-        } else {
+        } else
+#endif
+        {
             pstrcat(buf, sizeof(buf), module_name);
         }
     } else {
@@ -720,6 +724,33 @@ static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+static JSValue js_std_fdopen(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    const char *mode;
+    FILE *f;
+    int fd;
+
+    if (JS_ToInt32(ctx, &fd, argv[0]))
+        return JS_EXCEPTION;
+    mode = JS_ToCString(ctx, argv[1]);
+    if (!mode)
+        goto fail;
+    if (mode[strspn(mode, "rwa+")] != '\0') {
+        js_std_throw_errno(ctx, EINVAL);
+        goto fail;
+    }
+
+    f = fdopen(fd, mode);
+    JS_FreeCString(ctx, mode);
+    if (!f)
+        return js_std_throw_errno(ctx, errno);
+    return js_new_std_file(ctx, f, TRUE, FALSE);
+ fail:
+    JS_FreeCString(ctx, mode);
+    return JS_EXCEPTION;
+}
+
 static JSValue js_std_tmpfile(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv)
 {
@@ -1036,6 +1067,21 @@ static int http_get_status(const char *buf)
     return atoi(p);
 }
 
+static int get_bool_option(JSContext *ctx, BOOL *pbool,
+                           JSValueConst obj,
+                           const char *option)
+{
+    JSValue val;
+    val = JS_GetPropertyStr(ctx, obj, option);
+    if (JS_IsException(val))
+        return -1;
+    if (!JS_IsUndefined(val)) {
+        *pbool = JS_ToBool(ctx, val);
+    }
+    JS_FreeValue(ctx, val);
+    return 0;
+}
+
 static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
@@ -1046,7 +1092,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     char *buf; 
     size_t i, len;
     int c, status;
-    JSValue val, response = JS_UNDEFINED, ret_obj;
+    JSValue response = JS_UNDEFINED, ret_obj;
     JSValueConst options_obj;
     FILE *f;
     BOOL binary_flag, full_flag;
@@ -1061,23 +1107,16 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     if (argc >= 2) {
         options_obj = argv[1];
 
-        val = JS_GetPropertyStr(ctx, options_obj, "binary");
-        if (JS_IsException(val))
-            goto fail_opt;
-        binary_flag = JS_ToBool(ctx, val);
-        JS_FreeValue(ctx, val);
+        if (get_bool_option(ctx, &binary_flag, options_obj, "binary"))
+            goto fail_obj;
 
-        val = JS_GetPropertyStr(ctx, options_obj, "full");
-        if (JS_IsException(val)) {
-        fail_opt:
+        if (get_bool_option(ctx, &full_flag, options_obj, "full")) {
+        fail_obj:
             JS_FreeCString(ctx, url);
             return JS_EXCEPTION;
         }
-        full_flag = JS_ToBool(ctx, val);
-        JS_FreeValue(ctx, val);
     }
     
-
     js_std_dbuf_init(ctx, &cmd_buf);
     dbuf_printf(&cmd_buf, "%s ''", URL_GET_PROGRAM);
     len = strlen(url);
@@ -1203,6 +1242,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
     JS_CFUNC_DEF("popen", 2, js_std_popen ),
+    JS_CFUNC_DEF("fdopen", 2, js_std_fdopen ),
     JS_CFUNC_DEF("tmpfile", 0, js_std_tmpfile ),
     JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 0 ),
     JS_CFUNC_DEF("printf", 1, js_std_printf ),
@@ -1971,6 +2011,8 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
     return make_string_error(ctx, buf, err);
 }
 
+#if !defined(_WIN32)
+
 /* return [path, errorcode] */
 static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv)
@@ -2210,6 +2252,260 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
     return js_os_return(ctx, ret);
 }
 
+/* exec(args[, options]) -> exitcode */
+static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    JSValueConst options, args = argv[0];
+    JSValue val, ret_val;
+    const char **exec_argv, *file = NULL, *str, *cwd = NULL;
+    uint32_t exec_argc, i;
+    int ret, pid, status;
+    BOOL block_flag = TRUE, use_path = TRUE;
+    static const char *std_name[3] = { "stdin", "stdout", "stderr" };
+    int std_fds[3];
+    
+    val = JS_GetPropertyStr(ctx, args, "length");
+    if (JS_IsException(val))
+        return JS_EXCEPTION;
+    ret = JS_ToUint32(ctx, &exec_argc, val);
+    JS_FreeValue(ctx, val);
+    if (ret)
+        return JS_EXCEPTION;
+    /* arbitrary limit to avoid overflow */
+    if (exec_argc < 1 || exec_argc > 65535) {
+        return JS_ThrowTypeError(ctx, "invalid number of arguments");
+    }
+    exec_argv = js_mallocz(ctx, sizeof(exec_argv[0]) * (exec_argc + 1));
+    if (!exec_argv)
+        return JS_EXCEPTION;
+    for(i = 0; i < exec_argc; i++) {
+        val = JS_GetPropertyUint32(ctx, args, i);
+        if (JS_IsException(val))
+            goto exception;
+        str = JS_ToCString(ctx, val);
+        JS_FreeValue(ctx, val);
+        if (!str)
+            goto exception;
+        exec_argv[i] = str;
+    }
+    exec_argv[exec_argc] = NULL;
+
+    for(i = 0; i < 3; i++)
+        std_fds[i] = i;
+    
+    /* get the options, if any */
+    if (argc >= 2) {
+        options = argv[1];
+
+        if (get_bool_option(ctx, &block_flag, options, "block"))
+            goto exception;
+        if (get_bool_option(ctx, &use_path, options, "usePath"))
+            goto exception;
+        
+        val = JS_GetPropertyStr(ctx, options, "file");
+        if (JS_IsException(val))
+            goto exception;
+        if (!JS_IsUndefined(val)) {
+            file = JS_ToCString(ctx, val);
+            JS_FreeValue(ctx, val);
+            if (!file)
+                goto exception;
+        }
+
+        val = JS_GetPropertyStr(ctx, options, "cwd");
+        if (JS_IsException(val))
+            goto exception;
+        if (!JS_IsUndefined(val)) {
+            cwd = JS_ToCString(ctx, val);
+            JS_FreeValue(ctx, val);
+            if (!cwd)
+                goto exception;
+        }
+
+        /* stdin/stdout/stderr handles */
+        for(i = 0; i < 3; i++) {
+            val = JS_GetPropertyStr(ctx, options, std_name[i]);
+            if (JS_IsException(val))
+                goto exception;
+            if (!JS_IsUndefined(val)) {
+                int fd;
+                ret = JS_ToInt32(ctx, &fd, val);
+                JS_FreeValue(ctx, val);
+                if (ret)
+                    goto exception;
+                std_fds[i] = fd;
+            }
+        }
+    }
+
+    pid = fork();
+    if (pid < 0) {
+        JS_ThrowTypeError(ctx, "fork error");
+        goto exception;
+    }
+    if (pid == 0) {
+        /* child */
+        int fd_max = sysconf(_SC_OPEN_MAX);
+
+        /* remap the stdin/stdout/stderr handles if necessary */
+        for(i = 0; i < 3; i++) {
+            if (std_fds[i] != i) {
+                if (dup2(std_fds[i], i) < 0)
+                    _exit(127);
+            }
+        }
+
+        for(i = 3; i < fd_max; i++)
+            close(i);
+        if (cwd) {
+            if (chdir(cwd) < 0)
+                _exit(127);
+        }
+        if (!file)
+            file = exec_argv[0];
+        if (use_path)
+            ret = execvp(file, (char **)exec_argv);
+        else
+            ret = execv(file, (char **)exec_argv);
+        _exit(127);
+    }
+    /* parent */
+    if (block_flag) {
+        for(;;) {
+            ret = waitpid(pid, &status, 0);
+            if (ret == pid) {
+                if (WIFEXITED(status)) {
+                    ret = WEXITSTATUS(status);
+                    break;
+                } else if (WIFSIGNALED(status)) {
+                    ret = -WTERMSIG(status);
+                    break;
+                }
+            }
+        }
+    } else {
+        ret = pid;
+    }
+    ret_val = JS_NewInt32(ctx, ret);
+ done:
+    JS_FreeCString(ctx, file);
+    JS_FreeCString(ctx, cwd);
+    for(i = 0; i < exec_argc; i++)
+        JS_FreeCString(ctx, exec_argv[i]);
+    js_free(ctx, exec_argv);
+    return ret_val;
+ exception:
+    ret_val = JS_EXCEPTION;
+    goto done;
+}
+
+/* waitpid(pid, block) -> [pid, status] */
+static JSValue js_os_waitpid(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    int pid, status, options, ret;
+    JSValue obj;
+    
+    if (JS_ToInt32(ctx, &pid, argv[0]))
+        return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &options, argv[1]))
+        return JS_EXCEPTION;
+
+    ret = waitpid(pid, &status, options);
+    if (ret < 0) {
+        ret = -errno;
+        status = 0;
+    }
+
+    obj = JS_NewArray(ctx);
+    if (JS_IsException(obj))
+        return obj;
+    JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, ret),
+                                 JS_PROP_C_W_E);
+    JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
+                                 JS_PROP_C_W_E);
+    return obj;
+}    
+
+/* pipe() -> [read_fd, write_fd] or null if error */
+static JSValue js_os_pipe(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    int pipe_fds[2], ret;
+    JSValue obj;
+    
+    ret = pipe(pipe_fds);
+    if (ret < 0)
+        return JS_NULL;
+    obj = JS_NewArray(ctx);
+    if (JS_IsException(obj))
+        return obj;
+    JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, pipe_fds[0]),
+                                 JS_PROP_C_W_E);
+    JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, pipe_fds[1]),
+                                 JS_PROP_C_W_E);
+    return obj;
+}
+
+/* kill(pid, sig) */
+static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    int pid, sig, ret;
+    
+    if (JS_ToInt32(ctx, &pid, argv[0]))
+        return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &sig, argv[1]))
+        return JS_EXCEPTION;
+    ret = kill(pid, sig);
+    return js_os_return(ctx, ret);
+}
+
+/* sleep(delay_ms) */
+static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    int64_t delay;
+    struct timespec ts;
+    int ret;
+    
+    if (JS_ToInt64(ctx, &delay, argv[0]))
+        return JS_EXCEPTION;
+    ts.tv_sec = delay / 1000;
+    ts.tv_nsec = (delay % 1000) * 1000000;
+    ret = nanosleep(&ts, NULL);
+    return js_os_return(ctx, ret);
+}
+
+/* dup(fd) */
+static JSValue js_os_dup(JSContext *ctx, JSValueConst this_val,
+                         int argc, JSValueConst *argv)
+{
+    int fd, ret;
+    
+    if (JS_ToInt32(ctx, &fd, argv[0]))
+        return JS_EXCEPTION;
+    ret = dup(fd);
+    return js_os_return(ctx, ret);
+}
+
+/* dup2(fd) */
+static JSValue js_os_dup2(JSContext *ctx, JSValueConst this_val,
+                         int argc, JSValueConst *argv)
+{
+    int fd, fd2, ret;
+    
+    if (JS_ToInt32(ctx, &fd, argv[0]))
+        return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &fd2, argv[1]))
+        return JS_EXCEPTION;
+    ret = dup2(fd, fd2);
+    return js_os_return(ctx, ret);
+}
+
+#endif /* !_WIN32 */
+
 #if defined(_WIN32)
 #define OS_PLATFORM "win32"
 #elif defined(__APPLE__)
@@ -2253,10 +2549,24 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     OS_FLAG(SIGILL),
     OS_FLAG(SIGSEGV),
     OS_FLAG(SIGTERM),
+#if !defined(_WIN32)
+    OS_FLAG(SIGQUIT),
+    OS_FLAG(SIGPIPE),
+    OS_FLAG(SIGALRM),
+    OS_FLAG(SIGUSR1),
+    OS_FLAG(SIGUSR2),
+    OS_FLAG(SIGCHLD),
+    OS_FLAG(SIGCONT),
+    OS_FLAG(SIGSTOP),
+    OS_FLAG(SIGTSTP),
+    OS_FLAG(SIGTTIN),
+    OS_FLAG(SIGTTOU),
+#endif
     JS_CFUNC_DEF("setTimeout", 2, js_os_setTimeout ),
     JS_CFUNC_DEF("clearTimeout", 1, js_os_clearTimeout ),
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
     JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
+#if !defined(_WIN32)
     JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
     JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
     JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
@@ -2276,6 +2586,15 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_CFUNC_DEF("readlink", 1, js_os_readlink ),
     JS_CFUNC_DEF("readdir", 1, js_os_readdir ),
     JS_CFUNC_DEF("utimes", 3, js_os_utimes ),
+    JS_CFUNC_DEF("exec", 1, js_os_exec ),
+    JS_CFUNC_DEF("waitpid", 2, js_os_waitpid ),
+    OS_FLAG(WNOHANG),
+    JS_CFUNC_DEF("pipe", 0, js_os_pipe ),
+    JS_CFUNC_DEF("kill", 2, js_os_kill ),
+    JS_CFUNC_DEF("sleep", 1, js_os_sleep ),
+    JS_CFUNC_DEF("dup", 1, js_os_dup ),
+    JS_CFUNC_DEF("dup2", 2, js_os_dup2 ),
+#endif
 };
 
 static int js_os_init(JSContext *ctx, JSModuleDef *m)
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 0981453666..910bb75c05 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -39,6 +39,7 @@ FMT(i16)
 FMT(label16)
 FMT(npop)
 FMT(npopx)
+FMT(npop_u16)
 FMT(loc)
 FMT(arg)
 FMT(var_ref)
@@ -114,7 +115,8 @@ DEF(      add_brand, 1, 2, 0, none) /* this_obj home_obj -> */
 DEF(   return_async, 1, 1, 0, none)
 DEF(          throw, 1, 1, 0, none)
 DEF(      throw_var, 6, 0, 0, atom_u8)
-DEF(           eval, 3, 1, 1, u16)
+DEF(           eval, 5, 1, 1, npop_u16) /* func args... -> ret_val */
+DEF(     apply_eval, 3, 2, 1, u16) /* func array -> ret_eval */
 DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern and a
                                        bytecode string */
 DEF( get_super_ctor, 1, 1, 1, none)
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index d5c1c8342d..5d833b0432 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -343,6 +343,7 @@ struct JSContext {
     JSValue async_iterator_proto;
     JSValue array_proto_values;
     JSValue throw_type_error;
+    JSValue eval_obj;
 
     JSValue global_obj; /* global object */
     JSValue global_var_obj; /* contains the global let/const definitions */
@@ -854,18 +855,18 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
 static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
                              JSValueConst val, int flags, int scope_idx);
 JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
-static __attribute__((unused)) void JS_DumpAtoms(JSRuntime *rt);
-static __attribute__((unused)) void JS_DumpString(JSRuntime *rt,
+static __maybe_unused void JS_DumpAtoms(JSRuntime *rt);
+static __maybe_unused void JS_DumpString(JSRuntime *rt,
                                                   const JSString *p);
-static __attribute__((unused)) void JS_DumpObjectHeader(JSRuntime *rt);
-static __attribute__((unused)) void JS_DumpObject(JSRuntime *rt, JSObject *p);
-static __attribute__((unused)) void JS_DumpValueShort(JSRuntime *rt,
+static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt);
+static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p);
+static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
                                                       JSValueConst val);
-static __attribute__((unused)) void JS_DumpValue(JSContext *ctx, JSValueConst val);
-static __attribute__((unused)) void JS_PrintValue(JSContext *ctx,
+static __maybe_unused void JS_DumpValue(JSContext *ctx, JSValueConst val);
+static __maybe_unused void JS_PrintValue(JSContext *ctx,
                                                   const char *str,
                                                   JSValueConst val);
-static __attribute__((unused)) void JS_DumpShapes(JSRuntime *rt);
+static __maybe_unused void JS_DumpShapes(JSRuntime *rt);
 static JSValue js_function_apply(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv, int magic);
 static void js_array_finalizer(JSRuntime *rt, JSValue val);
@@ -1023,6 +1024,9 @@ static __exception int js_get_length32(JSContext *ctx, uint32_t *pres,
                                        JSValueConst obj);
 static __exception int js_get_length64(JSContext *ctx, int64_t *pres,
                                        JSValueConst obj);
+static void free_arg_list(JSContext *ctx, JSValue *tab, uint32_t len);
+static JSValue *build_arg_list(JSContext *ctx, uint32_t *plen,
+                               JSValueConst array_arg);
 static BOOL js_get_fast_array(JSContext *ctx, JSValueConst obj,
                               JSValue **arrpp, uint32_t *countp);
 static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
@@ -1033,7 +1037,6 @@ static void js_c_function_data_mark(JSRuntime *rt, JSValueConst val,
 static JSValue js_c_function_data_call(JSContext *ctx, JSValueConst func_obj,
                                        JSValueConst this_val,
                                        int argc, JSValueConst *argv);
-static JSAtom js_value_to_atom(JSContext *ctx, JSValueConst val);
 static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
@@ -1945,6 +1948,7 @@ void JS_FreeContext(JSContext *ctx)
     JS_FreeValue(ctx, ctx->global_var_obj);
 
     JS_FreeValue(ctx, ctx->throw_type_error);
+    JS_FreeValue(ctx, ctx->eval_obj);
 
     JS_FreeValue(ctx, ctx->array_proto_values);
     for(i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
@@ -2133,7 +2137,7 @@ static uint32_t hash_string(const JSString *str, uint32_t h)
     return h;
 }
 
-static __attribute__((unused)) void JS_DumpString(JSRuntime *rt,
+static __maybe_unused void JS_DumpString(JSRuntime *rt,
                                                   const JSString *p)
 {
     int i, c, sep;
@@ -2165,7 +2169,7 @@ static __attribute__((unused)) void JS_DumpString(JSRuntime *rt,
     putchar(sep);
 }
 
-static __attribute__((unused)) void JS_DumpAtoms(JSRuntime *rt)
+static __maybe_unused void JS_DumpAtoms(JSRuntime *rt)
 {
     JSAtomStruct *p;
     int h, i;
@@ -2918,7 +2922,7 @@ static BOOL JS_AtomSymbolHasDescription(JSContext *ctx, JSAtom v)
             !(p->len == 0 && p->is_wide_char != 0));
 }
 
-static __attribute__((unused)) void print_atom(JSContext *ctx, JSAtom atom)
+static __maybe_unused void print_atom(JSContext *ctx, JSAtom atom)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
     const char *p;
@@ -4234,7 +4238,7 @@ static JSShape *find_hashed_shape_prop(JSRuntime *rt, JSShape *sh,
     return NULL;
 }
 
-static __attribute__((unused)) void JS_DumpShape(JSRuntime *rt, int i, JSShape *sh)
+static __maybe_unused void JS_DumpShape(JSRuntime *rt, int i, JSShape *sh)
 {
     char atom_buf[ATOM_GET_STR_BUF_SIZE];
     int j;
@@ -4250,7 +4254,7 @@ static __attribute__((unused)) void JS_DumpShape(JSRuntime *rt, int i, JSShape *
     printf("\n");
 }
 
-static __attribute__((unused)) void JS_DumpShapes(JSRuntime *rt)
+static __maybe_unused void JS_DumpShapes(JSRuntime *rt)
 {
     int i;
     JSShape *sh;
@@ -5163,6 +5167,7 @@ static void mark_context(JSRuntime *rt, JSContext *ctx)
         JS_MarkValue(rt, ctx->native_error_proto[i]);
 
     JS_MarkValue(rt, ctx->throw_type_error);
+    JS_MarkValue(rt, ctx->eval_obj);
     JS_MarkValue(rt, ctx->global_obj);
     JS_MarkValue(rt, ctx->global_var_obj);
 }
@@ -7214,7 +7219,7 @@ static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val)
 }
 
 /* return JS_ATOM_NULL in case of exception */
-static JSAtom js_value_to_atom(JSContext *ctx, JSValueConst val)
+JSAtom JS_ValueToAtom(JSContext *ctx, JSValueConst val)
 {
     JSAtom atom;
     uint32_t tag;
@@ -7288,7 +7293,7 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
         }
     } else {
     slow_path:
-        atom = js_value_to_atom(ctx, prop);
+        atom = JS_ValueToAtom(ctx, prop);
         JS_FreeValue(ctx, prop);
         if (unlikely(atom == JS_ATOM_NULL))
             return JS_EXCEPTION;
@@ -8121,7 +8126,7 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
         JSAtom atom;
         int ret;
     slow_path:
-        atom = js_value_to_atom(ctx, prop);
+        atom = JS_ValueToAtom(ctx, prop);
         JS_FreeValue(ctx, prop);
         if (unlikely(atom == JS_ATOM_NULL)) {
             JS_FreeValue(ctx, val);
@@ -8680,7 +8685,7 @@ int JS_DefinePropertyValueValue(JSContext *ctx, JSValueConst this_obj,
 {
     JSAtom atom;
     int ret;
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     JS_FreeValue(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL)) {
         JS_FreeValue(ctx, val);
@@ -8778,7 +8783,7 @@ static int JS_DefineObjectNameComputed(JSContext *ctx, JSValueConst obj,
         !js_object_has_name(ctx, obj)) {
         JSAtom prop;
         JSValue name_str;
-        prop = js_value_to_atom(ctx, str);
+        prop = JS_ValueToAtom(ctx, str);
         if (prop == JS_ATOM_NULL)
             return -1;
         name_str = js_get_function_name(ctx, prop);
@@ -9020,12 +9025,18 @@ static int JS_SetGlobalVar(JSContext *ctx, JSAtom prop, JSValue val,
    flags can be 0, JS_PROP_THROW or JS_PROP_THROW_STRICT */
 int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags)
 {
-    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
-        JSObject *p = JS_VALUE_GET_OBJ(obj);
-        int res = delete_property(ctx, p, prop);
-        if (res != FALSE)
-            return res;
-    }
+    JSValue obj1;
+    JSObject *p;
+    int res;
+    
+    obj1 = JS_ToObject(ctx, obj);
+    if (JS_IsException(obj1))
+        return -1;
+    p = JS_VALUE_GET_OBJ(obj1);
+    res = delete_property(ctx, p, prop);
+    JS_FreeValue(ctx, obj1);
+    if (res != FALSE)
+        return res;
     if ((flags & JS_PROP_THROW) ||
         ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
         JS_ThrowTypeError(ctx, "could not delete property");
@@ -9752,7 +9763,7 @@ static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val)
     return JS_ToNumberFree(ctx, JS_DupValue(ctx, val));
 }
 
-static __attribute__((unused)) JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
+static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag;
     JSValue ret;
@@ -10821,14 +10832,14 @@ static JSValue JS_ToQuotedString(JSContext *ctx, JSValueConst val1)
     return JS_EXCEPTION;
 }
 
-static __attribute__((unused)) void JS_DumpObjectHeader(JSRuntime *rt)
+static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt)
 {
     printf("%14s %4s %4s %14s %10s %s\n",
            "ADDRESS", "REFS", "SHRF", "PROTO", "CLASS", "PROPS");
 }
 
 /* for debug only: dump an object without side effect */
-static __attribute__((unused)) void JS_DumpObject(JSRuntime *rt, JSObject *p)
+static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
 {
     uint32_t i;
     char atom_buf[ATOM_GET_STR_BUF_SIZE];
@@ -10920,7 +10931,7 @@ static __attribute__((unused)) void JS_DumpObject(JSRuntime *rt, JSObject *p)
     printf("\n");
 }
 
-static __attribute__((unused)) void JS_DumpValueShort(JSRuntime *rt,
+static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
                                                       JSValueConst val)
 {
     uint32_t tag = JS_VALUE_GET_NORM_TAG(val);
@@ -11018,13 +11029,13 @@ static __attribute__((unused)) void JS_DumpValueShort(JSRuntime *rt,
     }
 }
 
-static __attribute__((unused)) void JS_DumpValue(JSContext *ctx,
+static __maybe_unused void JS_DumpValue(JSContext *ctx,
                                                  JSValueConst val)
 {
     JS_DumpValueShort(ctx->rt, val);
 }
 
-static __attribute__((unused)) void JS_PrintValue(JSContext *ctx,
+static __maybe_unused void JS_PrintValue(JSContext *ctx,
                                                   const char *str,
                                                   JSValueConst val)
 {
@@ -11245,7 +11256,7 @@ static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
     return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
 }
 
-static __attribute__((unused)) JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
+static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
 {
     if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
         return val;
@@ -13361,7 +13372,7 @@ static __exception int js_operator_in(JSContext *ctx, JSValue *sp)
         JS_ThrowTypeError(ctx, "invalid 'in' operand");
         return -1;
     }
-    atom = js_value_to_atom(ctx, op1);
+    atom = JS_ValueToAtom(ctx, op1);
     if (unlikely(atom == JS_ATOM_NULL))
         return -1;
     ret = JS_HasProperty(ctx, op2, atom);
@@ -13474,7 +13485,7 @@ static __exception int js_operator_delete(JSContext *ctx, JSValue *sp)
 
     op1 = sp[-2];
     op2 = sp[-1];
-    atom = js_value_to_atom(ctx, op2);
+    atom = JS_ValueToAtom(ctx, op2);
     if (unlikely(atom == JS_ATOM_NULL))
         return -1;
     ret = JS_DeleteProperty(ctx, op1, atom, JS_PROP_THROW_STRICT);
@@ -15366,10 +15377,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 #define JS_THROW_VAR_RO             0
 #define JS_THROW_VAR_REDECL         1
 #define JS_THROW_VAR_UNINITIALIZED  2
+#define JS_THROW_VAR_DELETE_SUPER   3
             {
                 JSAtom atom;
+                int type;
                 atom = get_u32(pc);
-                int type = pc[4];
+                type = pc[4];
                 pc += 5;
                 if (type == JS_THROW_VAR_RO)
                     JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, atom);
@@ -15379,6 +15392,9 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 else
                 if (type == JS_THROW_VAR_UNINITIALIZED)
                     JS_ThrowReferenceErrorUninitialized(ctx, atom);
+                else
+                if (type == JS_THROW_VAR_DELETE_SUPER)
+                    JS_ThrowReferenceError(ctx, "unsupported reference to 'super'");
                 else
                     JS_ThrowInternalError(ctx, "invalid throw var type %d", type);
             }
@@ -15386,17 +15402,63 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
         CASE(OP_eval):
             {
-                JSValue obj;
+                JSValueConst obj;
                 int scope_idx;
+                call_argc = get_u16(pc);
+                scope_idx = get_u16(pc + 2) - 1;
+                pc += 4;
+                call_argv = sp - call_argc;
+                sf->cur_pc = pc;
+                if (js_same_value(ctx, call_argv[-1], ctx->eval_obj)) {
+                    if (call_argc >= 1)
+                        obj = call_argv[0];
+                    else
+                        obj = JS_UNDEFINED;
+                    ret_val = JS_EvalObject(ctx, JS_UNDEFINED, obj,
+                                            JS_EVAL_TYPE_DIRECT, scope_idx);
+                } else {
+                    ret_val = JS_CallInternal(ctx, call_argv[-1], JS_UNDEFINED,
+                                              JS_UNDEFINED, call_argc, call_argv, 0);
+                }
+                if (unlikely(JS_IsException(ret_val)))
+                    goto exception;
+                for(i = -1; i < call_argc; i++)
+                    JS_FreeValue(ctx, call_argv[i]);
+                sp -= call_argc + 1;
+                *sp++ = ret_val;
+            }
+            BREAK;
+            /* could merge with OP_apply */
+        CASE(OP_apply_eval):
+            {
+                int scope_idx;
+                uint32_t len;
+                JSValue *tab;
+                JSValueConst obj;
 
                 scope_idx = get_u16(pc) - 1;
                 pc += 2;
-                obj = sp[-1];
-                sp[-1] = JS_EvalObject(ctx, JS_UNDEFINED, obj,
-                                       JS_EVAL_TYPE_DIRECT, scope_idx);
-                JS_FreeValue(ctx, obj);
-                if (unlikely(JS_IsException(sp[-1])))
+                tab = build_arg_list(ctx, &len, sp[-1]);
+                if (!tab)
+                    goto exception;
+                if (js_same_value(ctx, sp[-2], ctx->eval_obj)) {
+                    if (len >= 1)
+                        obj = tab[0];
+                    else
+                        obj = JS_UNDEFINED;
+                    ret_val = JS_EvalObject(ctx, JS_UNDEFINED, obj,
+                                            JS_EVAL_TYPE_DIRECT, scope_idx);
+                } else {
+                    ret_val = JS_Call(ctx, sp[-2], JS_UNDEFINED, len,
+                                      (JSValueConst *)tab);
+                }
+                free_arg_list(ctx, tab, len);
+                if (unlikely(JS_IsException(ret_val)))
                     goto exception;
+                JS_FreeValue(ctx, sp[-2]);
+                JS_FreeValue(ctx, sp[-1]);
+                sp -= 2;
+                *sp++ = ret_val;
             }
             BREAK;
 
@@ -16266,7 +16328,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
                 is_computed = (opcode == OP_define_method_computed);
                 if (is_computed) {
-                    atom = js_value_to_atom(ctx, sp[-2]);
+                    atom = JS_ValueToAtom(ctx, sp[-2]);
                     if (unlikely(atom == JS_ATOM_NULL))
                         goto exception;
                     opcode += OP_define_method - OP_define_method_computed;
@@ -16355,7 +16417,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             {
                 JSValue val;
                 if (unlikely(JS_IsUndefined(sp[-2]))) {
-                    JSAtom atom = js_value_to_atom(ctx, sp[-1]);
+                    JSAtom atom = JS_ValueToAtom(ctx, sp[-1]);
                     if (atom != JS_ATOM_NULL) {
                         JS_ThrowReferenceErrorNotDefined(ctx, atom);
                         JS_FreeAtom(ctx, atom);
@@ -16375,7 +16437,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             {
                 JSValue val;
                 JSAtom atom;
-                atom = js_value_to_atom(ctx, sp[-1]);
+                atom = JS_ValueToAtom(ctx, sp[-1]);
                 if (unlikely(atom == JS_ATOM_NULL))
                     goto exception;
                 val = JS_GetPropertyInternal(ctx, sp[-2], atom, sp[-3], FALSE);
@@ -16407,7 +16469,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 int ret;
                 if (unlikely(JS_IsUndefined(sp[-3]))) {
                     if (is_strict_mode(ctx)) {
-                        JSAtom atom = js_value_to_atom(ctx, sp[-2]);
+                        JSAtom atom = JS_ValueToAtom(ctx, sp[-2]);
                         if (atom != JS_ATOM_NULL) {
                             JS_ThrowReferenceErrorNotDefined(ctx, atom);
                             JS_FreeAtom(ctx, atom);
@@ -16433,7 +16495,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     JS_ThrowTypeErrorNotAnObject(ctx);
                     goto exception;
                 }
-                atom = js_value_to_atom(ctx, sp[-2]);
+                atom = JS_ValueToAtom(ctx, sp[-2]);
                 if (unlikely(atom == JS_ATOM_NULL))
                     goto exception;
                 ret = JS_SetPropertyGeneric(ctx, JS_VALUE_GET_OBJ(sp[-3]),
@@ -20723,7 +20785,7 @@ static int __exception js_parse_property_name(JSParseState *s,
             }
         }
     } else if (s->token.val == TOK_STRING) {
-        name = js_value_to_atom(s->ctx, s->token.u.str.str);
+        name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
         if (name == JS_ATOM_NULL)
             goto fail;
         if (next_token(s))
@@ -20738,12 +20800,12 @@ static int __exception js_parse_property_name(JSParseState *s,
             d = bf_mul_pow10_to_float64(s->ctx, &p->num,
                                         s->token.u.num.exponent);
             val = __JS_NewFloat64(s->ctx, d);
-            name = js_value_to_atom(s->ctx, val);
+            name = JS_ValueToAtom(s->ctx, val);
             JS_FreeValue(s->ctx, val);
         } else
 #endif
         {
-            name = js_value_to_atom(s->ctx, val);
+            name = JS_ValueToAtom(s->ctx, val);
         }
         if (name == JS_ATOM_NULL)
             goto fail;
@@ -22917,9 +22979,6 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         scope = get_u16(fd->byte_code.buf + fd->last_opcode_pos + 5);
                         if (name == JS_ATOM_eval && call_type == FUNC_CALL_NORMAL) {
                             /* direct 'eval' */
-                            JS_FreeAtom(s->ctx, name);
-                            fd->byte_code.size = fd->last_opcode_pos;
-                            fd->last_opcode_pos = -1;
                             opcode = OP_eval;
                         } else {
                             /* verify if function name resolves to a simple
@@ -23056,10 +23115,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     emit_u16(s, call_type == FUNC_CALL_NEW);
                     break;
                 case OP_eval:
-                    /* eval needs a single argument */
-                    emit_op(s, OP_get_field);
-                    emit_atom(s, __JS_AtomFromUInt32(0));
-                    emit_op(s, OP_eval);
+                    emit_op(s, OP_apply_eval);
                     emit_u16(s, fd->scope_level);
                     fd->has_eval_call = TRUE;
                     break;
@@ -23101,21 +23157,10 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     emit_u16(s, arg_count);
                     break;
                 case OP_eval:
-                    /* eval needs a single argument */
-                    if (arg_count == 0) {
-                        /* no actual eval call is needed? */
-                        emit_op(s, OP_undefined);
-                    } else {
-                        int i;
-                        /* pop extra arguments. Contrary to ECMA spec,
-                           browsers seem to evaluate extra arguments
-                           to direct eval */
-                        for(i = 1; i < arg_count; i++)
-                            emit_op(s, OP_drop);
-                        emit_op(s, OP_eval);
-                        emit_u16(s, fd->scope_level);
-                        fd->has_eval_call = TRUE;
-                    }
+                    emit_op(s, OP_eval);
+                    emit_u16(s, arg_count);
+                    emit_u16(s, fd->scope_level);
+                    fd->has_eval_call = TRUE;
                     break;
                 default:
                     if (call_type == FUNC_CALL_SUPER_CTOR) {
@@ -23248,6 +23293,11 @@ static __exception int js_parse_delete(JSParseState *s)
         break;
     case OP_scope_get_private_field:
         return js_parse_error(s, "cannot delete a private class field");
+    case OP_get_super_value:
+        emit_op(s, OP_throw_var);
+        emit_atom(s, JS_ATOM_NULL);
+        emit_u8(s, JS_THROW_VAR_DELETE_SUPER);
+        break;
     default:
     ret_true:
         emit_op(s, OP_drop);
@@ -25386,11 +25436,19 @@ static char *js_default_module_normalize_name(JSContext *ctx,
         if (r[0] == '.' && r[1] == '/') {
             r += 2;
         } else if (r[0] == '.' && r[1] == '.' && r[2] == '/') {
+            /* remove the last path element of filename, except if "."
+               or ".." */
             if (filename[0] == '\0')
                 break;
             p = strrchr(filename, '/');
             if (!p)
                 p = filename;
+            else
+                p++;
+            if (!strcmp(p, ".") || !strcmp(p, ".."))
+                break;
+            if (p > filename)
+                p--;
             *p = '\0';
             r += 3;
         } else {
@@ -26246,7 +26304,7 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     specifierString = JS_ToString(ctx, specifier);
     if (JS_IsException(specifierString))
         goto exception;
-    filename = js_value_to_atom(ctx, specifierString);
+    filename = JS_ValueToAtom(ctx, specifierString);
     JS_FreeValue(ctx, specifierString);
     if (filename == JS_ATOM_NULL)
         goto exception;
@@ -26362,7 +26420,7 @@ static __exception JSAtom js_parse_from_clause(JSParseState *s)
         js_parse_error(s, "string expected");
         return JS_ATOM_NULL;
     }
-    module_name = js_value_to_atom(s->ctx, s->token.u.str.str);
+    module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
     if (module_name == JS_ATOM_NULL)
         return JS_ATOM_NULL;
     if (next_token(s)) {
@@ -26587,7 +26645,7 @@ static __exception int js_parse_import(JSParseState *s)
 
     first_import = m->import_entries_count;
     if (s->token.val == TOK_STRING) {
-        module_name = js_value_to_atom(ctx, s->token.u.str.str);
+        module_name = JS_ValueToAtom(ctx, s->token.u.str.str);
         if (module_name == JS_ATOM_NULL)
             return -1;
         if (next_token(s)) {
@@ -27026,6 +27084,9 @@ static void dump_byte_code(JSContext *ctx, int pass,
         case OP_FMT_npop:
             printf(" %u", get_u16(tab + pos));
             break;
+        case OP_FMT_npop_u16:
+            printf(" %u,%u", get_u16(tab + pos), get_u16(tab + pos + 2));
+            break;
         case OP_FMT_i16:
             printf(" %d", get_i16(tab + pos));
             break;
@@ -27158,7 +27219,7 @@ static void dump_byte_code(JSContext *ctx, int pass,
     js_free(ctx, bits);
 }
 
-static __attribute__((unused)) void dump_pc2line(JSContext *ctx, const uint8_t *buf, int len,
+static __maybe_unused void dump_pc2line(JSContext *ctx, const uint8_t *buf, int len,
                                                  int line_num)
 {
     const uint8_t *p_end, *p_next, *p;
@@ -27203,7 +27264,7 @@ static __attribute__((unused)) void dump_pc2line(JSContext *ctx, const uint8_t *
     }
 }
 
-static __attribute__((unused)) void js_dump_function_bytecode(JSContext *ctx, JSFunctionBytecode *b)
+static __maybe_unused void js_dump_function_bytecode(JSContext *ctx, JSFunctionBytecode *b)
 {
     int i;
     char atom_buf[ATOM_GET_STR_BUF_SIZE];
@@ -28778,6 +28839,16 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
             arg_valid = get_u16(bc_buf + pos + 1);
             break;
         case OP_eval: /* convert scope index to adjusted variable index */
+            {
+                int call_argc = get_u16(bc_buf + pos + 1);
+                scope = get_u16(bc_buf + pos + 1 + 2);
+                mark_eval_captured_variables(ctx, s, scope);
+                dbuf_putc(&bc_out, op);
+                dbuf_put_u16(&bc_out, call_argc);
+                dbuf_put_u16(&bc_out, s->scopes[scope].first + 1);
+            }
+            break;
+        case OP_apply_eval: /* convert scope index to adjusted variable index */
             scope = get_u16(bc_buf + pos + 1);
             mark_eval_captured_variables(ctx, s, scope);
             dbuf_putc(&bc_out, op);
@@ -30219,7 +30290,7 @@ static __exception int compute_stack_size_rec(JSContext *ctx,
         }
         n_pop = oi->n_pop;
         /* call pops a variable number of arguments */
-        if (oi->fmt == OP_FMT_npop) {
+        if (oi->fmt == OP_FMT_npop || oi->fmt == OP_FMT_npop_u16) {
             n_pop += get_u16(bc_buf + pos + 1);
         } else {
 #if SHORT_OPCODES
@@ -31666,7 +31737,7 @@ static void bc_put_u16(BCWriterState *s, uint16_t v)
     dbuf_put_u16(&s->dbuf, v);
 }
 
-static __attribute__((unused)) void bc_put_u32(BCWriterState *s, uint32_t v)
+static __maybe_unused void bc_put_u32(BCWriterState *s, uint32_t v)
 {
     if (s->byte_swap)
         v = bswap32(v);
@@ -31814,6 +31885,12 @@ static void bc_byte_swap(uint8_t *bc_buf, int bc_len)
                         bswap16(get_u16(bc_buf + pos + 1 + 4 + 4)));
             }
             break;
+        case OP_FMT_npop_u16:
+            put_u16(bc_buf + pos + 1,
+                    bswap16(get_u16(bc_buf + pos + 1)));
+            put_u16(bc_buf + pos + 1 + 2,
+                    bswap16(get_u16(bc_buf + pos + 1 + 2)));
+            break;
         default:
             break;
         }
@@ -32363,7 +32440,7 @@ static int bc_get_u16(BCReaderState *s, uint16_t *pval)
     return 0;
 }
 
-static __attribute__((unused)) int bc_get_u32(BCReaderState *s, uint32_t *pval)
+static __maybe_unused int bc_get_u32(BCReaderState *s, uint32_t *pval)
 {
     if (unlikely(s->buf_end - s->ptr < 4)) {
         *pval = 0; /* avoid warning */
@@ -33763,7 +33840,7 @@ static JSValue js_object_defineProperty(JSContext *ctx, JSValueConst this_val,
 
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     flags = 0;
@@ -33812,7 +33889,7 @@ static JSValue js_object___defineGetter__(JSContext *ctx, JSValueConst this_val,
         JS_FreeValue(ctx, obj);
         return JS_EXCEPTION;
     }
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL)) {
         JS_FreeValue(ctx, obj);
         return JS_EXCEPTION;
@@ -33842,23 +33919,26 @@ static JSValue js_object___defineGetter__(JSContext *ctx, JSValueConst this_val,
 static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst this_val,
                                                   int argc, JSValueConst *argv, int magic)
 {
-    JSValueConst obj, prop;
+    JSValueConst prop;
     JSAtom atom;
-    JSValue ret;
+    JSValue ret, obj;
     JSPropertyDescriptor desc;
     int res, flags;
 
-    obj = argv[0];
-    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
-        /* ES6 feature non compatible with ES5.1: obj can be a primitive type */
-        if (magic || JS_VALUE_GET_TAG(obj) == JS_TAG_NULL ||
-            JS_VALUE_GET_TAG(obj) == JS_TAG_UNDEFINED)
+    if (magic) {
+        /* Reflect.getOwnPropertyDescriptor case */
+        if (JS_VALUE_GET_TAG(argv[0]) != JS_TAG_OBJECT)
             return JS_ThrowTypeErrorNotAnObject(ctx);
+        obj = JS_DupValue(ctx, argv[0]);
+    } else {
+        obj = JS_ToObject(ctx, argv[0]);
+        if (JS_IsException(obj))
+            return obj;
     }
     prop = argv[1];
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
-        return JS_EXCEPTION;
+        goto exception;
     ret = JS_UNDEFINED;
     if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
         res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), atom);
@@ -33888,6 +33968,7 @@ static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst t
         }
     }
     JS_FreeAtom(ctx, atom);
+    JS_FreeValue(ctx, obj);
     return ret;
 
 exception1:
@@ -33895,6 +33976,7 @@ static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst t
     JS_FreeValue(ctx, ret);
 exception:
     JS_FreeAtom(ctx, atom);
+    JS_FreeValue(ctx, obj);
     return JS_EXCEPTION;
 }
 
@@ -34099,7 +34181,7 @@ static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValueConst this_val,
     JSObject *p;
     BOOL ret;
 
-    atom = js_value_to_atom(ctx, argv[0]); /* must be done first */
+    atom = JS_ValueToAtom(ctx, argv[0]); /* must be done first */
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     obj = JS_ToObject(ctx, this_val);
@@ -34582,7 +34664,7 @@ static JSValue js_object_propertyIsEnumerable(JSContext *ctx, JSValueConst this_
     obj = JS_ToObject(ctx, this_val);
     if (JS_IsException(obj))
         goto exception;
-    prop = js_value_to_atom(ctx, argv[0]);
+    prop = JS_ValueToAtom(ctx, argv[0]);
     if (unlikely(prop == JS_ATOM_NULL))
         goto exception;
 
@@ -34614,7 +34696,7 @@ static JSValue js_object___lookupGetter__(JSContext *ctx, JSValueConst this_val,
     obj = JS_ToObject(ctx, this_val);
     if (JS_IsException(obj))
         goto exception;
-    prop = js_value_to_atom(ctx, argv[0]);
+    prop = JS_ValueToAtom(ctx, argv[0]);
     if (unlikely(prop == JS_ATOM_NULL))
         goto exception;
 
@@ -41825,7 +41907,7 @@ static JSValue js_reflect_deleteProperty(JSContext *ctx, JSValueConst this_val,
     obj = argv[0];
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    atom = js_value_to_atom(ctx, argv[1]);
+    atom = JS_ValueToAtom(ctx, argv[1]);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     ret = JS_DeleteProperty(ctx, obj, atom, 0);
@@ -41851,7 +41933,7 @@ static JSValue js_reflect_get(JSContext *ctx, JSValueConst this_val,
         receiver = argv[2];
     else
         receiver = obj;
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     ret = JS_GetPropertyInternal(ctx, obj, atom, receiver, FALSE);
@@ -41870,7 +41952,7 @@ static JSValue js_reflect_has(JSContext *ctx, JSValueConst this_val,
     prop = argv[1];
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     ret = JS_HasProperty(ctx, obj, atom);
@@ -41897,7 +41979,7 @@ static JSValue js_reflect_set(JSContext *ctx, JSValueConst this_val,
         receiver = obj;
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    atom = js_value_to_atom(ctx, prop);
+    atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
     ret = JS_SetPropertyGeneric(ctx, JS_VALUE_GET_OBJ(obj), atom,
@@ -42639,7 +42721,7 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
             JS_ThrowTypeError(ctx, "proxy: properties must be strings or symbols");
             goto fail;
         }
-        atom = js_value_to_atom(ctx, val);
+        atom = JS_ValueToAtom(ctx, val);
         JS_FreeValue(ctx, val);
         if (atom == JS_ATOM_NULL)
             goto fail;
@@ -45370,7 +45452,6 @@ static const JSCFunctionListEntry js_global_funcs[] = {
     JS_CFUNC_DEF("parseFloat", 1, js_parseFloat ),
     JS_CFUNC_DEF("isNaN", 1, js_global_isNaN ),
     JS_CFUNC_DEF("isFinite", 1, js_global_isFinite ),
-    JS_CFUNC_DEF("eval", 1, js_global_eval ),
 
     JS_CFUNC_MAGIC_DEF("decodeURI", 1, js_global_decodeURI, 0 ),
     JS_CFUNC_MAGIC_DEF("decodeURIComponent", 1, js_global_decodeURI, 1 ),
@@ -46058,7 +46139,7 @@ static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValueConst this_val,
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
     if (JS_IsString(argv[0])) {
-        hint = js_value_to_atom(ctx, argv[0]);
+        hint = JS_ValueToAtom(ctx, argv[0]);
         if (hint == JS_ATOM_NULL)
             return JS_EXCEPTION;
         JS_FreeAtom(ctx, hint);
@@ -47288,6 +47369,11 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                                countof(js_float_env_funcs));
 #endif
     /* global properties */
+    ctx->eval_obj = JS_NewCFunction(ctx, js_global_eval, "eval", 1);
+    JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_eval,
+                           JS_DupValue(ctx, ctx->eval_obj),
+                           JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+
     JS_SetPropertyFunctionList(ctx, ctx->global_obj, js_global_funcs,
                                countof(js_global_funcs));
 
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 206516b04a..eb4eb8d792 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -385,6 +385,7 @@ void JS_FreeAtomRT(JSRuntime *rt, JSAtom v);
 JSValue JS_AtomToValue(JSContext *ctx, JSAtom atom);
 JSValue JS_AtomToString(JSContext *ctx, JSAtom atom);
 const char *JS_AtomToCString(JSContext *ctx, JSAtom atom);
+JSAtom JS_ValueToAtom(JSContext *ctx, JSValueConst val);
 
 /* object class support */
 

From 9e38aeb277b05b7dc766d5ec1810ccdc07383f58 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 20 Sep 2019 13:14:22 +0300
Subject: [PATCH 026/185] more consistent conversion operators for Value,
 exception handling in eval

---
 main.cpp      |  24 +++++++-----
 quickjspp.hpp | 101 +++++++++++++++++++++++++++++++++-----------------
 2 files changed, 83 insertions(+), 42 deletions(-)

diff --git a/main.cpp b/main.cpp
index 13e163cf36..d0c4545232 100644
--- a/main.cpp
+++ b/main.cpp
@@ -114,7 +114,6 @@ int main(int argc, char ** argv)
                        "globalThis.test = test;\n"
                        "globalThis.os = os;\n";
     context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
-    const char * filename = argv[1];
 
     try
     {
@@ -138,22 +137,29 @@ int main(int argc, char ** argv)
                                 //"console.log(5.1 === q.base_field);"
                                 "console.log(q.spt === q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));" // false
                                 "q.fi(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
-        assert(xxx.cast<int>() == 18);
+        assert((int)xxx == 18);
         auto yyy = context.eval("q.fi.bind(t)(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
-        assert(yyy.cast<int>() == 13);
+        assert((int)yyy == 13);
 
-        auto f = context.eval("q.fi.bind(q)").cast<std::function<int32_t(TYPES)>>();
-        int zzz = f(false, 1, 0., context.eval("q").cast<std::shared_ptr<test>>(),
-                    context.eval("t").cast<std::shared_ptr<test>>(), "test string", std::string{"test"});
+        auto f = context.eval("q.fi.bind(q)").as<std::function<int32_t(TYPES)>>();
+        int zzz = f(false, 1, 0., context.eval("q").as<std::shared_ptr<test>>(),
+                    context.eval("t").as<std::shared_ptr<test>>(), "test string", std::string{"test"});
         assert(zzz == 19);
+
+
+        if(argv[1])
+            context.evalFile(argv[1]);
     }
     catch(exception)
     {
-        js_std_dump_error(ctx);
+        //js_std_dump_error(ctx);
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
     }
 
-    if(filename)
-    context.evalFile(filename, JS_EVAL_TYPE_MODULE);
+
 
     JSMemoryUsage mem;
     JS_ComputeMemoryUsage(rt, &mem);
diff --git a/quickjspp.hpp b/quickjspp.hpp
index 23e0c355e4..90aed0c750 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -644,6 +644,8 @@ struct js_property_traits<uint32_t>
     }
 };
 
+class Value;
+
 namespace detail {
 template <typename Key>
 struct property_proxy
@@ -652,12 +654,20 @@ struct property_proxy
     JSValue this_obj;
     Key key;
 
-    template <typename Value>
-    operator Value() const
+    /** Conversion helper function */
+    template <typename T>
+    T as() const
     {
-        return unwrap_free<Value>(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
+        return unwrap_free<T>(ctx, js_property_traits<Key>::get_property(ctx, this_obj, key));
     }
 
+    /** Explicit conversion operator (to any type) */
+    template <typename T>
+    explicit operator T() const { return as<T>(); }
+
+    /** Implicit converion to qjs::Value */
+    operator Value() const; // defined later due to Value being incomplete type
+
     template <typename Value>
     property_proxy& operator =(Value value)
     {
@@ -705,10 +715,11 @@ class Value
     JSContext * ctx = nullptr;
 
 public:
+    /** Use context.newValue(val) instead */
     template <typename T>
-    Value(JSContext * ctx, T val) : ctx(ctx)
+    Value(JSContext * ctx, T&& val) : ctx(ctx)
     {
-        v = js_traits<T>::wrap(ctx, val);
+        v = js_traits<std::decay_t<T>>::wrap(ctx, std::forward<T>(val));
     }
 
     Value(const Value& rhs)
@@ -728,18 +739,15 @@ class Value
         if(ctx) JS_FreeValue(ctx, v);
     }
 
+    bool isError() const { return JS_IsError(ctx, v); }
 
+    /** Conversion helper function. Both value.as<T>() and static_cast<T>(value) are supported */
     template <typename T>
-    T cast() const
-    {
-        return js_traits<std::decay_t<T>>::unwrap(ctx, v);
-    }
+    T as() const { return js_traits<std::decay_t<T>>::unwrap(ctx, v); }
 
+    /** Explicit conversion to any type */
     template <typename T>
-    T as() const
-    {
-        return cast<T>();
-    }
+    explicit operator T() const { return as<T>(); }
 
     JSValue release() // dont call freevalue
     {
@@ -747,13 +755,11 @@ class Value
         return v;
     }
 
-    operator JSValue()&&
-    {
-        return release();
-    }
+    /** Implicit conversion to JSValue (rvalue only). Example: JSValue v = std::move(value); */
+    operator JSValue() && { return release(); }
 
 
-    // access properties
+    /** Access JS properties. Returns proxy type which is implicitly convertible to qjs::Value */
     template <typename Key>
     detail::property_proxy<Key> operator [](Key key)
     {
@@ -825,9 +831,10 @@ class Runtime
     {
         rt = JS_NewRuntime();
         if(!rt)
-            throw exception{};
+            throw std::runtime_error{"qjs: Cannot create runtime"};
     }
 
+    // noncopyable
     Runtime(const Runtime&) = delete;
 
     ~Runtime()
@@ -1033,7 +1040,7 @@ class Context
     {
         ctx = JS_NewContext(rt);
         if(!ctx)
-            throw exception{};
+            throw std::runtime_error{"qjs: Cannot create context"};
         init();
     }
 
@@ -1042,6 +1049,7 @@ class Context
         init();
     }
 
+    // noncopyable
     Context(const Context&) = delete;
 
     ~Context()
@@ -1057,15 +1065,18 @@ class Context
         return modules.back();
     }
 
-    Value global()
-    {
-        return Value{ctx, JS_GetGlobalObject(ctx)};
-    }
+    /** returns globalThis */
+    Value global() { return Value{ctx, JS_GetGlobalObject(ctx)}; }
 
-    Value newObject()
-    {
-        return Value{ctx, JS_NewObject(ctx)};
-    }
+    /** returns new Object() */
+    Value newObject() { return Value{ctx, JS_NewObject(ctx)}; }
+
+    /** returns JS value converted from c++ object \val */
+    template <typename T>
+    Value newValue(T&& val) { return Value{ctx, std::forward<T>(val)}; }
+
+    /** returns current exception associated with context, and resets it. Should be called when qjs::exception is caught */
+    Value getException() { return Value{ctx, JS_GetException(ctx)}; }
 
     /** Register class \T for conversions to/from std::shared_ptr<T> to work.
      * Wherever possible module.class_<T>("T")... should be used instead.
@@ -1082,8 +1093,8 @@ class Context
     Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
     {
         JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
-        //if(JS_IsException(v))
-        //throw exception{};
+        if(JS_IsException(v))
+            throw exception{};
         return Value{ctx, v};
     }
 
@@ -1106,6 +1117,23 @@ class Context
     }
 };
 
+/** Conversion traits for Value.
+ */
+template <>
+struct js_traits<Value>
+{
+    static Value unwrap(JSContext * ctx, JSValueConst v) noexcept
+    {
+        return Value{ctx, JS_DupValue(ctx, v)};
+    }
+
+    static JSValue wrap(JSContext * ctx, Value v) noexcept
+    {
+        assert(ctx == v.ctx);
+        return v.release();
+    }
+};
+
 /** Convert to/from std::function
  * @tparam R return type
  * @tparam Args argument types
@@ -1168,13 +1196,20 @@ struct js_traits<std::vector<T>>
             throw exception{};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
         std::vector<T> arr;
-        int32_t len = jsarray["length"];
+        auto len = static_cast<int32_t>(jsarray["length"]);
         arr.reserve((uint32_t) len);
         for(uint32_t i = 0; i < (uint32_t) len; i++)
-            arr.push_back(jsarray[i]);
+            arr.push_back(static_cast<T>(jsarray[i]));
         return arr;
     }
 };
 
+namespace detail {
+template <typename Key>
+property_proxy<Key>::operator Value() const
+{
+    return as<Value>();
+}
+}
 
-}
\ No newline at end of file
+} // namespace qjs

From 1e53dfcde3ec18a64b930990a3ca6768125732ed Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 20 Sep 2019 15:27:31 +0300
Subject: [PATCH 027/185] comparison and assignment operators for qjs::Value

---
 quickjspp.hpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 90aed0c750..0b621eee01 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -734,6 +734,30 @@ class Value
         v = rhs.v;
     }
 
+    Value& operator=(Value rhs)
+    {
+        std::swap(ctx, rhs.ctx);
+        std::swap(v, rhs.v);
+        return *this;
+    }
+
+    bool operator==(JSValueConst other) const
+    {
+        return JS_VALUE_GET_TAG(v) == JS_VALUE_GET_TAG(other) && JS_VALUE_GET_PTR(v) == JS_VALUE_GET_PTR(other);
+    }
+
+    bool operator!=(JSValueConst other) const { return !((*this) == other); }
+
+
+    /** Returns true if 2 values are the same (equality for arithmetic types or point to the same object) */
+    bool operator==(const Value& rhs) const
+    {
+        return ctx == rhs.ctx && (*this == rhs.v);
+    }
+
+    bool operator!=(const Value& rhs) const { return !((*this) == rhs); }
+
+
     ~Value()
     {
         if(ctx) JS_FreeValue(ctx, v);

From 5c3e13120f23b21df89c3f8428a868d042976092 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 20 Sep 2019 15:53:42 +0300
Subject: [PATCH 028/185] finally some tests

---
 CMakeLists.txt             | 13 ++++---
 qjs.cpp                    | 57 +++++++++++++++++++++++++++
 quickjs/CMakeLists.txt     |  3 ++
 test/CMakeLists.txt        | 13 +++++++
 main.cpp => test/class.cpp | 79 +++++++++++++++++---------------------
 test/value.cpp             | 64 ++++++++++++++++++++++++++++++
 6 files changed, 180 insertions(+), 49 deletions(-)
 create mode 100644 qjs.cpp
 create mode 100644 test/CMakeLists.txt
 rename main.cpp => test/class.cpp (73%)
 create mode 100644 test/value.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3951eef502..997baf6888 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,10 +4,13 @@ project(quickjspp)
 set(CMAKE_CXX_STANDARD 17)
 #set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
 
-#if(GNU)
-#    add_compile_options(-Wall -Wno-unused-parameter)
-#    endif()
+if(CMAKE_COMPILER_IS_GNUCC)
+    add_compile_options(-Wall -Wno-unused-parameter)
+endif()
 
 add_subdirectory(quickjs)
-add_executable(quickjspp main.cpp)
-target_link_libraries(quickjspp quickjs )
+add_executable(qjs qjs.cpp)
+target_link_libraries(qjs quickjs)
+
+enable_testing()
+add_subdirectory(test)
diff --git a/qjs.cpp b/qjs.cpp
new file mode 100644
index 0000000000..a40d4f7b51
--- /dev/null
+++ b/qjs.cpp
@@ -0,0 +1,57 @@
+#include "quickjspp.hpp"
+
+
+#include <iostream>
+
+int main(int argc, char ** argv)
+{
+    JSRuntime * rt;
+    JSContext * ctx;
+    using namespace qjs;
+
+    Runtime runtime;
+    rt = runtime.rt;
+
+    Context context(runtime);
+    ctx = context.ctx;
+
+
+    /* loader for ES6 modules */
+    JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
+    js_std_add_helpers(ctx, argc, argv);
+
+    /* system modules */
+    js_init_module_std(ctx, "std");
+    js_init_module_os(ctx, "os");
+
+    /* make 'std' and 'os' visible to non module code */
+    const char * str = "import * as std from 'std';\n"
+                       "import * as os from 'os';\n"
+                       "globalThis.std = std;\n"
+                       "globalThis.os = os;\n";
+    context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
+
+    try
+    {
+        if(argv[1])
+            context.evalFile(argv[1]);
+    }
+    catch(exception)
+    {
+        //js_std_dump_error(ctx);
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+
+        js_std_free_handlers(rt);
+        return 1;
+    }
+
+    js_std_loop(ctx);
+
+    js_std_free_handlers(rt);
+
+    return 0;
+
+}
diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index a40ee724e4..11a94b0bee 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -16,7 +16,10 @@ endif()
 add_library(quickjs ${quickjs_src})
 target_compile_definitions(quickjs PRIVATE ${quickjs_def} )
 
+add_library(quickjs-dumpleaks ${quickjs_src})
+target_compile_definitions(quickjs-dumpleaks PRIVATE ${quickjs_def} DUMP_LEAKS=1)
 
 if(UNIX)
   target_link_libraries(quickjs ${CMAKE_DL_LIBS} m )
+  target_link_libraries(quickjs-dumpleaks ${CMAKE_DL_LIBS} m )
 endif()
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000000..8f7101fbf6
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,13 @@
+include_directories(..)
+
+macro(make_test name)
+add_executable(${name} ${name}.cpp)
+target_link_libraries(${name} quickjs-dumpleaks)
+add_test(${name} ${name})
+# try to compile with -DCONFIG_CHECK_JSVALUE
+add_library(${name}-checkjsv OBJECT ${name}.cpp)
+target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
+endmacro()
+
+make_test(value)
+make_test(class)
diff --git a/main.cpp b/test/class.cpp
similarity index 73%
rename from main.cpp
rename to test/class.cpp
index d0c4545232..97fe942f72 100644
--- a/main.cpp
+++ b/test/class.cpp
@@ -1,14 +1,7 @@
 #include "quickjspp.hpp"
-
-
 #include <iostream>
 
 
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-
-
 #define TYPES bool, int32_t, double, std::shared_ptr<test>, const std::shared_ptr<test>&, std::string, const std::string&
 
 class base_test
@@ -59,7 +52,7 @@ void f(TYPES) {}
 void qjs_glue(qjs::Context::Module& m) {
     m.function<&::f>("f"); // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
     m.class_<::base_test>("base_test")
-                    // implicit: .constructor<::base_test const &>()
+            // implicit: .constructor<::base_test const &>()
             .constructor<>()
             .fun<&::base_test::base_method>("base_method") // (double)
             .fun<&::base_test::base_field>("base_field") // double
@@ -83,7 +76,8 @@ void qjs_glue(qjs::Context::Module& m) {
             .fun<&::test::s>("s") // ::std::string
             ;
 } // qjs_glue
-int main(int argc, char ** argv)
+
+int main()
 {
     JSRuntime * rt;
     JSContext * ctx;
@@ -95,33 +89,37 @@ int main(int argc, char ** argv)
     Context context(runtime);
     ctx = context.ctx;
 
-    qjs_glue(context.addModule("test"));
+    try
+    {
+        qjs_glue(context.addModule("test"));
 
 
-    /* loader for ES6 modules */
-    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
-    js_std_add_helpers(ctx, argc, argv);
+        /* loader for ES6 modules */
+        JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
+        js_std_add_helpers(ctx, 0, nullptr);
 
-    /* system modules */
-    js_init_module_std(ctx, "std");
-    js_init_module_os(ctx, "os");
+        /* system modules */
+        js_init_module_std(ctx, "std");
+        js_init_module_os(ctx, "os");
+
+        /* make 'std' and 'os' visible to non module code */
+        const char * str = "import * as std from 'std';\n"
+                           "import * as os from 'os';\n"
+                           "import * as test from 'test';\n"
+                           "globalThis.std = std;\n"
+                           "globalThis.test = test;\n"
+                           "globalThis.os = os;\n";
+        context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
+
+
+        context.global().add("assert", [](bool t) { if(!t) std::exit(2); });
 
-    /* make 'std' and 'os' visible to non module code */
-    const char * str = "import * as std from 'std';\n"
-                       "import * as os from 'os';\n"
-                       "import * as test from 'test';\n"
-                       "globalThis.std = std;\n"
-                       "globalThis.test = test;\n"
-                       "globalThis.os = os;\n";
-    context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
 
-    try
-    {
         auto xxx = context.eval("\"use strict\";"
                                 "var b = new test.base_test();"
                                 "b.base_field = [[5],[1,2,3,4],[6]];"
-                                "console.log(b.base_field[1][3] === 4);"
-                                "console.log(b.base_method() === 5);"
+                                "assert(b.base_field[1][3] === 4);"
+                                "assert(b.base_method() === 5);"
 
                                 "var t = new test.TestSimple(12);"
                                 "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"
@@ -130,12 +128,12 @@ int main(int argc, char ** argv)
                                 "q.s = \"STRING\";"
                                 "q.spt = t;"
                                 //"q.base_field = 105.5;"
-                                "console.log(q.b === q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
-                                "console.log(q.d === q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
-                                "console.log(q.s === q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs));"
-                                //"console.log(105.5 === q.base_method(5.1));"
-                                //"console.log(5.1 === q.base_field);"
-                                "console.log(q.spt === q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));" // false
+                                "assert(q.b === q.fb(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
+                                "assert(q.d === q.fd(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));"
+                                "assert(q.s === q.fs(t.vb, t.vi, t.vd, t, t, \"test\", t.vs));"
+                                //"assert(105.5 === q.base_method(5.1));"
+                                //"assert(5.1 === q.base_field);"
+                                "assert(q.spt !== q.fspt(t.vb, t.vi, t.vd, t, t, t.vs, \"test\"));" // different objects
                                 "q.fi(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
         assert((int)xxx == 18);
         auto yyy = context.eval("q.fi.bind(t)(t.vb, t.vi, t.vd, t, t, t.vs, \"test\")");
@@ -146,24 +144,17 @@ int main(int argc, char ** argv)
                     context.eval("t").as<std::shared_ptr<test>>(), "test string", std::string{"test"});
         assert(zzz == 19);
 
-
-        if(argv[1])
-            context.evalFile(argv[1]);
     }
     catch(exception)
     {
-        //js_std_dump_error(ctx);
         auto exc = context.getException();
         std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
         if((bool)exc["stack"])
             std::cerr << (std::string)exc["stack"] << std::endl;
-    }
-
 
-
-    JSMemoryUsage mem;
-    JS_ComputeMemoryUsage(rt, &mem);
-    JS_DumpMemoryUsage(stderr, &mem, rt);
+        js_std_free_handlers(rt);
+        return 1;
+    }
 
     js_std_loop(ctx);
 
diff --git a/test/value.cpp b/test/value.cpp
new file mode 100644
index 0000000000..c6b6f759c0
--- /dev/null
+++ b/test/value.cpp
@@ -0,0 +1,64 @@
+#include "quickjspp.hpp"
+#include <iostream>
+#include <cstring>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    
+    try
+    {
+        auto val1 = context.newValue(321);
+        auto val2 = context.newValue(123);
+        assert(val1 != val2);
+
+        val1 = val2;
+        assert(val1 == val2);
+
+        val1 = context.newValue(123);
+        assert(val1 == val2);
+
+        val1 = std::move(val2);
+        assert(val1 != val2);
+
+        assert(val1.as<std::string>() == "123");
+
+        assert((double) val1 == 123.0);
+
+        val2 = context.newValue((std::string) "123");
+        assert(val1 != val2);
+
+        context.global()["val1"] = val1;
+        context.global()["val2"] = val2;
+
+
+        assert((bool) context.eval("val1 !== val2"));
+        assert((bool) context.eval("val1 == val2"));
+
+        //
+
+        val1 = context.newObject();
+        val1["a"] = 1;
+        val2 = context.newObject();
+        val2["a"] = 1;
+
+        assert(val1 != val2);
+
+        context.global()["val1"] = val1;
+        context.global()["val2"] = val2;
+
+        assert((bool) context.eval("val1 !== val2"));
+        assert((bool) context.eval("val1 != val2"));
+        assert((bool)context.eval("JSON.stringify(val1) === JSON.stringify(val2)"));
+
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}

From ca46c80f5b277bb2a69077768015b146e682f293 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 21 Sep 2019 13:31:30 +0300
Subject: [PATCH 029/185] const char * conversion

---
 quickjspp.hpp | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 0b621eee01..1584289152 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -198,7 +198,7 @@ struct js_traits<std::string_view>
 {
     static detail::js_string unwrap(JSContext * ctx, JSValueConst v)
     {
-        std::size_t plen;
+        size_t plen;
         const char * ptr = JS_ToCStringLen(ctx, &plen, v);
         if(!ptr)
             throw exception{};
@@ -207,7 +207,7 @@ struct js_traits<std::string_view>
 
     static JSValue wrap(JSContext * ctx, std::string_view str) noexcept
     {
-        return JS_NewStringLen(ctx, str.data(), (int) str.size());
+        return JS_NewStringLen(ctx, str.data(), str.size());
     }
 };
 
@@ -223,10 +223,21 @@ struct js_traits<std::string>
 
     static JSValue wrap(JSContext * ctx, const std::string& str) noexcept
     {
-        return JS_NewStringLen(ctx, str.data(), (int) str.size());
+        return JS_NewStringLen(ctx, str.data(), str.size());
     }
 };
 
+/** Conversion from const char * */
+template <>
+struct js_traits<const char *>
+{
+    static JSValue wrap(JSContext * ctx, const char * str) noexcept
+    {
+        return JS_NewString(ctx, str);
+    }
+};
+
+
 namespace detail {
 
 /** Helper function to convert and then free JSValue. */

From c598e98be49422d57c72145a5e701eb696d82133 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 21 Sep 2019 19:55:38 +0300
Subject: [PATCH 030/185] fix arguments unwrapping

---
 quickjspp.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1584289152..1ada10778e 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -274,9 +274,9 @@ Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence
  * @tparam Args C++ types of the argv array
  */
 template <typename... Args>
-std::tuple<Args...> unwrap_args(JSContext * ctx, JSValueConst * argv)
+std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, JSValueConst * argv)
 {
-    return unwrap_args_impl<std::tuple<Args...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
+    return unwrap_args_impl<std::tuple<std::decay_t<Args>...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
 }
 
 /** Helper function to call f with an array of JSValues.
@@ -731,6 +731,8 @@ class Value
     Value(JSContext * ctx, T&& val) : ctx(ctx)
     {
         v = js_traits<std::decay_t<T>>::wrap(ctx, std::forward<T>(val));
+        if(JS_IsException(v))
+            throw exception{};
     }
 
     Value(const Value& rhs)

From 9bd88ac84b981cc3db629063e3c0595e014a8ddf Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Sep 2019 12:16:39 +0300
Subject: [PATCH 031/185] fix multiple contexts creation

---
 quickjspp.hpp | 62 ++++++++++++++++++++++++++++++---------------------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1ada10778e..63560fc8a7 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -447,33 +447,39 @@ template <class T>
 struct js_traits<std::shared_ptr<T>>
 {
     /// Registered class id in QuickJS.
-    inline static JSClassID QJSClassId;
+    inline static JSClassID QJSClassId = 0;
 
     /** Register class in QuickJS context.
      *
      * @param ctx context
      * @param name class name
-     * @param proto class prototype
+     * @param proto class prototype or JS_NULL
      * @throws exception
      */
-    static void register_class(JSContext * ctx, const char * name, JSValue proto)
+    static void register_class(JSContext * ctx, const char * name, JSValue proto = JS_NULL)
     {
-        JSClassDef def{
-                name,
-                // destructor
-                [](JSRuntime * rt, JSValue obj) noexcept {
-                    auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
-                    assert(pptr);
-                    //delete pptr;
-                    auto alloc = allocator<std::shared_ptr<T>>{rt};
-                    using atraits = std::allocator_traits<decltype(alloc)>;
-                    atraits::destroy(alloc, pptr);
-                    atraits::deallocate(alloc, pptr, 1);
-                }
-        };
-        int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
-        if(e < 0)
-            throw exception{};
+        if(QJSClassId == 0)
+        {
+            JSClassDef def{
+                    name,
+                    // destructor
+                    [](JSRuntime * rt, JSValue obj) noexcept {
+                        auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
+                        assert(pptr);
+                        //delete pptr;
+                        auto alloc = allocator<std::shared_ptr<T>>{rt};
+                        using atraits = std::allocator_traits<decltype(alloc)>;
+                        atraits::destroy(alloc, pptr);
+                        atraits::deallocate(alloc, pptr, 1);
+                    }
+            };
+            int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+            if(e < 0)
+            {
+                JS_ThrowInternalError(ctx, "Cant register class %s", name);
+                throw exception{};
+            }
+        }
         JS_SetClassProto(ctx, QJSClassId, proto);
     }
 
@@ -583,10 +589,13 @@ static_assert(std::is_trivially_destructible_v<function>);
 template <>
 struct js_traits<detail::function>
 {
-    inline static JSClassID QJSClassId;
+    inline static JSClassID QJSClassId = 0;
 
+    // TODO: replace ctx with rt
     static void register_class(JSContext * ctx, const char * name)
     {
+        if(QJSClassId)
+            return;
         JSClassDef def{
                 name,
                 // destructor
@@ -609,18 +618,19 @@ struct js_traits<detail::function>
         };
         int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
         if(e < 0)
-            throw exception{};
+            throw std::runtime_error{"Cannot register C++ function class"};
     }
 };
 
 
-//          properties
-
+/** Traits for accessing object properties.
+ * @tparam Key property key type (uint32 and strings are supported)
+ */
 template <typename Key>
 struct js_property_traits
 {
-    // static void set_property(JSContext * ctx, JSValue this_obj, R key, JSValue value)
-    // static JSValue get_property(JSContext * ctx, JSValue this_obj, R key)
+    static void set_property(JSContext * ctx, JSValue this_obj, Key key, JSValue value);
+    static JSValue get_property(JSContext * ctx, JSValue this_obj, Key key);
 };
 
 template <>
@@ -1122,7 +1132,7 @@ class Context
      * @param proto JS class prototype or JS_UNDEFINED
      */
     template <class T>
-    void registerClass(const char * name, JSValue proto)
+    void registerClass(const char * name, JSValue proto = JS_NULL)
     {
         js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
     }

From ee9ed7b389e80b9519b24546f39349f528f6f93a Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Sep 2019 12:42:11 +0300
Subject: [PATCH 032/185] remove duplicate exception check

---
 quickjspp.hpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 63560fc8a7..dde2e3546a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -136,9 +136,9 @@ template <>
 struct js_traits<void>
 {
     /// @throws exception if jsvalue is neither undefined nor null
-    static void unwrap(JSContext * ctx, JSValueConst undefined)
+    static void unwrap(JSContext * ctx, JSValueConst value)
     {
-        if(!JS_IsUndefined(undefined) && !JS_IsNull(undefined))
+        if(JS_IsException(value))
             throw exception{};
     }
 };
@@ -1140,8 +1140,6 @@ class Context
     Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
     {
         JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
-        if(JS_IsException(v))
-            throw exception{};
         return Value{ctx, v};
     }
 

From fdf34f8878bf9549e087f759637fce36ed170500 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Sep 2019 12:42:37 +0300
Subject: [PATCH 033/185] fix qjs arguments

---
 qjs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qjs.cpp b/qjs.cpp
index a40d4f7b51..a9718a8091 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -18,7 +18,7 @@ int main(int argc, char ** argv)
 
     /* loader for ES6 modules */
     JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
-    js_std_add_helpers(ctx, argc, argv);
+    js_std_add_helpers(ctx, argc - 1, argv + 1);
 
     /* system modules */
     js_init_module_std(ctx, "std");
@@ -34,7 +34,7 @@ int main(int argc, char ** argv)
     try
     {
         if(argv[1])
-            context.evalFile(argv[1]);
+            context.evalFile(argv[1], JS_EVAL_TYPE_MODULE);
     }
     catch(exception)
     {

From 3d6b37a9b0fad0721a7b7d9226b15be27d9ee691 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Sep 2019 12:45:06 +0300
Subject: [PATCH 034/185] more tests

---
 test/CMakeLists.txt   | 13 +++++++--
 test/example.cpp      | 53 ++++++++++++++++++++++++++++++++++++
 test/exception.cpp    | 53 ++++++++++++++++++++++++++++++++++++
 test/multicontext.cpp | 62 +++++++++++++++++++++++++++++++++++++++++++
 test/value.cpp        |  6 +++--
 5 files changed, 183 insertions(+), 4 deletions(-)
 create mode 100644 test/example.cpp
 create mode 100644 test/exception.cpp
 create mode 100644 test/multicontext.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 8f7101fbf6..35f6efbbf2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,5 +1,10 @@
 include_directories(..)
 
+if(UNIX AND CMAKE_COMPILER_IS_GNUCC)
+    add_compile_options(-fsanitize=undefined)
+    add_link_options(-fsanitize=undefined)
+endif()
+
 macro(make_test name)
 add_executable(${name} ${name}.cpp)
 target_link_libraries(${name} quickjs-dumpleaks)
@@ -9,5 +14,9 @@ add_library(${name}-checkjsv OBJECT ${name}.cpp)
 target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
-make_test(value)
-make_test(class)
+foreach(test
+        value class exception example multicontext
+        )
+make_test(${test})
+endforeach()
+
diff --git a/test/example.cpp b/test/example.cpp
new file mode 100644
index 0000000000..73eff19f59
--- /dev/null
+++ b/test/example.cpp
@@ -0,0 +1,53 @@
+#include "quickjspp.hpp"
+#include <iostream>
+
+class MyClass
+{
+public:
+    MyClass() {}
+    MyClass(std::vector<int>) {}
+
+    double member_variable = 5.5;
+    std::string member_function(const std::string& s) { return "Hello, " + s; }
+};
+
+void println(const std::string& str) { std::cout << str << std::endl; }
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    try
+    {
+        // export classes as a module
+        auto& module = context.addModule("MyModule");
+        module.function<&println>("println");
+        module.class_<MyClass>("MyClass")
+                .constructor<>()
+                .constructor<std::vector<int>>("MyClassA")
+                .fun<&MyClass::member_variable>("member_variable")
+                .fun<&MyClass::member_function>("member_function");
+        // import module
+        context.eval("import * as my from 'MyModule'; globalThis.my = my;", "<import>", JS_EVAL_TYPE_MODULE);
+        // evaluate js code
+        context.eval("let v1 = new my.MyClass();" "\n"
+                     "v1.member_variable = 1;" "\n"
+                     "let v2 = new my.MyClassA([1,2,3]);" "\n"
+                     "function my_callback(str) {" "\n"
+                     "  my.println(v2.member_function(str));" "\n"
+                     "}" "\n"
+        );
+
+        // callback
+        auto cb = (std::function<void(const std::string&)>) context.eval("my_callback");
+        cb("world");
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/test/exception.cpp b/test/exception.cpp
new file mode 100644
index 0000000000..c595698299
--- /dev/null
+++ b/test/exception.cpp
@@ -0,0 +1,53 @@
+#include "quickjspp.hpp"
+#include <iostream>
+
+struct A{};
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    context.global().add("println", [](const std::string& s) { std::cout << s << std::endl; });
+
+    context.registerClass<A>("A");
+    context.registerClass<A>("A");
+
+    try
+    {
+        auto obj = context.eval("Symbol.toPrimitive");
+        std::cout << static_cast<int>(obj) << std::endl;
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        assert(exc.isError() && (std::string) exc == "TypeError: cannot convert symbol to number");
+    }
+
+    try
+    {
+        std::string big;
+        big.resize((1 << 30) + 1);
+        auto fun = context.eval("(function(a, b, c) { println(a); println(b); println(c); })").as<std::function<void(double, std::string, int)>>();
+        fun(0, std::move(big), 0);
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cout << (std::string) exc << '\n' << (std::string_view) exc["stack"];
+    }
+
+    try
+    {
+        //context.global().add("emptyf", [](JSValue v) {} );
+        auto f = (std::function<void ()>) context.eval("(function() { +Symbol.toPrimitive })");
+        f();
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cout << (std::string) exc << '\n' << (std::string_view) exc["stack"];
+    }
+}
diff --git a/test/multicontext.cpp b/test/multicontext.cpp
new file mode 100644
index 0000000000..c0d65c693f
--- /dev/null
+++ b/test/multicontext.cpp
@@ -0,0 +1,62 @@
+#include "quickjspp.hpp"
+#include <iostream>
+
+class MyClass
+{
+public:
+    MyClass() {}
+
+    void print_context(qjs::Value value) { std::cout << "Context: " << value.ctx << '\n'; }
+};
+
+void println(const std::string& str) { std::cout << str << std::endl; }
+
+static void glue(qjs::Context::Module& module)
+{
+    module.function<&println>("println");
+    module.class_<MyClass>("MyClass")
+            .constructor<>()
+            .fun<&MyClass::print_context>("print_context");
+}
+
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context1(runtime);
+    qjs::Context context2(runtime);
+    try
+    {
+        // export classes as a module
+        glue(context1.addModule("MyModule"));
+        // evaluate js code
+        context1.eval("import * as my from 'MyModule'; " "\n"
+                      "(new my.MyClass()).print_context(undefined);" "\n"
+                     , "<eval>", JS_EVAL_TYPE_MODULE
+        );
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context1.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+    try
+    {
+        glue(context2.addModule("MyModule"));
+        context2.eval("import * as my from 'MyModule'; " "\n"
+                      "(new my.MyClass()).print_context(undefined);" "\n"
+                      ,"<eval>", JS_EVAL_TYPE_MODULE
+        );
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context2.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/test/value.cpp b/test/value.cpp
index c6b6f759c0..01ca7e5fc9 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -39,9 +39,9 @@ int main()
         //
 
         val1 = context.newObject();
-        val1["a"] = 1;
+        val1["a"] = "1";
         val2 = context.newObject();
-        val2["a"] = 1;
+        val2["a"] = "1";
 
         assert(val1 != val2);
 
@@ -52,6 +52,8 @@ int main()
         assert((bool) context.eval("val1 != val2"));
         assert((bool)context.eval("JSON.stringify(val1) === JSON.stringify(val2)"));
 
+        qjs::Value one = val1["a"];
+        assert((int)one == 1);
     }
     catch(qjs::exception)
     {

From ff903f8bd671d18842f1b9c9de691487d6300175 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 24 Sep 2019 19:35:58 +0000
Subject: [PATCH 035/185] remove usan option from cmake files

---
 test/CMakeLists.txt | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 35f6efbbf2..0555c50f83 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,10 +1,5 @@
 include_directories(..)
 
-if(UNIX AND CMAKE_COMPILER_IS_GNUCC)
-    add_compile_options(-fsanitize=undefined)
-    add_link_options(-fsanitize=undefined)
-endif()
-
 macro(make_test name)
 add_executable(${name} ${name}.cpp)
 target_link_libraries(${name} quickjs-dumpleaks)

From 29e03b91be969a81ac28d1111433c468bf48da0b Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 24 Sep 2019 19:37:04 +0000
Subject: [PATCH 036/185] new readme. fix #2

---
 readme.md  | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 readme.txt | 19 ---------------
 2 files changed, 69 insertions(+), 19 deletions(-)
 create mode 100644 readme.md
 delete mode 100644 readme.txt

diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000000..1876a1e00f
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,69 @@
+QuickJSPP is QuickJS wrapper for C++. It allows you to easily embed Javascript engine into your program.
+
+QuickJS is a small and embeddable Javascript engine. It supports the ES2020 specification including modules, asynchronous generators and proxies. More info: <https://bellard.org/quickjs/>
+
+# Example
+```cpp
+#include "quickjspp.hpp"
+#include <iostream>
+
+class MyClass
+{
+public:
+    MyClass() {}
+    MyClass(std::vector<int>) {}
+
+    double member_variable = 5.5;
+    std::string member_function(const std::string& s) { return "Hello, " + s; }
+};
+
+void println(const std::string& str) { std::cout << str << std::endl; }
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    try
+    {
+        // export classes as a module
+        auto& module = context.addModule("MyModule");
+        module.function<&println>("println");
+        module.class_<MyClass>("MyClass")
+                .constructor<>()
+                .constructor<std::vector<int>>("MyClassA")
+                .fun<&MyClass::member_variable>("member_variable")
+                .fun<&MyClass::member_function>("member_function");
+        // import module
+        context.eval("import * as my from 'MyModule'; globalThis.my = my;", "<import>", JS_EVAL_TYPE_MODULE);
+        // evaluate js code
+        context.eval("let v1 = new my.MyClass();" "\n"
+                     "v1.member_variable = 1;" "\n"
+                     "let v2 = new my.MyClassA([1,2,3]);" "\n"
+                     "function my_callback(str) {" "\n"
+                     "  my.println(v2.member_function(str));" "\n"
+                     "}" "\n"
+        );
+
+        // callback
+        auto cb = (std::function<void(const std::string&)>) context.eval("my_callback");
+        cb("world");
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}
+```
+
+# Installation
+QuickJSPP is header-only - put quickjspp.hpp into your include search path.
+Compiler that supports C++17 or later is required.
+The program needs to be linked against QuickJS.
+Sample CMake project files are provided.
+
+# License
+QuickJSPP is licensed under [CC0](https://creativecommons.org/publicdomain/zero/1.0/). QuickJS is licensed under [MIT](https://opensource.org/licenses/MIT).
diff --git a/readme.txt b/readme.txt
deleted file mode 100644
index 2b3118454e..0000000000
--- a/readme.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-QuickJS wrapper for C++.
-
-
-* Status
-+ conversions between int32_t, std::string, bool, double and JSValue
-+ basic support for classes
-+ basic support for modules
-+ automatic function wrapping and unwrapping
-- exception interop
-- tests for memory leaks
-
-* Installation
-QuickJSPP is header-only - C++17 or later is required. QuickJS needs to be compiled. Sample CMake files are provided.
-
-* Notes
-A small patch for C++ support is applied to quickjs.h.
-
-* License
-QuickJSPP is licensed under CC0 (https://creativecommons.org/publicdomain/zero/1.0/). 

From d169272302010b8c803863d8db9162ab0325950d Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 24 Sep 2019 20:17:31 +0000
Subject: [PATCH 037/185] doxygen autodoc

---
 .github/workflows/doxygen.yml |   23 +
 Doxyfile                      | 2464 +++++++++++++++++++++++++++++++++
 quickjspp.hpp                 |   12 +-
 3 files changed, 2493 insertions(+), 6 deletions(-)
 create mode 100644 .github/workflows/doxygen.yml
 create mode 100644 Doxyfile

diff --git a/.github/workflows/doxygen.yml b/.github/workflows/doxygen.yml
new file mode 100644
index 0000000000..03de2e5c9c
--- /dev/null
+++ b/.github/workflows/doxygen.yml
@@ -0,0 +1,23 @@
+name: Doxygen gh-pages
+on:
+  push:
+    branches:
+    - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Doxygen install
+      run: sudo apt-get install -y doxygen graphviz 
+    - name: Doxygen
+      run: doxygen
+    - name: Deploy to gh-pages
+      uses: peaceiris/actions-gh-pages@v2.3.2
+      env:
+        PERSONAL_TOKEN: ${{ secrets.TOKEN }}
+        PUBLISH_BRANCH: gh-pages
+        PUBLISH_DIR: ./html
+      with:
+        emptyCommits: false
diff --git a/Doxyfile b/Doxyfile
new file mode 100644
index 0000000000..e13744773b
--- /dev/null
+++ b/Doxyfile
@@ -0,0 +1,2464 @@
+# Doxyfile 1.8.13
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "QuickJSPP"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       =
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+# Fortran. In the later case the parser tries to guess whether the code is fixed
+# or free formatted code, this is the default for Fortran type files), VHDL. For
+# instance to make doxygen treat .inc files as Fortran files (default is PHP),
+# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 0.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 0
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO, these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES, upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = YES
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = NO
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = YES
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = . \
+                         quickjs
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
+# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf and *.qsf.
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.md \
+                         *.py \
+                         *.pyw
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           = test
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *.cpp
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE = readme.md
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = YES
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = NO
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse-libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          = -std=c++17
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sf.net) file that captures the
+# structure of the code including all documentation. Note that this feature is
+# still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = NO
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = svg
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = YES
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 30
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 3
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/quickjspp.hpp b/quickjspp.hpp
index dde2e3546a..0cae03455c 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -983,7 +983,7 @@ class Context
         // class register wrapper
     private:
         /** Helper class to register class members and constructors.
-         * See \fun, \constructor.
+         * See fun, constructor.
          * Actual registration occurs at object destruction.
          */
         template <class T>
@@ -1061,7 +1061,7 @@ class Context
 
     public:
         /** Add class to module.
-         * See \class_registrar.
+         * See \ref class_registrar.
          */
         template <class T>
         class_registrar<T> class_(const char * name)
@@ -1118,14 +1118,14 @@ class Context
     /** returns new Object() */
     Value newObject() { return Value{ctx, JS_NewObject(ctx)}; }
 
-    /** returns JS value converted from c++ object \val */
+    /** returns JS value converted from c++ object val */
     template <typename T>
     Value newValue(T&& val) { return Value{ctx, std::forward<T>(val)}; }
 
     /** returns current exception associated with context, and resets it. Should be called when qjs::exception is caught */
     Value getException() { return Value{ctx, JS_GetException(ctx)}; }
 
-    /** Register class \T for conversions to/from std::shared_ptr<T> to work.
+    /** Register class T for conversions to/from std::shared_ptr<T> to work.
      * Wherever possible module.class_<T>("T")... should be used instead.
      * @tparam T class type
      * @param name class name in JS engine
@@ -1198,7 +1198,7 @@ struct js_traits<std::function<R(Args...)>>
         };
     }
 
-    /** Convert from function object \functor to JSValue.
+    /** Convert from function object functor to JSValue.
      * Uses detail::function for type-erasure.
      */
     template <typename Functor>
@@ -1219,7 +1219,7 @@ struct js_traits<std::function<R(Args...)>>
     }
 };
 
-/** Convert from std::vector<T> to Array and vice-versa. If Array holds objects that are non-convertible to \T throws qjs::exception */
+/** Convert from std::vector<T> to Array and vice-versa. If Array holds objects that are non-convertible to T throws qjs::exception */
 template <class T>
 struct js_traits<std::vector<T>>
 {

From 16ffeb3e0d2d8de5236e0d56a09befd44ce345ff Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Wed, 23 Oct 2019 18:28:08 +0000
Subject: [PATCH 038/185] added missing header

---
 quickjspp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 0cae03455c..29a6e8b744 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -14,6 +14,7 @@ extern "C" {
 #include <algorithm>
 #include <tuple>
 #include <functional>
+#include <stdexcept>
 
 namespace qjs {
 

From 8df12b47d104d69138048d29a0660b380802c938 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 29 Oct 2019 12:20:26 +0300
Subject: [PATCH 039/185] update quickjs to 2019-10-27

---
 quickjs/VERSION   |   2 +-
 quickjs/quickjs.c | 114 ++++++++++++++++++++++++++++++++--------------
 quickjs/quickjs.h |   8 ++++
 3 files changed, 90 insertions(+), 34 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 80c17d9faf..b147a4bb62 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-09-18
+2019-10-27
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 5d833b0432..2e4e65c9b5 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -7970,7 +7970,8 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
     }
 
     if (p->is_exotic) {
-        if (p->class_id == JS_CLASS_ARRAY && p->fast_array) {
+        if (p->class_id == JS_CLASS_ARRAY && p->fast_array &&
+            __JS_AtomIsTaggedInt(prop)) {
             uint32_t idx = __JS_AtomToUInt32(prop);
             if (idx == p->u.array.count) {
                 /* fast case */
@@ -20437,11 +20438,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         }
         if (var_def_type != JS_VAR_DEF_FUNCTION_DECL &&
             var_def_type != JS_VAR_DEF_NEW_FUNCTION_DECL &&
-            (fd->func_kind == JS_FUNC_ASYNC ||
-             fd->func_kind == JS_FUNC_GENERATOR ||
-             fd->func_kind == JS_FUNC_ASYNC_GENERATOR ||
-             fd->func_type == JS_PARSE_FUNC_METHOD ||
-             fd->scope_level == 1) &&
+            fd->scope_level == 1 &&
             find_arg(ctx, fd, name) >= 0) {
             /* lexical variable redefines a parameter name */
             return js_parse_error(s, "invalid redefinition of parameter name");
@@ -24026,9 +24023,10 @@ static void emit_return(JSParseState *s, BOOL hasval)
 }
 
 #define DECL_MASK_FUNC  (1 << 0) /* allow normal function declaration */
-#define DECL_MASK_LABEL (1 << 1) /* allow labelled statement */
+/* ored with DECL_MASK_FUNC if function declarations are allowed with a label */
+#define DECL_MASK_FUNC_WITH_LABEL (1 << 1)
 #define DECL_MASK_OTHER (1 << 2) /* all other declarations */
-#define DECL_MASK_ALL   (DECL_MASK_FUNC | DECL_MASK_LABEL | DECL_MASK_OTHER)
+#define DECL_MASK_ALL   (DECL_MASK_FUNC | DECL_MASK_FUNC_WITH_LABEL | DECL_MASK_OTHER)
 
 static __exception int js_parse_statement_or_decl(JSParseState *s,
                                                   int decl_mask);
@@ -24463,10 +24461,6 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
     if (is_label(s)) {
         BlockEnv *be;
 
-        if (!(decl_mask & DECL_MASK_LABEL)) {
-            js_parse_error(s, "functions can only be labelled inside blocks");
-            goto fail;
-        }
         label_name = JS_DupAtom(ctx, s->token.u.ident.atom);
 
         for (be = s->cur_func->top_break; be; be = be->prev) {
@@ -24490,11 +24484,12 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
             label_break = new_label(s);
             push_break_entry(s->cur_func, &break_entry,
                              label_name, label_break, -1, 0);
-            if (s->cur_func->js_mode & JS_MODE_STRICT)
+            if (!(s->cur_func->js_mode & JS_MODE_STRICT) &&
+                (decl_mask & DECL_MASK_FUNC_WITH_LABEL)) {
+                mask = DECL_MASK_FUNC | DECL_MASK_FUNC_WITH_LABEL;
+            } else {
                 mask = 0;
-            else
-                mask = DECL_MASK_FUNC;
-            mask |= DECL_MASK_LABEL;
+            }
             if (js_parse_statement_or_decl(s, mask))
                 goto fail;
             emit_label(s, label_break);
@@ -26578,8 +26573,8 @@ static __exception int js_parse_export(JSParseState *s)
         emit_atom(s, local_name);
         emit_u16(s, 0);
 
-        if (add_export_entry(s, m, local_name, JS_ATOM_default,
-                             JS_EXPORT_TYPE_LOCAL) < 0)
+        if (!add_export_entry(s, m, local_name, JS_ATOM_default,
+                              JS_EXPORT_TYPE_LOCAL))
             return -1;
         break;
     case TOK_VAR:
@@ -28089,12 +28084,12 @@ static int find_private_class_field_all(JSContext *ctx, JSFunctionDef *fd,
 
 static void get_loc_or_ref(DynBuf *bc, BOOL is_ref, int idx)
 {
-    /* Note: the private field can be uninitialized, so the _check is
-       necessary */
+    /* if the field is not initialized, the error is catched when
+       accessing it */
     if (is_ref) 
-        dbuf_putc(bc, OP_get_var_ref_check);
+        dbuf_putc(bc, OP_get_var_ref);
     else
-        dbuf_putc(bc, OP_get_loc_check);
+        dbuf_putc(bc, OP_get_loc);
     dbuf_put_u16(bc, idx);
 }
 
@@ -33455,9 +33450,8 @@ static void JS_SetConstructor2(JSContext *ctx,
     set_cycle_flag(ctx, proto);
 }
 
-static void JS_SetConstructor(JSContext *ctx,
-                              JSValueConst func_obj,
-                              JSValueConst proto)
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+                       JSValueConst proto)
 {
     JS_SetConstructor2(ctx, func_obj, proto,
                        0, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
@@ -37984,6 +37978,34 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
         matcher = JS_GetProperty(ctx, regexp, atom);
         if (JS_IsException(matcher))
             return JS_EXCEPTION;
+        if (atom == JS_ATOM_Symbol_matchAll) {
+            int ret;
+            JSValue flags;
+
+            ret = js_is_regexp(ctx, regexp);
+            if (ret < 0)
+                goto fail1;
+            if (ret) {
+                flags = JS_GetProperty(ctx, regexp, JS_ATOM_flags);
+                if (JS_IsException(flags))
+                    goto fail1;
+                if (JS_IsUndefined(flags) || JS_IsNull(flags)) {
+                    JS_ThrowTypeError(ctx, "cannot convert to object");
+                    goto fail1;
+                }
+                flags = JS_ToStringFree(ctx, flags);
+                if (JS_IsException(flags))
+                    goto fail1;
+                ret = string_indexof_char(JS_VALUE_GET_STRING(flags), 'g', 0);
+                JS_FreeValue(ctx, flags);
+                if (ret < 0) {
+                    JS_ThrowTypeError(ctx, "regexp must have the 'g' flag");
+                fail1:
+                    JS_FreeValue(ctx, matcher);
+                    return JS_EXCEPTION;
+                }
+            }
+        }
         if (!JS_IsUndefined(matcher) && !JS_IsNull(matcher)) {
             return JS_CallFree(ctx, matcher, regexp, 1, &O);
         }
@@ -42707,11 +42729,11 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
     len2 = 0;
     if (js_get_length32(ctx, &len, prop_array))
         goto fail;
-    if (len == 0)
-        goto done;
-    tab = js_mallocz(ctx, sizeof(tab[0]) * len);
-    if (!tab)
-        goto fail;
+    if (len > 0) {
+        tab = js_mallocz(ctx, sizeof(tab[0]) * len);
+        if (!tab)
+            goto fail;
+    }
     for(i = 0; i < len; i++) {
         val = JS_GetPropertyUint32(ctx, prop_array, i);
         if (JS_IsException(val))
@@ -42783,7 +42805,6 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
         }
     }
 
- done:
     js_free_prop_enum(ctx, tab2, len2);
     JS_FreeValue(ctx, prop_array);
     *ptab = tab;
@@ -45265,7 +45286,8 @@ static JSValue js_global_decodeURI(JSContext *ctx, JSValueConst this_val,
                     }
                     c = (c << 6) | (c1 & 0x3f);
                 }
-                if (c < c_min || c > 0x10FFFF) {
+                if (c < c_min || c > 0x10FFFF ||
+                    (c >= 0xd800 && c < 0xe000)) {
                     js_throw_URIError(ctx, "malformed UTF-8");
                     goto fail;
                 }
@@ -47817,6 +47839,32 @@ static JSValue js_typed_array_get_byteOffset(JSContext *ctx,
     return JS_NewInt32(ctx, ta->offset);
 }
 
+/* Return the buffer associated to the typed array or an exception if
+   it is not a typed array or if the buffer is detached. pbyte_offset,
+   pbyte_length or pbytes_per_element can be NULL. */
+JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
+                               size_t *pbyte_offset,
+                               size_t *pbyte_length,
+                               size_t *pbytes_per_element)
+{
+    JSObject *p;
+    JSTypedArray *ta;
+    p = get_typed_array(ctx, obj, FALSE);
+    if (!p)
+        return JS_EXCEPTION;
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    ta = p->u.typed_array;
+    if (pbyte_offset)
+        *pbyte_offset = ta->offset;
+    if (pbyte_length)
+        *pbyte_length = ta->length;
+    if (pbytes_per_element) {
+        *pbytes_per_element = 1 << typed_array_size_log2(p->class_id);
+    }
+    return JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, ta->buffer));
+}
+                               
 static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
                                               JSValueConst this_val)
 {
@@ -48877,7 +48925,7 @@ struct TA_sort_context {
     JSValueConst arr;
     JSValueConst cmp;
     JSValue (*getfun)(JSContext *ctx, const void *a);
-    void *array_ptr; /* cannot change unless the array is detached */
+    uint8_t *array_ptr; /* cannot change unless the array is detached */
     int elt_size;
 };
 
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index eb4eb8d792..f6494e1205 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -684,6 +684,7 @@ int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
 int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
                       JSValueConst obj, JSAtom prop);
 
+/* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
                      const char *filename);
 JSValue JS_Call(JSContext *ctx, JSValueConst func_obj, JSValueConst this_obj,
@@ -696,6 +697,7 @@ JSValue JS_CallConstructor2(JSContext *ctx, JSValueConst func_obj,
                             JSValueConst new_target,
                             int argc, JSValueConst *argv);
 JS_BOOL JS_DetectModule(const char *input, size_t input_len);
+/* 'input' must be zero terminated i.e. input[input_len] = '\0'. */
 JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
                 const char *filename, int eval_flags);
 JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);
@@ -724,6 +726,10 @@ JSValue JS_NewArrayBuffer(JSContext *ctx, uint8_t *buf, size_t len,
 JSValue JS_NewArrayBufferCopy(JSContext *ctx, const uint8_t *buf, size_t len);
 void JS_DetachArrayBuffer(JSContext *ctx, JSValueConst obj);
 uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValueConst obj);
+JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
+                               size_t *pbyte_offset,
+                               size_t *pbyte_length,
+                               size_t *pbytes_per_element);
 
 JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
 
@@ -825,6 +831,8 @@ static inline JSValue JS_NewCFunctionMagic(JSContext *ctx, JSCFunctionMagic *fun
 {
     return JS_NewCFunction2(ctx, (JSCFunction *)func, name, length, cproto, magic);
 }
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+                       JSValueConst proto);
 
 /* C property definition */
 

From c6b588a8eea9465ca45c45f0739060865cac18bf Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 29 Oct 2019 12:58:00 +0300
Subject: [PATCH 040/185] require eval buffer to be null-terminated

---
 quickjspp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 29a6e8b744..9c340cffd3 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1140,6 +1140,7 @@ class Context
 
     Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
     {
+        assert(buffer.data()[buffer.size()] == '\0' && "eval buffer is not null-terminated"); // JS_Eval requirement
         JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
         return Value{ctx, v};
     }

From 436de1479dc17838e2707d9e816a5ec55d7c9c4f Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Dec 2019 14:27:11 +0300
Subject: [PATCH 041/185] update quickjs to 2019-12-21

---
 quickjs/VERSION          |    2 +-
 quickjs/libbf.c          |   21 +-
 quickjs/libbf.h          |    2 -
 quickjs/msvc.patch       |   45 ++
 quickjs/quickjs-libc.c   |   72 +-
 quickjs/quickjs-libc.h   |    3 +
 quickjs/quickjs-opcode.h |    1 +
 quickjs/quickjs.c        | 1429 ++++++++++++++++++++++----------------
 quickjs/quickjs.h        |   67 +-
 9 files changed, 989 insertions(+), 653 deletions(-)
 create mode 100644 quickjs/msvc.patch

diff --git a/quickjs/VERSION b/quickjs/VERSION
index b147a4bb62..bd167284e5 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-10-27
+2019-12-21
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 17418097fa..d96683de73 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -2653,8 +2653,13 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
        renormalization) */
     memset(a->tab, 0, (pos + 1) * sizeof(limb_t));
 
-    if (p == p_start)
-        goto error;
+    if (p == p_start) {
+        if (!radix_bits)
+            bf_delete(a);
+        ret = 0;
+        bf_set_nan(r);
+        goto done;
+    }
 
     /* parse the exponent, if any */
     expn = 0;
@@ -2747,18 +2752,6 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     if (pnext)
         *pnext = p;
     return ret | ret_legacy_octal;
- error:
-    if (!radix_bits)
-        bf_delete(a);
-    ret = 0;
-    if (flags & BF_ATOF_NAN_IF_EMPTY)  {
-        bf_set_nan(r);
-    } else {
-        bf_set_zero(r, 0);
-        if (flags & BF_ATOF_INT_PREC_INF)
-            ret |= BF_ATOF_ST_INTEGER;
-    }
-    goto done;
 }
 
 int bf_atof(bf_t *r, const char *str, const char **pnext, int radix,
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index e3ea06019b..f5d42f2af0 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -264,8 +264,6 @@ void bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
 #define BF_ATOF_UNDERSCORE_SEP (1 << 23)
 /* if a 'n' suffix is present, force integer parsing (XXX: remove) */
 #define BF_ATOF_INT_N_SUFFIX   (1 << 24)
-/* if set return NaN if empty number string (instead of 0) */
-#define BF_ATOF_NAN_IF_EMPTY   (1 << 25)
 /* only accept decimal floating point if radix = 0 */
 #define BF_ATOF_ONLY_DEC_FLOAT (1 << 26)
 
diff --git a/quickjs/msvc.patch b/quickjs/msvc.patch
new file mode 100644
index 0000000000..f210ac5854
--- /dev/null
+++ b/quickjs/msvc.patch
@@ -0,0 +1,45 @@
+diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
+index f6494e1..d822321 100644
+--- a/quickjs/quickjs.h
++++ b/quickjs/quickjs.h
+@@ -53,7 +53,7 @@ typedef struct JSClass JSClass;
+ typedef uint32_t JSClassID;
+ typedef uint32_t JSAtom;
+ 
+-#if defined(__x86_64__) || defined(__aarch64__)
++#if defined(__x86_64__) || defined(__aarch64__) || defined(_WIN64)
+ #define JS_PTR64
+ #define JS_PTR64_DEF(a) a
+ #else
+@@ -205,8 +205,13 @@ typedef struct JSValue {
+ #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
+ #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
+ 
++#ifdef _MSC_VER
++#define JS_MKVAL(tag, val) JSValue{ JSValueUnion{ .int32 = val }, tag }
++#define JS_MKPTR(tag, p) JSValue{ JSValueUnion{ .ptr = p }, tag }
++#else
+ #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
+ #define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
++#endif
+ 
+ #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
+ 
+@@ -587,7 +592,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
+         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         p->ref_count++;
+     }
+-    return (JSValue)v;
++    return v;
+ }
+ 
+ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
+@@ -596,7 +601,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
+         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+         p->ref_count++;
+     }
+-    return (JSValue)v;
++    return v;
+ }
+ 
+ int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index eba52cfd10..aad1692c16 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -555,12 +555,38 @@ static int interrupt_handler(JSRuntime *rt, void *opaque)
     return (os_pending_signals >> SIGINT) & 1;
 }
 
+static int get_bool_option(JSContext *ctx, BOOL *pbool,
+                           JSValueConst obj,
+                           const char *option)
+{
+    JSValue val;
+    val = JS_GetPropertyStr(ctx, obj, option);
+    if (JS_IsException(val))
+        return -1;
+    if (!JS_IsUndefined(val)) {
+        *pbool = JS_ToBool(ctx, val);
+    }
+    JS_FreeValue(ctx, val);
+    return 0;
+}
+
 static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
     const char *str;
     size_t len;
     JSValue ret;
+    JSValueConst options_obj;
+    BOOL backtrace_barrier = FALSE;
+    int flags;
+    
+    if (argc >= 2) {
+        options_obj = argv[1];
+        if (get_bool_option(ctx, &backtrace_barrier, options_obj,
+                            "backtrace_barrier"))
+            return JS_EXCEPTION;
+    }
+
     str = JS_ToCStringLen(ctx, &len, argv[0]);
     if (!str)
         return JS_EXCEPTION;
@@ -568,7 +594,10 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
         /* install the interrupt handler */
         JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
     }
-    ret = JS_Eval(ctx, str, len, "<evalScript>", JS_EVAL_TYPE_GLOBAL);
+    flags = JS_EVAL_TYPE_GLOBAL; 
+    if (backtrace_barrier)
+        flags |= JS_EVAL_FLAG_BACKTRACE_BARRIER;
+    ret = JS_Eval(ctx, str, len, "<evalScript>", flags);
     JS_FreeCString(ctx, str);
     if (--eval_script_recurse == 0) {
         /* remove the interrupt handler */
@@ -1067,21 +1096,6 @@ static int http_get_status(const char *buf)
     return atoi(p);
 }
 
-static int get_bool_option(JSContext *ctx, BOOL *pbool,
-                           JSValueConst obj,
-                           const char *option)
-{
-    JSValue val;
-    val = JS_GetPropertyStr(ctx, obj, option);
-    if (JS_IsException(val))
-        return -1;
-    if (!JS_IsUndefined(val)) {
-        *pbool = JS_ToBool(ctx, val);
-    }
-    JS_FreeValue(ctx, val);
-    return 0;
-}
-
 static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
@@ -2696,15 +2710,15 @@ void js_std_free_handlers(JSRuntime *rt)
     }
 }
 
-void js_std_dump_error(JSContext *ctx)
+static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val,
+                               BOOL is_throw)
 {
-    JSValue exception_val, val;
+    JSValue val;
     const char *stack;
     BOOL is_error;
     
-    exception_val = JS_GetException(ctx);
     is_error = JS_IsError(ctx, exception_val);
-    if (!is_error)
+    if (is_throw && !is_error)
         printf("Throw: ");
     js_print(ctx, JS_NULL, 1, (JSValueConst *)&exception_val);
     if (is_error) {
@@ -2716,9 +2730,27 @@ void js_std_dump_error(JSContext *ctx)
         }
         JS_FreeValue(ctx, val);
     }
+}
+
+void js_std_dump_error(JSContext *ctx)
+{
+    JSValue exception_val;
+    
+    exception_val = JS_GetException(ctx);
+    js_std_dump_error1(ctx, exception_val, TRUE);
     JS_FreeValue(ctx, exception_val);
 }
 
+void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
+                                      JSValueConst reason,
+                                      BOOL is_handled, void *opaque)
+{
+    if (!is_handled) {
+        printf("Possibly unhandled promise rejection: ");
+        js_std_dump_error1(ctx, reason, FALSE);
+    }
+}
+
 /* main loop which calls the user JS callbacks */
 void js_std_loop(JSContext *ctx)
 {
diff --git a/quickjs/quickjs-libc.h b/quickjs/quickjs-libc.h
index ac7947e4fe..93a53da614 100644
--- a/quickjs/quickjs-libc.h
+++ b/quickjs/quickjs-libc.h
@@ -42,5 +42,8 @@ JSModuleDef *js_module_loader(JSContext *ctx,
                               const char *module_name, void *opaque);
 void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                         int flags);
+void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
+                                      JSValueConst reason,
+                                      JS_BOOL is_handled, void *opaque);
 
 #endif /* QUICKJS_LIBC_H */
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 910bb75c05..cc514e5502 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -257,6 +257,7 @@ DEF(     strict_neq, 1, 2, 1, none)
 DEF(            and, 1, 2, 1, none)
 DEF(            xor, 1, 2, 1, none)
 DEF(             or, 1, 2, 1, none)
+DEF(is_undefined_or_null, 1, 1, 1, none)
 #ifdef CONFIG_BIGNUM
 DEF(      mul_pow10, 1, 2, 1, none)
 DEF(       math_div, 1, 2, 1, none)
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 2e4e65c9b5..76f68d6053 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -199,6 +199,12 @@ typedef struct JSShape JSShape;
 typedef struct JSString JSString;
 typedef struct JSString JSAtomStruct;
 
+typedef enum {
+    JS_GC_PHASE_NONE,
+    JS_GC_PHASE_DECREF,
+    JS_GC_PHASE_REMOVE_CYCLES,
+} JSGCPhaseEnum;
+
 struct JSRuntime {
     JSMallocFunctions mf;
     JSMallocState malloc_state;
@@ -216,26 +222,30 @@ struct JSRuntime {
     JSClass *class_array;
 
     struct list_head context_list; /* list of JSContext.link */
-    /* list of allocated objects (used by the garbage collector) */
-    struct list_head obj_list; /* list of JSObject.link */
+    /* list of JSGCObjectHeader.link. List of allocated GC objects (used
+       by the garbage collector) */
+    struct list_head gc_obj_list;
+    /* list of JSGCObjectHeader.link. Used during JS_FreeValueRT() */
+    struct list_head gc_zero_ref_count_list; 
+    struct list_head tmp_obj_list; /* used during GC */
+    JSGCPhaseEnum gc_phase : 8;
     size_t malloc_gc_threshold;
 #ifdef DUMP_LEAKS
     struct list_head string_list; /* list of JSString.link */
 #endif
-    struct list_head tmp_obj_list; /* used during gc */
-    struct list_head free_obj_list; /* used during gc */
-    struct list_head *el_next; /* used during gc */
 
     JSInterruptHandler *interrupt_handler;
     void *interrupt_opaque;
 
+    JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
+    void *host_promise_rejection_tracker_opaque;
+    
     struct list_head job_list; /* list of JSJobEntry.link */
 
     JSModuleNormalizeFunc *module_normalize_func;
     JSModuleLoaderFunc *module_loader_func;
     void *module_loader_opaque;
 
-    BOOL in_gc_sweep : 8;
     BOOL can_block : 8; /* TRUE if Atomics.wait can block */
 
     /* Shape hash table */
@@ -272,23 +282,49 @@ typedef struct JSStackFrame {
     const uint8_t *cur_pc; /* only used in bytecode functions : PC of the
                         instruction after the call */
     int arg_count;
-    int js_mode; /* for C functions: 0 */
+    int js_mode; /* 0 or JS_MODE_BIGINT for C functions */
     /* only used in generators. Current stack pointer value. NULL if
        the function is running. */ 
     JSValue *cur_sp;
 } JSStackFrame;
 
-typedef struct JSGCHeader {
-    uint8_t mark;
-} JSGCHeader;
+typedef enum {
+    JS_GC_OBJ_TYPE_JS_OBJECT,
+    JS_GC_OBJ_TYPE_FUNCTION_BYTECODE,
+    JS_GC_OBJ_TYPE_SHAPE,
+    JS_GC_OBJ_TYPE_VAR_REF,
+    JS_GC_OBJ_TYPE_ASYNC_FUNCTION,
+} JSGCObjectTypeEnum;
+
+/* header for GC objects. GC objects are C data structures with a
+   reference count that can reference other GC objects. JS Objects are
+   a particular type of GC object. */
+struct JSGCObjectHeader {
+    int ref_count; /* must come first, 32-bit */
+    JSGCObjectTypeEnum gc_obj_type : 4;
+    uint8_t mark : 4; /* used by the GC */
+    uint8_t dummy1; /* not used by the GC */
+    uint16_t dummy2; /* not used by the GC */
+    struct list_head link;
+};
 
 typedef struct JSVarRef {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    JSGCHeader gc_header; /* must come after JSRefCountHeader, 8-bit */
-    uint8_t is_arg : 1;
-    int var_idx; /* index of the corresponding function variable on
-                    the stack */
-    struct list_head link; /* prev = NULL if no longer on the stack */
+    union {
+        JSGCObjectHeader header; /* must come first */
+        struct {
+            int __gc_ref_count; /* corresponds to header.ref_count */
+            uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
+
+            /* 0 : the JSVarRef is on the stack. header.link is an element
+               of JSStackFrame.var_ref_list.
+               1 : the JSVarRef is detached. header.link has the normal meanning 
+            */
+            uint8_t is_detached : 1; 
+            uint8_t is_arg : 1;
+            uint16_t var_idx; /* index of the corresponding function variable on
+                                 the stack */
+        };
+    };
     JSValue *pvalue; /* pointer to the value, either on the stack or
                         to 'value' */
     JSValue value; /* used when the variable is no longer on the stack */
@@ -320,10 +356,6 @@ struct JSContext {
     size_t stack_size; /* in bytes */
 
     JSValue current_exception;
-    /* true if a backtrace needs to be added to the current exception
-       (the backtrace generation cannot be done immediately in a bytecode
-       function) */
-    BOOL exception_needs_backtrace : 8;
     /* true if inside an out of memory error, to avoid recursing */
     BOOL in_out_of_memory : 8;
     uint16_t binary_object_count;
@@ -478,8 +510,7 @@ typedef enum JSFunctionKindEnum {
 } JSFunctionKindEnum;
 
 typedef struct JSFunctionBytecode {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    JSGCHeader gc_header; /* must come after header, 8-bit */
+    JSGCObjectHeader header; /* must come first */
     uint8_t js_mode;
     uint8_t has_prototype : 1; /* true if a prototype field is necessary */
     uint8_t has_simple_parameter_list : 1;
@@ -492,6 +523,7 @@ typedef struct JSFunctionBytecode {
     uint8_t super_allowed : 1;
     uint8_t arguments_allowed : 1;
     uint8_t has_debug : 1;
+    uint8_t backtrace_barrier : 1; /* stop backtrace on this function */
     uint8_t read_only_bytecode : 1;
     /* XXX: 4 bits available */
     uint8_t *byte_code_buf; /* (self pointer) */
@@ -578,8 +610,7 @@ typedef struct JSAsyncFunctionState {
 /* XXX: could use an object instead to avoid the
    JS_TAG_ASYNC_FUNCTION tag for the GC */
 typedef struct JSAsyncFunctionData {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    JSGCHeader gc_header; /* must come after JSRefCountHeader, 8-bit */
+    JSGCObjectHeader header; /* must come first */
     JSValue resolving_funcs[2];
     BOOL is_active; /* true if the async function state is valid */
     JSAsyncFunctionState func_state;
@@ -691,8 +722,7 @@ typedef struct JSShapeProperty {
 struct JSShape {
     uint32_t prop_hash_end[0]; /* hash table of size hash_mask + 1
                                   before the start of the structure. */
-    JSRefCountHeader header; /* must come first, 32-bit */
-    JSGCHeader gc_header; /* must come after JSRefCountHeader, 8-bit */
+    JSGCObjectHeader header;
     /* true if the shape is inserted in the shape hash table. If not,
        JSShape.hash is not valid */
     uint8_t is_hashed;
@@ -709,19 +739,23 @@ struct JSShape {
     JSShapeProperty prop[0]; /* prop_size elements */
 };
 struct JSObject {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    JSGCHeader gc_header; /* must come after JSRefCountHeader, 8-bit */
-    uint8_t extensible : 1;
-    uint8_t free_mark : 1; /* only used when freeing objects with cycles */
-    uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
-    uint8_t fast_array : 1; /* TRUE if u.array is used for get/put */
-    uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
-    uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
-    uint8_t is_class : 1; /* TRUE if object is a class constructor */
-    uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
-    uint16_t class_id; /* see JS_CLASS_x */
-    /* byte offsets: 8/8 */
-    struct list_head link; /* object list */
+    union {
+        JSGCObjectHeader header;
+        struct {
+            int __gc_ref_count; /* corresponds to header.ref_count */
+            uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
+            
+            uint8_t extensible : 1;
+            uint8_t free_mark : 1; /* only used when freeing objects with cycles */
+            uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
+            uint8_t fast_array : 1; /* TRUE if u.array is used for get/put */
+            uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
+            uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
+            uint8_t is_class : 1; /* TRUE if object is a class constructor */
+            uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
+            uint16_t class_id; /* see JS_CLASS_x */
+        };
+    };
     /* byte offsets: 16/24 */
     JSShape *shape; /* prototype and property names + flag */
     JSProperty *prop; /* array of properties */
@@ -839,6 +873,12 @@ static JSAtom __JS_NewAtomInit(JSRuntime *rt, const char *str, int len,
                                int atom_type);
 static void JS_FreeAtomStruct(JSRuntime *rt, JSAtomStruct *p);
 static void free_function_bytecode(JSRuntime *rt, JSFunctionBytecode *b);
+static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
+                                  JSValueConst this_obj,
+                                  int argc, JSValueConst *argv, int flags);
+static JSValue js_call_bound_function(JSContext *ctx, JSValueConst func_obj,
+                                      JSValueConst this_obj,
+                                      int argc, JSValueConst *argv, int flags);
 static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                                JSValueConst this_obj, JSValueConst new_target,
                                int argc, JSValue *argv, int flags);
@@ -860,6 +900,7 @@ static __maybe_unused void JS_DumpString(JSRuntime *rt,
                                                   const JSString *p);
 static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt);
 static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p);
+static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p);
 static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
                                                       JSValueConst val);
 static __maybe_unused void JS_DumpValue(JSContext *ctx, JSValueConst val);
@@ -913,10 +954,6 @@ static void js_promise_mark(JSRuntime *rt, JSValueConst val,
 static void js_promise_resolve_function_finalizer(JSRuntime *rt, JSValue val);
 static void js_promise_resolve_function_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
-static JSValue js_promise_resolve_function_call(JSContext *ctx,
-                                                JSValueConst func_obj,
-                                                JSValueConst this_val,
-                                                int argc, JSValueConst *argv);
 static JSValue JS_ToStringFree(JSContext *ctx, JSValue val);
 static int JS_ToBoolFree(JSContext *ctx, JSValue val);
 static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val);
@@ -956,12 +993,6 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
 #endif
 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
 static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx);
-static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
-                             JSValueConst this_obj,
-                             int argc, JSValueConst *argv);
-static JSValue js_proxy_call_constructor(JSContext *ctx, JSValueConst func_obj,
-                                         JSValueConst new_target,
-                                         int argc, JSValueConst *argv);
 static JSValueConst js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj);
 static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
                                    JSValueConst proto_val, BOOL throw_flag);
@@ -981,7 +1012,8 @@ static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf, int var_idx,
                              BOOL is_arg);
 static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
                                           JSValueConst this_obj,
-                                          int argc, JSValueConst *argv);
+                                          int argc, JSValueConst *argv,
+                                          int flags);
 static void js_async_function_resolve_finalizer(JSRuntime *rt, JSValue val);
 static void js_async_function_resolve_mark(JSRuntime *rt, JSValueConst val,
                                            JS_MarkFunc *mark_func);
@@ -1036,8 +1068,12 @@ static void js_c_function_data_mark(JSRuntime *rt, JSValueConst val,
                                     JS_MarkFunc *mark_func);
 static JSValue js_c_function_data_call(JSContext *ctx, JSValueConst func_obj,
                                        JSValueConst this_val,
-                                       int argc, JSValueConst *argv);
+                                       int argc, JSValueConst *argv, int flags);
 static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val);
+static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
+                          JSGCObjectTypeEnum type);
+static void remove_gc_object(JSGCObjectHeader *h);
+static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
 static const JSClassExoticMethods js_string_exotic_methods;
@@ -1309,7 +1345,10 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
 #endif
 
     init_list_head(&rt->context_list);
-    init_list_head(&rt->obj_list);
+    init_list_head(&rt->gc_obj_list);
+    init_list_head(&rt->gc_zero_ref_count_list);
+    rt->gc_phase = JS_GC_PHASE_NONE;
+    
 #ifdef DUMP_LEAKS
     init_list_head(&rt->string_list);
 #endif
@@ -1326,7 +1365,9 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->class_array[JS_CLASS_STRING].exotic = &js_string_exotic_methods;
     rt->class_array[JS_CLASS_MODULE_NS].exotic = &js_module_ns_exotic_methods;
 
+    rt->class_array[JS_CLASS_C_FUNCTION].call = js_call_c_function;
     rt->class_array[JS_CLASS_C_FUNCTION_DATA].call = js_c_function_data_call;
+    rt->class_array[JS_CLASS_BOUND_FUNCTION].call = js_call_bound_function;
     rt->class_array[JS_CLASS_GENERATOR_FUNCTION].call = js_generator_function_call;
     if (init_shape_hash(rt))
         goto fail;
@@ -1605,34 +1646,34 @@ void JS_FreeRuntime(JSRuntime *rt)
     /* leaking objects */
     {
         BOOL header_done;
-        JSObject *p;
+        JSGCObjectHeader *p;
         int count;
 
         /* remove the internal refcounts to display only the object
            referenced externally */
-        list_for_each(el, &rt->obj_list) {
-            p = list_entry(el, JSObject, link);
-            p->gc_header.mark = 0;
+        list_for_each(el, &rt->gc_obj_list) {
+            p = list_entry(el, JSGCObjectHeader, link);
+            p->mark = 0;
         }
         gc_decref(rt);
 
         header_done = FALSE;
-        list_for_each(el, &rt->obj_list) {
-            p = list_entry(el, JSObject, link);
-            if (p->header.ref_count != 0) {
+        list_for_each(el, &rt->gc_obj_list) {
+            p = list_entry(el, JSGCObjectHeader, link);
+            if (p->ref_count != 0) {
                 if (!header_done) {
                     printf("Object leaks:\n");
                     JS_DumpObjectHeader(rt);
                     header_done = TRUE;
                 }
-                JS_DumpObject(rt, p);
+                JS_DumpGCObject(rt, p);
             }
         }
 
         count = 0;
-        list_for_each(el, &rt->obj_list) {
-            p = list_entry(el, JSObject, link);
-            if (p->header.ref_count == 0) {
+        list_for_each(el, &rt->gc_obj_list) {
+            p = list_entry(el, JSGCObjectHeader, link);
+            if (p->ref_count == 0) {
                 count++;
             }
         }
@@ -1640,7 +1681,7 @@ void JS_FreeRuntime(JSRuntime *rt)
             printf("Secondary object leaks: %d\n", count);
     }
 #endif
-    assert(list_empty(&rt->obj_list));
+    assert(list_empty(&rt->gc_obj_list));
 
     /* free the classes */
     for(i = 0; i < rt->class_count; i++) {
@@ -1922,12 +1963,12 @@ void JS_FreeContext(JSContext *ctx)
 #ifdef DUMP_OBJECTS
     {
         struct list_head *el;
-        JSObject *p;
+        JSGCObjectHeader *p;
         printf("JSObjects: {\n");
         JS_DumpObjectHeader(ctx->rt);
-        list_for_each(el, &rt->obj_list) {
-            p = list_entry(el, JSObject, link);
-            JS_DumpObject(rt, p);
+        list_for_each(el, &rt->gc_obj_list) {
+            p = list_entry(el, JSGCObjectHeader, link);
+            JS_DumpGCObject(rt, p);
         }
         printf("}\n");
     }
@@ -3995,7 +4036,7 @@ static no_inline JSShape *js_new_shape2(JSContext *ctx, JSObject *proto,
         return NULL;
     sh = get_shape_from_alloc(sh_alloc, hash_size);
     sh->header.ref_count = 1;
-    sh->gc_header.mark = 0;
+    add_gc_object(rt, &sh->header, JS_GC_OBJ_TYPE_SHAPE);
     if (proto)
         JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, proto));
     sh->proto = proto;
@@ -4038,7 +4079,7 @@ static JSShape *js_clone_shape(JSContext *ctx, JSShape *sh1)
     memcpy(sh_alloc, sh_alloc1, size);
     sh = get_shape_from_alloc(sh_alloc, hash_size);
     sh->header.ref_count = 1;
-    sh->gc_header.mark = 0;
+    add_gc_object(ctx->rt, &sh->header, JS_GC_OBJ_TYPE_SHAPE);
     sh->is_hashed = FALSE;
     if (sh->proto) {
         JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, sh->proto));
@@ -4055,24 +4096,30 @@ static JSShape *js_dup_shape(JSShape *sh)
     return sh;
 }
 
-static void js_free_shape(JSRuntime *rt, JSShape *sh)
+static void js_free_shape0(JSRuntime *rt, JSShape *sh)
 {
     uint32_t i;
     JSShapeProperty *pr;
 
+    assert(sh->header.ref_count == 0);
+    if (sh->is_hashed)
+        js_shape_hash_unlink(rt, sh);
+    if (sh->proto != NULL) {
+        JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, sh->proto));
+    }
+    pr = get_shape_prop(sh);
+    for(i = 0; i < sh->prop_count; i++) {
+        JS_FreeAtomRT(rt, pr->atom);
+        pr++;
+    }
+    remove_gc_object(&sh->header);
+    js_free_rt(rt, get_alloc_from_shape(sh));
+}
+
+static void js_free_shape(JSRuntime *rt, JSShape *sh)
+{
     if (unlikely(--sh->header.ref_count <= 0)) {
-        assert(sh->header.ref_count == 0);
-        if (sh->is_hashed)
-            js_shape_hash_unlink(rt, sh);
-        if (sh->proto != NULL) {
-            JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, sh->proto));
-        }
-        pr = get_shape_prop(sh);
-        for(i = 0; i < sh->prop_count; i++) {
-            JS_FreeAtomRT(rt, pr->atom);
-            pr++;
-        }
-        js_free_rt(rt, get_alloc_from_shape(sh));
+        js_free_shape0(rt, sh);
     }
 }
 
@@ -4114,9 +4161,11 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
         if (!sh_alloc)
             return -1;
         sh = get_shape_from_alloc(sh_alloc, new_hash_size);
+        list_del(&old_sh->header.link);
         /* copy all the fields and the properties */
         memcpy(sh, old_sh,
                sizeof(JSShape) + sizeof(sh->prop[0]) * old_sh->prop_count);
+        list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
         new_hash_mask = new_hash_size - 1;
         sh->prop_hash_mask = new_hash_mask;
         memset(sh->prop_hash_end - new_hash_size, 0,
@@ -4131,11 +4180,16 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
         js_free(ctx, get_alloc_from_shape(old_sh));
     } else {
         /* only resize the properties */
+        list_del(&sh->header.link);
         sh_alloc = js_realloc(ctx, get_alloc_from_shape(sh),
                               get_shape_size(new_hash_size, new_size));
-        if (unlikely(!sh_alloc))
+        if (unlikely(!sh_alloc)) {
+            /* insert again in the GC list */
+            list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
             return -1;
+        }
         sh = get_shape_from_alloc(sh_alloc, new_hash_size);
+        list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
     }
     *psh = sh;
     sh->prop_size = new_size;
@@ -4260,7 +4314,8 @@ static __maybe_unused void JS_DumpShapes(JSRuntime *rt)
     JSShape *sh;
     struct list_head *el;
     JSObject *p;
-
+    JSGCObjectHeader *gp;
+    
     printf("JSShapes: {\n");
     printf("%5s %4s %14s %5s %5s %s\n", "SLOT", "REFS", "PROTO", "SIZE", "COUNT", "PROPS");
     for(i = 0; i < rt->shape_hash_size; i++) {
@@ -4270,10 +4325,13 @@ static __maybe_unused void JS_DumpShapes(JSRuntime *rt)
         }
     }
     /* dump non-hashed shapes */
-    list_for_each(el, &rt->obj_list) {
-        p = list_entry(el, JSObject, link);
-        if (!p->shape->is_hashed) {
-            JS_DumpShape(rt, -1, p->shape);
+    list_for_each(el, &rt->gc_obj_list) {
+        gp = list_entry(el, JSGCObjectHeader, link);
+        if (gp->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT) {
+            p = (JSObject *)gp;
+            if (!p->shape->is_hashed) {
+                JS_DumpShape(rt, -1, p->shape);
+            }
         }
     }
     printf("}\n");
@@ -4287,8 +4345,6 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     p = js_malloc(ctx, sizeof(JSObject));
     if (unlikely(!p))
         goto fail;
-    p->header.ref_count = 1;
-    p->gc_header.mark = 0;
     p->class_id = class_id;
     p->extensible = TRUE;
     p->free_mark = 0;
@@ -4368,7 +4424,8 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
         }
         break;
     }
-    list_add_tail(&p->link, &ctx->rt->obj_list);
+    p->header.ref_count = 1;
+    add_gc_object(ctx->rt, &p->header, JS_GC_OBJ_TYPE_JS_OBJECT);
     return JS_MKPTR(JS_TAG_OBJECT, p);
 }
 
@@ -4637,7 +4694,7 @@ static void js_c_function_data_mark(JSRuntime *rt, JSValueConst val,
 
 static JSValue js_c_function_data_call(JSContext *ctx, JSValueConst func_obj,
                                        JSValueConst this_val,
-                                       int argc, JSValueConst *argv)
+                                       int argc, JSValueConst *argv, int flags)
 {
     JSCFunctionDataRecord *s = JS_GetOpaque(func_obj, JS_CLASS_C_FUNCTION_DATA);
     JSValueConst *arg_buf;
@@ -4758,10 +4815,11 @@ static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref)
     if (var_ref) {
         assert(var_ref->header.ref_count > 0);
         if (--var_ref->header.ref_count == 0) {
-            if (var_ref->link.prev != NULL) {
-                list_del(&var_ref->link); /* still on the stack */
-            } else {
+            if (var_ref->is_detached) {
                 JS_FreeValueRT(rt, var_ref->value);
+                remove_gc_object(&var_ref->header);
+            } else {
+                list_del(&var_ref->header.link); /* still on the stack */
             }
             js_free_rt(rt, var_ref);
         }
@@ -4843,9 +4901,8 @@ static void js_bytecode_function_mark(JSRuntime *rt, JSValueConst val,
         if (var_refs) {
             for(i = 0; i < b->closure_var_count; i++) {
                 JSVarRef *var_ref = var_refs[i];
-                if (var_ref) {
-                    JS_MarkValue(rt, JS_MKPTR(JS_TAG_VAR_REF, var_ref),
-                                 mark_func);
+                if (var_ref && var_ref->is_detached) {
+                    mark_func(rt, &var_ref->header);
                 }
             }
         }
@@ -4898,13 +4955,15 @@ static void js_for_in_iterator_mark(JSRuntime *rt, JSValueConst val,
     JS_MarkValue(rt, it->obj, mark_func);
 }
 
-static void free_object_struct(JSRuntime *rt, JSObject *p)
+static void free_object(JSRuntime *rt, JSObject *p)
 {
     int i;
     JSClassFinalizer *finalizer;
     JSShape *sh;
     JSShapeProperty *pr;
 
+    p->free_mark = 1; /* used to tell the object is invalid when
+                         freeing cycles */
     /* free all the fields */
     sh = p->shape;
     pr = get_shape_prop(sh);
@@ -4913,6 +4972,8 @@ static void free_object_struct(JSRuntime *rt, JSObject *p)
         pr++;
     }
     js_free_rt(rt, p->prop);
+    /* as an optimization we destroy the shape immediately without
+       putting it in gc_zero_ref_count_list */
     js_free_shape(rt, sh);
 
     /* fail safe */
@@ -4932,33 +4993,44 @@ static void free_object_struct(JSRuntime *rt, JSObject *p)
     p->u.opaque = NULL;
     p->u.func.var_refs = NULL;
     p->u.func.home_object = NULL;
-}
-
-static void free_object2(JSRuntime *rt, JSObject *p)
-{
-    if (p->free_mark) {
-        /* already freed (happen when freeing cycles) */
-        return;
-    }
-    /* indicate that the object is being freed */
-    p->free_mark = 1;
-
-    free_object_struct(rt, p);
 
-    /* remove from the global object list */
-    list_del(&p->link);
-    if (rt->in_gc_sweep) {
-        list_add_tail(&p->link, &rt->free_obj_list);
+    remove_gc_object(&p->header);
+    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES && p->header.ref_count != 0) {
+        list_add_tail(&p->header.link, &rt->gc_zero_ref_count_list);
     } else {
         js_free_rt(rt, p);
     }
 }
 
-static void free_object(JSRuntime *rt, JSObject *p)
+static void free_gc_object(JSRuntime *rt, JSGCObjectHeader *gp)
+{
+    switch(gp->gc_obj_type) {
+    case JS_GC_OBJ_TYPE_JS_OBJECT:
+        free_object(rt, (JSObject *)gp);
+        break;
+    case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
+        free_function_bytecode(rt, (JSFunctionBytecode *)gp);
+        break;
+    default:
+        abort();
+    }
+}
+
+static void free_zero_refcount(JSRuntime *rt)
 {
-    assert(p->header.ref_count == 0);
-    if (!rt->in_gc_sweep)
-        free_object2(rt, p);
+    struct list_head *el;
+    JSGCObjectHeader *p;
+    
+    rt->gc_phase = JS_GC_PHASE_DECREF;
+    for(;;) {
+        el = rt->gc_zero_ref_count_list.next;
+        if (el == &rt->gc_zero_ref_count_list)
+            break;
+        p = list_entry(el, JSGCObjectHeader, link);
+        assert(p->ref_count == 0);
+        free_gc_object(rt, p);
+    }
+    rt->gc_phase = JS_GC_PHASE_NONE;
 }
 
 /* called with the ref_count of 'v' reaches zero. */
@@ -4993,14 +5065,18 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v)
         }
         break;
     case JS_TAG_OBJECT:
-        free_object(rt, JS_VALUE_GET_OBJ(v));
-        break;
     case JS_TAG_FUNCTION_BYTECODE:
-        free_function_bytecode(rt, JS_VALUE_GET_PTR(v));
+        {
+            JSGCObjectHeader *p = JS_VALUE_GET_PTR(v);
+            if (rt->gc_phase != JS_GC_PHASE_REMOVE_CYCLES) {
+                list_del(&p->link);
+                list_add(&p->link, &rt->gc_zero_ref_count_list);
+                if (rt->gc_phase == JS_GC_PHASE_NONE) {
+                    free_zero_refcount(rt);
+                }
+            }
+        }
         break;
-    case JS_TAG_SHAPE:
-    case JS_TAG_ASYNC_FUNCTION:
-    case JS_TAG_VAR_REF:
     case JS_TAG_MODULE:
         abort(); /* never freed here */
         break;
@@ -5033,38 +5109,45 @@ void __JS_FreeValue(JSContext *ctx, JSValue v)
 
 /* garbage collection */
 
-static BOOL has_children(JSValueConst val)
+static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
+                          JSGCObjectTypeEnum type)
 {
-    switch(JS_VALUE_GET_TAG(val)) {
-    case JS_TAG_VAR_REF:
-    case JS_TAG_OBJECT:
-    case JS_TAG_FUNCTION_BYTECODE:
-    case JS_TAG_ASYNC_FUNCTION:
-    case JS_TAG_SHAPE:
-        return TRUE;
-    default:
-        return FALSE;
-    }
+    h->mark = 0;
+    h->gc_obj_type = type;
+    list_add_tail(&h->link, &rt->gc_obj_list);
+}
+
+static void remove_gc_object(JSGCObjectHeader *h)
+{
+    list_del(&h->link);
 }
 
 void JS_MarkValue(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func)
 {
-    if (JS_VALUE_HAS_REF_COUNT(val) && has_children(val)) {
-        mark_func(rt, val);
+    if (JS_VALUE_HAS_REF_COUNT(val)) {
+        switch(JS_VALUE_GET_TAG(val)) {
+        case JS_TAG_OBJECT:
+        case JS_TAG_FUNCTION_BYTECODE:
+            mark_func(rt, JS_VALUE_GET_PTR(val));
+            break;
+        default:
+            break;
+        }
     }
 }
 
-static void mark_children(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func)
+static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
+                          JS_MarkFunc *mark_func)
 {
-    switch(JS_VALUE_GET_TAG(val)) {
-    case JS_TAG_OBJECT:
+    switch(gp->gc_obj_type) {
+    case JS_GC_OBJ_TYPE_JS_OBJECT:
         {
-            JSObject *p = JS_VALUE_GET_OBJ(val);
+            JSObject *p = (JSObject *)gp;
             JSShapeProperty *prs;
             JSShape *sh;
             int i;
             sh = p->shape;
-            mark_func(rt, JS_MKPTR(JS_TAG_SHAPE, sh));
+            mark_func(rt, &sh->header);
             /* mark all the fields */
             prs = get_shape_prop(sh);
             for(i = 0; i < sh->prop_count; i++) {
@@ -5073,11 +5156,15 @@ static void mark_children(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_fun
                     if (prs->flags & JS_PROP_TMASK) {
                         if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
                             if (pr->u.getset.getter)
-                                mark_func(rt, JS_MKPTR(JS_TAG_OBJECT, pr->u.getset.getter));
+                                mark_func(rt, &pr->u.getset.getter->header);
                             if (pr->u.getset.setter)
-                                mark_func(rt, JS_MKPTR(JS_TAG_OBJECT, pr->u.getset.setter));
+                                mark_func(rt, &pr->u.getset.setter->header);
                         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
-                            JS_MarkValue(rt, JS_MKPTR(JS_TAG_VAR_REF, pr->u.var_ref), mark_func);
+                            if (pr->u.var_ref->is_detached) {
+                                /* Note: the tag does not matter
+                                   provided it is a GC object */
+                                mark_func(rt, &pr->u.var_ref->header);
+                            }
                         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
                             /* nothing to do */
                         }
@@ -5096,46 +5183,43 @@ static void mark_children(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_fun
             }
         }
         break;
-    case JS_TAG_FUNCTION_BYTECODE:
+    case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
         /* the template objects can be part of a cycle */
         {
-            JSFunctionBytecode *b = JS_VALUE_GET_PTR(val);
+            JSFunctionBytecode *b = (JSFunctionBytecode *)gp;
             int i;
             for(i = 0; i < b->cpool_count; i++) {
                 JS_MarkValue(rt, b->cpool[i], mark_func);
             }
         }
         break;
-    case JS_TAG_VAR_REF:
+    case JS_GC_OBJ_TYPE_VAR_REF:
         {
-            JSVarRef *var_ref = JS_VALUE_GET_PTR(val);
-            /* the refcount of stack values is not incremented, hence
-               the test */
-            if (var_ref->link.prev == NULL) {
-                JS_MarkValue(rt, *var_ref->pvalue, mark_func);
-            }
+            JSVarRef *var_ref = (JSVarRef *)gp;
+            /* only detached variable referenced are taken into account */
+            assert(var_ref->is_detached);
+            JS_MarkValue(rt, *var_ref->pvalue, mark_func);
         }
         break;
-    case JS_TAG_ASYNC_FUNCTION:
+    case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
         {
-            JSAsyncFunctionData *s = JS_VALUE_GET_PTR(val);
+            JSAsyncFunctionData *s = (JSAsyncFunctionData *)gp;
             if (s->is_active)
                 async_func_mark(rt, &s->func_state, mark_func);
             JS_MarkValue(rt, s->resolving_funcs[0], mark_func);
             JS_MarkValue(rt, s->resolving_funcs[1], mark_func);
         }
         break;
-    case JS_TAG_SHAPE:
+    case JS_GC_OBJ_TYPE_SHAPE:
         {
-            JSShape *sh = JS_VALUE_GET_PTR(val);
+            JSShape *sh = (JSShape *)gp;
             if (sh->proto != NULL) {
-                mark_func(rt, JS_MKPTR(JS_TAG_OBJECT, sh->proto));
+                mark_func(rt, &sh->proto->header);
             }
         }
         break;
     default:
-        /* no children */
-        break;
+        abort();
     }
 }
 
@@ -5173,190 +5257,122 @@ static void mark_context(JSRuntime *rt, JSContext *ctx)
 }
 #endif
 
-/* 1 = possible member of a cycle
-   2 = member of a cycle
-*/
-
-static void gc_decref_mark(JSRuntime *rt, JSValueConst obj);
-
-//#define DUMP_GC_DECREF
-
-#ifdef DUMP_GC_DECREF
-static int decref_indent;
-#endif
-
-static void gc_decref_child(JSRuntime *rt, JSValueConst obj)
+static void gc_decref_child(JSRuntime *rt, JSGCObjectHeader *p)
 {
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-
-#ifdef DUMP_LEAKS
-#ifdef DUMP_GC_DECREF
-    {
-        int i;
-        for(i = 0; i < decref_indent; i++)
-                printf("  ");
-        if (JS_IsObject(obj)) {
-            JS_DumpObject(rt, p);
-        } else {
-            JS_DumpValueShort(rt, obj); printf("\n");
-        }
-    }
-#endif
-    if (p->header.ref_count <= 0) {
-        printf("%p: invalid refcount (%d)\n", p, p->header.ref_count);
-        if (JS_IsObject(obj)) {
-            JS_DumpObject(rt, p);
-        } else {
-            JS_DumpValueShort(rt, obj);
-        }
-    }
-#endif
-    assert(p->header.ref_count > 0);
-    p->header.ref_count--;
-    gc_decref_mark(rt, obj);
-}
-
-static void gc_decref_mark(JSRuntime *rt, JSValueConst obj)
-{
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    if (p->gc_header.mark == 0) {
-        p->gc_header.mark = 1;
-#ifdef DUMP_GC_DECREF
-        decref_indent++;
-#endif
-        mark_children(rt, obj, gc_decref_child);
-#ifdef DUMP_GC_DECREF
-        decref_indent--;
-#endif
+    assert(p->ref_count > 0);
+    p->ref_count--;
+    if (p->ref_count == 0 && p->mark == 1) {
+        list_del(&p->link);
+        list_add_tail(&p->link, &rt->tmp_obj_list);
     }
 }
 
 static void gc_decref(JSRuntime *rt)
 {
-    struct list_head *el;
-    JSObject *p;
-
-    list_for_each(el, &rt->obj_list) {
-        p = list_entry(el, JSObject, link);
-        gc_decref_mark(rt, JS_MKPTR(JS_TAG_OBJECT, p));
-    }
-}
-
-static void gc_scan_incref(JSRuntime *rt, JSValueConst obj);
-
-static void gc_scan_incref_child(JSRuntime *rt, JSValueConst obj)
-{
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    p->header.ref_count++;
-    if (p->gc_header.mark != 0) {
-        gc_scan_incref(rt, obj);
+    struct list_head *el, *el1;
+    JSGCObjectHeader *p;
+    
+    init_list_head(&rt->tmp_obj_list);
+
+    /* decrement the refcount of all the children of all the GC
+       objects and move the GC objects with zero refcount to
+       tmp_obj_list */
+    list_for_each_safe(el, el1, &rt->gc_obj_list) {
+        p = list_entry(el, JSGCObjectHeader, link);
+        assert(p->mark == 0);
+        mark_children(rt, p, gc_decref_child);
+        p->mark = 1;
+        if (p->ref_count == 0) {
+            list_del(&p->link);
+            list_add_tail(&p->link, &rt->tmp_obj_list);
+        }
     }
 }
 
-static void gc_scan_incref(JSRuntime *rt, JSValueConst obj)
+static void gc_scan_incref_child(JSRuntime *rt, JSGCObjectHeader *p)
 {
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    p->gc_header.mark = 0; /* not freed */
-    if (JS_IsObject(obj)) {
-        /* remove the tmp_obj_list and update the next object to
-           explore */
-        if (rt->el_next == &p->link)
-            rt->el_next = rt->el_next->next;
-        /* add to rt->obj_list */
+    p->ref_count++;
+    if (p->ref_count == 1) {
+        /* ref_count was 0: remove from tmp_obj_list and add at the
+           end of gc_obj_list */
         list_del(&p->link);
-        list_add_tail(&p->link, &rt->obj_list);
-    }
-    mark_children(rt, obj, gc_scan_incref_child);
-}
-
-static void gc_scan_obj(JSRuntime *rt, JSValueConst obj)
-{
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    if (p->gc_header.mark == 1) {
-        if (p->header.ref_count > 0) {
-            gc_scan_incref(rt, obj);
-        } else {
-            p->gc_header.mark = 2;
-            mark_children(rt, obj, gc_scan_obj);
-        }
+        list_add_tail(&p->link, &rt->gc_obj_list);
+        p->mark = 0; /* reset the mark for the next GC call */
     }
 }
 
-static void gc_scan_obj2(JSRuntime *rt, JSValueConst obj);
-
-static void gc_scan_incref_child2(JSRuntime *rt, JSValueConst obj)
+static void gc_scan_incref_child2(JSRuntime *rt, JSGCObjectHeader *p)
 {
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    p->header.ref_count++;
-    gc_scan_obj2(rt, obj);
-}
-
-static void gc_scan_obj2(JSRuntime *rt, JSValueConst obj)
-{
-    JSObject *p = JS_VALUE_GET_OBJ(obj);
-    if (p->gc_header.mark == 2) {
-        p->gc_header.mark = 3;
-        mark_children(rt, obj, gc_scan_incref_child2);
-    }
+    p->ref_count++;
 }
 
 static void gc_scan(JSRuntime *rt)
 {
     struct list_head *el;
-    JSObject *p;
-
-    /* move obj_list to tmp_obj_list */
-    list_add(&rt->tmp_obj_list, &rt->obj_list);
-    list_del(&rt->obj_list);
-    init_list_head(&rt->obj_list);
+    JSGCObjectHeader *p;
 
-    /* keep the objects with a refcount > 0 and their children. After
-       this pass, obj_list contains the objects to be deleted. Their
-       mark is 2. */
-    for(el = rt->tmp_obj_list.next; el != &rt->tmp_obj_list;
-        el = rt->el_next) {
-        rt->el_next = el->next; /* may be modified by gc_scan_obj() */
-        p = list_entry(el, JSObject, link);
-        gc_scan_obj(rt, JS_MKPTR(JS_TAG_OBJECT, p));
+    /* keep the objects with a refcount > 0 and their children. */
+    list_for_each(el, &rt->gc_obj_list) {
+        p = list_entry(el, JSGCObjectHeader, link);
+        assert(p->ref_count > 0);
+        p->mark = 0; /* reset the mark for the next GC call */
+        mark_children(rt, p, gc_scan_incref_child);
     }
-
-    /* restore the refcount of the objects to be deleted. After this
-       pass, their mark is 3 */
+    
+    /* restore the refcount of the objects to be deleted. */
     list_for_each(el, &rt->tmp_obj_list) {
-        p = list_entry(el, JSObject, link);
-        gc_scan_obj2(rt, JS_MKPTR(JS_TAG_OBJECT, p));
+        p = list_entry(el, JSGCObjectHeader, link);
+        mark_children(rt, p, gc_scan_incref_child2);
     }
 }
 
 static void gc_free_cycles(JSRuntime *rt)
 {
     struct list_head *el, *el1;
-    JSObject *p;
+    JSGCObjectHeader *p;
 #ifdef DUMP_GC_FREE
     BOOL header_done = FALSE;
 #endif
-    init_list_head(&rt->free_obj_list);
-    rt->in_gc_sweep = TRUE;
-    list_for_each_safe(el, el1, &rt->tmp_obj_list) {
-        p = list_entry(el, JSObject, link);
-        assert(p->gc_header.mark == 3);
+
+    rt->gc_phase = JS_GC_PHASE_REMOVE_CYCLES;
+
+    for(;;) {
+        el = rt->tmp_obj_list.next;
+        if (el == &rt->tmp_obj_list)
+            break;
+        p = list_entry(el, JSGCObjectHeader, link);
+        /* Only need to free the GC object associated with JS
+           values. The rest will be automatically removed because they
+           must be referenced by them. */
+        switch(p->gc_obj_type) {
+        case JS_GC_OBJ_TYPE_JS_OBJECT:
+        case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
 #ifdef DUMP_GC_FREE
-        if (!header_done) {
-            printf("Freeing cycles:\n");
-            JS_DumpObjectHeader(rt);
-            header_done = TRUE;
-        }
-        JS_DumpObject(rt, p);
+            if (!header_done) {
+                printf("Freeing cycles:\n");
+                JS_DumpObjectHeader(rt);
+                header_done = TRUE;
+            }
+            JS_DumpGCObject(rt, p);
 #endif
-        free_object2(rt, p);
+            free_gc_object(rt, p);
+            break;
+        default:
+            list_del(&p->link);
+            list_add_tail(&p->link, &rt->gc_zero_ref_count_list);
+            break;
+        }
     }
-    rt->in_gc_sweep = FALSE;
-
-    /* free all the object structures */
-    list_for_each_safe(el, el1, &rt->free_obj_list) {
-        p = list_entry(el, JSObject, link);
+    rt->gc_phase = JS_GC_PHASE_NONE;
+           
+    list_for_each_safe(el, el1, &rt->gc_zero_ref_count_list) {
+        p = list_entry(el, JSGCObjectHeader, link);
+        assert(p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT ||
+               p->gc_obj_type == JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
         js_free_rt(rt, p);
     }
+
+    init_list_head(&rt->gc_zero_ref_count_list);
 }
 
 void JS_RunGC(JSRuntime *rt)
@@ -5365,10 +5381,10 @@ void JS_RunGC(JSRuntime *rt)
        1 after this pass. */
     gc_decref(rt);
 
-    /* keep objects with a non zero refcount and their childs */
+    /* keep the GC objects with a non zero refcount and their childs */
     gc_scan(rt);
 
-    /* free the objects with a zero refcount */
+    /* free the GC objects in a cycle */
     gc_free_cycles(rt);
 }
 
@@ -5384,23 +5400,17 @@ BOOL JS_IsLiveObject(JSRuntime *rt, JSValueConst obj)
     return !p->free_mark;
 }
 
-/* Return true during the GC sweep phase (can be useful inside in finalizer) */
-BOOL JS_IsInGCSweep(JSRuntime *rt)
-{
-    return rt->in_gc_sweep;
-}
-
 /* Compute memory used by various object types */
 /* XXX: poor man's approach to handling multiply referenced objects */
 typedef struct JSMemoryUsage_helper {
     double memory_used_count;
     double str_count;
     double str_size;
-    double js_func_count;
+    int64_t js_func_count;
     double js_func_size;
-    double js_func_code_size;
-    double js_func_pc2line_count;
-    double js_func_pc2line_size;
+    int64_t js_func_code_size;
+    int64_t js_func_pc2line_count;
+    int64_t js_func_pc2line_size;
 } JSMemoryUsage_helper;
 
 static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp);
@@ -5418,7 +5428,6 @@ static void compute_jsstring_size(JSString *str, JSMemoryUsage_helper *hp)
 static void compute_bytecode_size(JSFunctionBytecode *b, JSMemoryUsage_helper *hp)
 {
     int memory_used_count, js_func_size, i;
-    double ref_count = b->header.ref_count;
 
     memory_used_count = 0;
     js_func_size = offsetof(JSFunctionBytecode, debug);
@@ -5436,7 +5445,7 @@ static void compute_bytecode_size(JSFunctionBytecode *b, JSMemoryUsage_helper *h
         js_func_size += b->closure_var_count * sizeof(*b->closure_var);
     }
     if (!b->read_only_bytecode && b->byte_code_buf) {
-        hp->js_func_code_size += b->byte_code_len / ref_count;
+        hp->js_func_code_size += b->byte_code_len;
     }
     if (b->has_debug) {
         js_func_size += sizeof(*b) - offsetof(JSFunctionBytecode, debug);
@@ -5446,13 +5455,13 @@ static void compute_bytecode_size(JSFunctionBytecode *b, JSMemoryUsage_helper *h
         }
         if (b->debug.pc2line_len) {
             memory_used_count++;
-            hp->js_func_pc2line_count += 1 / ref_count;
-            hp->js_func_pc2line_size += b->debug.pc2line_len / ref_count;
+            hp->js_func_pc2line_count += 1;
+            hp->js_func_pc2line_size += b->debug.pc2line_len;
         }
     }
-    hp->js_func_size += js_func_size / ref_count;
-    hp->js_func_count += 1 / ref_count;
-    hp->memory_used_count += memory_used_count / ref_count;
+    hp->js_func_size += js_func_size;
+    hp->js_func_count += 1;
+    hp->memory_used_count += memory_used_count;
 }
 
 static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp)
@@ -5461,9 +5470,6 @@ static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp)
     case JS_TAG_STRING:
         compute_jsstring_size(JS_VALUE_GET_STRING(val), hp);
         break;
-    case JS_TAG_FUNCTION_BYTECODE:
-        compute_bytecode_size(JS_VALUE_GET_PTR(val), hp);
-        break;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
     case JS_TAG_BIG_FLOAT:
@@ -5535,10 +5541,21 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         }
     }
 
-    list_for_each(el, &rt->obj_list) {
-        JSObject *p = list_entry(el, JSObject, link);
-        JSShape *sh = p->shape;
+    list_for_each(el, &rt->gc_obj_list) {
+        JSGCObjectHeader *gp = list_entry(el, JSGCObjectHeader, link);
+        JSObject *p;
+        JSShape *sh;
         JSShapeProperty *prs;
+
+        /* XXX: could count the other GC object types too */
+        if (gp->gc_obj_type == JS_GC_OBJ_TYPE_FUNCTION_BYTECODE) {
+            compute_bytecode_size((JSFunctionBytecode *)gp, hp);
+            continue;
+        } else if (gp->gc_obj_type != JS_GC_OBJ_TYPE_JS_OBJECT) {
+            continue;
+        }
+        p = (JSObject *)gp;
+        sh = p->shape;
         s->obj_count++;
         if (p->prop) {
             s->memory_used_count++;
@@ -5612,7 +5629,6 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
                         }
                     }
                 }
-                compute_bytecode_size(b, hp);
             }
             break;
         case JS_CLASS_BOUND_FUNCTION:    /* u.bound_function */
@@ -5738,11 +5754,11 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
     }
     s->str_count = round(mem.str_count);
     s->str_size = round(mem.str_size);
-    s->js_func_count = round(mem.js_func_count);
+    s->js_func_count = mem.js_func_count;
     s->js_func_size = round(mem.js_func_size);
-    s->js_func_code_size = round(mem.js_func_code_size);
-    s->js_func_pc2line_count = round(mem.js_func_pc2line_count);
-    s->js_func_pc2line_size = round(mem.js_func_pc2line_size);
+    s->js_func_code_size = mem.js_func_code_size;
+    s->js_func_pc2line_count = mem.js_func_pc2line_count;
+    s->js_func_pc2line_size = mem.js_func_pc2line_size;
     s->memory_used_count += round(mem.memory_used_count) +
         s->atom_count + s->str_count +
         s->obj_count + s->shape_count +
@@ -5793,9 +5809,13 @@ void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt)
             int obj_classes[JS_CLASS_INIT_COUNT + 1] = { 0 };
             int class_id;
             struct list_head *el;
-            list_for_each(el, &rt->obj_list) {
-                JSObject *p = list_entry(el, JSObject, link);
-                obj_classes[min_uint32(p->class_id, JS_CLASS_INIT_COUNT)]++;
+            list_for_each(el, &rt->gc_obj_list) {
+                JSGCObjectHeader *gp = list_entry(el, JSGCObjectHeader, link);
+                JSObject *p;
+                if (gp->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT) {
+                    p = (JSObject *)gp;
+                    obj_classes[min_uint32(p->class_id, JS_CLASS_INIT_COUNT)]++;
+                }
             }
             fprintf(fp, "\n" "JSObject classes\n");
             if (obj_classes[0])
@@ -5887,7 +5907,6 @@ JSValue JS_Throw(JSContext *ctx, JSValue obj)
 {
     JS_FreeValue(ctx, ctx->current_exception);
     ctx->current_exception = obj;
-    ctx->exception_needs_backtrace = JS_IsError(ctx, obj);
     return JS_EXCEPTION;
 }
 
@@ -5897,7 +5916,6 @@ JSValue JS_GetException(JSContext *ctx)
     JSValue val;
     val = ctx->current_exception;
     ctx->current_exception = JS_NULL;
-    ctx->exception_needs_backtrace = FALSE;
     return val;
 }
 
@@ -6023,12 +6041,15 @@ static const char *get_func_name(JSContext *ctx, JSValueConst func)
     return JS_ToCString(ctx, val);
 }
 
+#define JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL (1 << 0)
+/* only taken into account if filename is provided */
+#define JS_BACKTRACE_FLAG_SINGLE_LEVEL     (1 << 1)
+
 /* if filename != NULL, an additional level is added with the filename
-   and line number information (used for parse error). If 'pc' !=
-   NULL, it is used as the cur_pc value for the current stack frame */
+   and line number information (used for parse error). */
 static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
                             const char *filename, int line_num,
-                            const uint8_t *cur_pc)
+                            int backtrace_flags)
 {
     JSStackFrame *sf;
     JSValue str;
@@ -6036,8 +6057,8 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
     const char *func_name_str;
     const char *str1;
     JSObject *p;
-
-    ctx->exception_needs_backtrace = FALSE;
+    BOOL backtrace_barrier;
+    
     js_dbuf_init(ctx, &dbuf);
     if (filename) {
         dbuf_printf(&dbuf, "    at %s", filename);
@@ -6049,8 +6070,14 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
         JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_lineNumber, JS_NewInt32(ctx, line_num),
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+        if (backtrace_flags & JS_BACKTRACE_FLAG_SINGLE_LEVEL)
+            goto done;
     }
     for(sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
+        if (backtrace_flags & JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL) {
+            backtrace_flags &= ~JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL;
+            continue;
+        }
         func_name_str = get_func_name(ctx, sf->cur_func);
         if (!func_name_str || func_name_str[0] == '\0')
             str1 = "<anonymous>";
@@ -6060,24 +6087,17 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
         JS_FreeCString(ctx, func_name_str);
 
         p = JS_VALUE_GET_OBJ(sf->cur_func);
+        backtrace_barrier = FALSE;
         if (js_class_has_bytecode(p->class_id)) {
             JSFunctionBytecode *b;
             char atom_buf[ATOM_GET_STR_BUF_SIZE];
             int line_num1;
 
             b = p->u.func.function_bytecode;
+            backtrace_barrier = b->backtrace_barrier;
             if (b->has_debug) {
-                if (sf == ctx->current_stack_frame) {
-                    if (!cur_pc) {
-                        line_num1 = b->debug.line_num;
-                    } else {
-                        line_num1 = find_line_num(ctx, b,
-                                                  cur_pc - b->byte_code_buf - 1);
-                    }
-                } else {
-                    line_num1 = find_line_num(ctx, b,
-                                              sf->cur_pc - b->byte_code_buf - 1);
-                }
+                line_num1 = find_line_num(ctx, b,
+                                          sf->cur_pc - b->byte_code_buf - 1);
                 dbuf_printf(&dbuf, " (%s",
                             JS_AtomGetStr(ctx, atom_buf, sizeof(atom_buf),
                                           b->debug.filename));
@@ -6089,7 +6109,11 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
             dbuf_printf(&dbuf, " (native)");
         }
         dbuf_putc(&dbuf, '\n');
+        /* stop backtrace if JS_EVAL_FLAG_BACKTRACE_BARRIER was used */
+        if (backtrace_barrier)
+            break;
     }
+ done:
     dbuf_putc(&dbuf, '\0');
     str = JS_NewString(ctx, (char *)dbuf.buf);
     dbuf_free(&dbuf);
@@ -6097,13 +6121,27 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
                            JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
 }
 
+/* Note: it is important that no exception is returned by this function */
+static BOOL is_backtrace_needed(JSContext *ctx, JSValueConst obj)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
+        return FALSE;
+    p = JS_VALUE_GET_OBJ(obj);
+    if (p->class_id != JS_CLASS_ERROR)
+        return FALSE;
+    if (find_own_property1(p, JS_ATOM_stack))
+        return FALSE;
+    return TRUE;
+}
+
 JSValue JS_NewError(JSContext *ctx)
 {
     return JS_NewObjectClass(ctx, JS_CLASS_ERROR);
 }
 
-static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
-                             const char *fmt, va_list ap)
+static JSValue JS_ThrowError2(JSContext *ctx, JSErrorEnum error_num,
+                              const char *fmt, va_list ap, BOOL add_backtrace)
 {
     char buf[256];
     JSValue obj, ret;
@@ -6119,10 +6157,25 @@ static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
                                JS_NewString(ctx, buf),
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     }
+    if (add_backtrace) {
+        build_backtrace(ctx, obj, NULL, 0, 0);
+    }
     ret = JS_Throw(ctx, obj);
     return ret;
 }
 
+static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
+                             const char *fmt, va_list ap)
+{
+    JSStackFrame *sf;
+    BOOL add_backtrace;
+
+    /* the backtrace is added later if called from a bytecode function */
+    sf = ctx->current_stack_frame;
+    add_backtrace = !sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL);
+    return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
+}
+
 JSValue __attribute__((format(printf, 2, 3))) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
@@ -9071,8 +9124,6 @@ BOOL JS_IsFunction(JSContext *ctx, JSValueConst val)
     p = JS_VALUE_GET_OBJ(val);
     switch(p->class_id) {
     case JS_CLASS_BYTECODE_FUNCTION:
-    case JS_CLASS_C_FUNCTION:
-    case JS_CLASS_BOUND_FUNCTION:
         return TRUE;
     case JS_CLASS_PROXY:
         return p->u.proxy_data->is_func;
@@ -9102,8 +9153,7 @@ BOOL JS_IsConstructor(JSContext *ctx, JSValueConst val)
     return p->is_constructor;
 }
 
-static BOOL JS_SetConstructorBit(JSContext *ctx, JSValueConst func_obj,
-                                 BOOL val)
+BOOL JS_SetConstructorBit(JSContext *ctx, JSValueConst func_obj, BOOL val)
 {
     JSObject *p;
     if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
@@ -9119,22 +9169,7 @@ BOOL JS_IsError(JSContext *ctx, JSValueConst val)
     if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
         return FALSE;
     p = JS_VALUE_GET_OBJ(val);
-    if (p->class_id == JS_CLASS_ERROR)
-        return TRUE;
-    if (ctx->is_error_property_enabled) {
-        /* check for a special property for test262 test suites */
-        JSValue isError;
-        isError = JS_GetPropertyStr(ctx, val, "isError");
-        return JS_ToBoolFree(ctx, isError);
-    } else {
-        return FALSE;
-    }
-}
-
-/* only used for test262 test suites */
-void JS_EnableIsErrorProperty(JSContext *ctx, BOOL enable)
-{
-    ctx->is_error_property_enabled = enable;
+    return (p->class_id == JS_CLASS_ERROR);
 }
 
 /* used to avoid catching interrupt exceptions */
@@ -9377,7 +9412,6 @@ static JSValue js_atof(JSContext *ctx, const char *p, const char **pp,
         prec = ctx->fp_env.prec;
         flags |= ctx->fp_env.flags;
     }
-    p += skip_spaces(p);
     res = bf_atof(a, p, &p, radix, prec, flags);
     if ((flags & BF_ATOF_THROW) && bf_is_nan(a)) {
         bf_delete(a);
@@ -9418,8 +9452,6 @@ static inline int to_digit(int c)
 #define ATOD_THROW           (1 << 1)
 /* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
 #define ATOD_ACCEPT_BIN_OCT  (1 << 2)
-/* if set return NaN if empty number string */
-#define ATOD_NAN_IF_EMPTY    (1 << 3)
 /* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
 #define ATOD_ACCEPT_LEGACY_OCTAL  (1 << 4)
 /* accept _ between digits as a digit separator */
@@ -9438,7 +9470,7 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
     /* optional separator between digits */
     sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
 
-    p = str + skip_spaces(str);
+    p = str;
     p_start = p;
     is_neg = 0;
     if (p[0] == '+') {
@@ -9575,10 +9607,10 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
         }
     }
 done:
-    if (is_neg)
-        d = -d;
-    if (p == p_start && (flags & ATOD_NAN_IF_EMPTY)) {
+    if (p == p_start) {
         d = JS_FLOAT64_NAN;
+    } else if (is_neg) {
+        d = -d;
     }
     if (pp)
         *pp = p;
@@ -9644,29 +9676,36 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
         {
             const char *str;
             const char *p;
-
-            str = JS_ToCString(ctx, val);
+            size_t len;
+            
+            str = JS_ToCStringLen(ctx, &len, val);
             JS_FreeValue(ctx, val);
             if (!str)
                 return JS_EXCEPTION;
+            p = str;
+            p += skip_spaces(p);
+            if ((p - str) == len) {
+                ret = JS_NewInt32(ctx, 0);
+            } else {
 #ifdef CONFIG_BIGNUM
-            {
-                int flags;
-                flags = BF_ATOF_BIN_OCT | BF_ATOF_NO_PREFIX_AFTER_SIGN |
-                    BF_ATOF_JS_QUIRKS | BF_ATOF_FLOAT64;
-                if (is_bignum_mode(ctx))
-                    flags |= BF_ATOF_INT_PREC_INF;
-                else
-                    flags |= BF_ATOF_ONLY_DEC_FLOAT;
-                ret = js_atof(ctx, str, &p, 0, flags);
-            }
+                {
+                    int flags;
+                    flags = BF_ATOF_BIN_OCT | BF_ATOF_NO_PREFIX_AFTER_SIGN |
+                        BF_ATOF_JS_QUIRKS | BF_ATOF_FLOAT64;
+                    if (is_bignum_mode(ctx))
+                        flags |= BF_ATOF_INT_PREC_INF;
+                    else
+                        flags |= BF_ATOF_ONLY_DEC_FLOAT;
+                    ret = js_atof(ctx, p, &p, 0, flags);
+                }
 #else
-            ret = js_atod(ctx, str, &p, 0, ATOD_ACCEPT_BIN_OCT);
+                ret = js_atod(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT);
 #endif
-            p += skip_spaces(p);
-            if (*p != '\0') {
-                JS_FreeValue(ctx, ret);
-                ret = JS_NAN;
+                p += skip_spaces(p);
+                if ((p - str) != len) {
+                    JS_FreeValue(ctx, ret);
+                    ret = JS_NAN;
+                }
             }
             JS_FreeCString(ctx, str);
         }
@@ -10932,6 +10971,35 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
     printf("\n");
 }
 
+static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p)
+{
+    if (p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT) {
+        JS_DumpObject(rt, (JSObject *)p);
+    } else {
+        printf("%14p %4d ",
+               (void *)p,
+               p->ref_count);
+        switch(p->gc_obj_type) {
+        case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
+            printf("[function bytecode]");
+            break;
+        case JS_GC_OBJ_TYPE_SHAPE:
+            printf("[shape]");
+            break;
+        case JS_GC_OBJ_TYPE_VAR_REF:
+            printf("[var_ref]");
+            break;
+        case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
+            printf("[async_function]");
+            break;
+        default:
+            printf("[unknown %d]", p->gc_obj_type);
+            break;
+        }
+        printf("\n");
+    }
+}
+
 static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
                                                       JSValueConst val)
 {
@@ -11021,9 +11089,6 @@ static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
     case JS_TAG_MODULE:
         printf("[module]");
         break;
-    case JS_TAG_VAR_REF:
-        printf("[var_ref]");
-        break;
     default:
         printf("[unknown tag %d]", tag);
         break;
@@ -11148,11 +11213,11 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
 /* return NaN if bad bigint literal */
 static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
 {
-    const char *str;
-    const char *p;
-    int flags, err;
+    const char *str, *p;
+    size_t len;
+    int flags;
 
-    str = JS_ToCString(ctx, val);
+    str = JS_ToCStringLen(ctx, &len, val);
     JS_FreeValue(ctx, val);
     if (!str)
         return JS_EXCEPTION;
@@ -11160,21 +11225,30 @@ static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
         BF_ATOF_JS_QUIRKS | BF_ATOF_INT_ONLY | BF_ATOF_INT_PREC_INF;
     if (!is_bignum_mode(ctx))
         flags |= BF_ATOF_BIG_INT;
-    val = js_atof(ctx, str, &p, 0, flags);
+    p = str;
     p += skip_spaces(p);
-    err = (*p != '\0');
-    JS_FreeCString(ctx, str);
-    if (err) {
-        JS_FreeValue(ctx, val);
-        val = JS_NAN;
+    if ((p - str) == len) {
+        bf_t a_s, *a = &a_s;
+        bf_init(ctx->bf_ctx, a);
+        bf_set_si(a, 0);
+        val = JS_NewBigInt2(ctx, a, (flags & BF_ATOF_BIG_INT) != 0);
+    } else {
+        val = js_atof(ctx, p, &p, 0, flags);
+        p += skip_spaces(p);
+        if ((p - str) != len) {
+            JS_FreeValue(ctx, val);
+            val = JS_NAN;
+        }
     }
+    JS_FreeCString(ctx, str);
     return val;
 }
 
 static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
 {
     val = JS_StringToBigInt(ctx, val);
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT) {
+    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT &&
+        JS_VALUE_GET_TAG(val) != JS_TAG_INT) {
         JS_FreeValue(ctx, val);
         return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
     }
@@ -14304,7 +14378,7 @@ static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf,
     struct list_head *el;
 
     list_for_each(el, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, link);
+        var_ref = list_entry(el, JSVarRef, header.link);
         if (var_ref->var_idx == var_idx && var_ref->is_arg == is_arg) {
             var_ref->header.ref_count++;
             return var_ref;
@@ -14315,10 +14389,10 @@ static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf,
     if (!var_ref)
         return NULL;
     var_ref->header.ref_count = 1;
-    var_ref->gc_header.mark = 0;
+    var_ref->is_detached = FALSE;
     var_ref->is_arg = is_arg;
     var_ref->var_idx = var_idx;
-    list_add_tail(&var_ref->link, &sf->var_ref_list);
+    list_add_tail(&var_ref->header.link, &sf->var_ref_list);
     if (is_arg)
         var_ref->pvalue = &sf->arg_buf[var_idx];
     else
@@ -14551,15 +14625,16 @@ static void close_var_refs(JSRuntime *rt, JSStackFrame *sf)
     int var_idx;
 
     list_for_each_safe(el, el1, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, link);
+        var_ref = list_entry(el, JSVarRef, header.link);
         var_idx = var_ref->var_idx;
         if (var_ref->is_arg)
             var_ref->value = JS_DupValueRT(rt, sf->arg_buf[var_idx]);
         else
             var_ref->value = JS_DupValueRT(rt, sf->var_buf[var_idx]);
         var_ref->pvalue = &var_ref->value;
-        var_ref->link.prev = NULL; /* the reference is no longer to a
-                                      local variable */
+        /* the reference is no longer to a local variable */
+        var_ref->is_detached = TRUE;
+        add_gc_object(rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
     }
 }
 
@@ -14570,20 +14645,20 @@ static void close_lexical_var(JSContext *ctx, JSStackFrame *sf, int idx, int is_
     int var_idx = idx;
 
     list_for_each_safe(el, el1, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, link);
+        var_ref = list_entry(el, JSVarRef, header.link);
         if (var_idx == var_ref->var_idx && var_ref->is_arg == is_arg) {
             var_ref->value = JS_DupValue(ctx, sf->var_buf[var_idx]);
             var_ref->pvalue = &var_ref->value;
-            list_del(&var_ref->link);
-            var_ref->link.prev = NULL; /* the reference is no longer to a
-                                          local variable */
+            list_del(&var_ref->header.link);
+            /* the reference is no longer to a local variable */
+            var_ref->is_detached = TRUE;
+            add_gc_object(ctx->rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
         }
     }
 }
 
-#define CALL_FLAG_CONSTRUCTOR (1 << 0)
-#define CALL_FLAG_COPY_ARGV   (1 << 1)
-#define CALL_FLAG_GENERATOR   (1 << 2)
+#define JS_CALL_FLAG_COPY_ARGV   (1 << 1)
+#define JS_CALL_FLAG_GENERATOR   (1 << 2)
 
 static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
                                   JSValueConst this_obj,
@@ -14637,7 +14712,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     switch(cproto) {
     case JS_CFUNC_constructor:
     case JS_CFUNC_constructor_or_func:
-        if (!(flags & CALL_FLAG_CONSTRUCTOR)) {
+        if (!(flags & JS_CALL_FLAG_CONSTRUCTOR)) {
             if (cproto == JS_CFUNC_constructor) {
             not_a_constructor:
                 ret_val = JS_ThrowTypeError(ctx, "must be called with new");
@@ -14653,7 +14728,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
         break;
     case JS_CFUNC_constructor_magic:
     case JS_CFUNC_constructor_or_func_magic:
-        if (!(flags & CALL_FLAG_CONSTRUCTOR)) {
+        if (!(flags & JS_CALL_FLAG_CONSTRUCTOR)) {
             if (cproto == JS_CFUNC_constructor_magic) {
                 goto not_a_constructor;
             } else {
@@ -14742,7 +14817,7 @@ static JSValue js_call_bound_function(JSContext *ctx, JSValueConst func_obj,
     for(i = 0; i < argc; i++) {
         arg_buf[bf->argc + i] = argv[i];
     }
-    if (flags & CALL_FLAG_CONSTRUCTOR) {
+    if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
         new_target = this_obj;
         if (js_same_value(ctx, func_obj, new_target))
             new_target = bf->func_obj;
@@ -14793,7 +14868,7 @@ typedef enum {
 #define FUNC_RET_YIELD      1
 #define FUNC_RET_YIELD_STAR 2
 
-/* argv[] is modified if (flags & CALL_FLAG_COPY_ARGV) = 0. */
+/* argv[] is modified if (flags & JS_CALL_FLAG_COPY_ARGV) = 0. */
 static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                                JSValueConst this_obj, JSValueConst new_target,
                                int argc, JSValue *argv, int flags)
@@ -14832,7 +14907,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     if (js_poll_interrupts(ctx))
         return JS_EXCEPTION;
     if (unlikely(JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)) {
-        if (flags & CALL_FLAG_GENERATOR) {
+        if (flags & JS_CALL_FLAG_GENERATOR) {
             JSAsyncFunctionState *s = JS_VALUE_GET_PTR(func_obj);
             /* func_obj get contains a pointer to JSFuncAsyncState */
             /* the stack frame is already allocated */
@@ -14858,29 +14933,18 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     }
     p = JS_VALUE_GET_OBJ(func_obj);
     if (unlikely(p->class_id != JS_CLASS_BYTECODE_FUNCTION)) {
-        switch(p->class_id) {
-        case JS_CLASS_C_FUNCTION:
-            return js_call_c_function(ctx, func_obj, this_obj, argc,
-                                      (JSValueConst *)argv, flags);
-        case JS_CLASS_BOUND_FUNCTION:
-            return js_call_bound_function(ctx, func_obj, this_obj, argc,
-                                          (JSValueConst *)argv, flags);
-        default:
-            {
-                JSClassCall *call_func;
-                call_func = ctx->rt->class_array[p->class_id].call;
-                if (!call_func) {
-                not_a_function:
-                    return JS_ThrowTypeError(ctx, "not a function");
-                }
-                return call_func(ctx, func_obj, this_obj, argc,
-                                 (JSValueConst *)argv);
-            }
+        JSClassCall *call_func;
+        call_func = ctx->rt->class_array[p->class_id].call;
+        if (!call_func) {
+        not_a_function:
+            return JS_ThrowTypeError(ctx, "not a function");
         }
+        return call_func(ctx, func_obj, this_obj, argc,
+                         (JSValueConst *)argv, flags);
     }
     b = p->u.func.function_bytecode;
 
-    if (unlikely(argc < b->arg_count || (flags & CALL_FLAG_COPY_ARGV))) {
+    if (unlikely(argc < b->arg_count || (flags & JS_CALL_FLAG_COPY_ARGV))) {
         arg_allocated_size = b->arg_count;
     } else {
         arg_allocated_size = 0;
@@ -17254,6 +17318,13 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
         CASE(OP_nop):
             BREAK;
+        CASE(OP_is_undefined_or_null):
+            if (JS_VALUE_GET_TAG(sp[-1]) == JS_TAG_UNDEFINED ||
+                JS_VALUE_GET_TAG(sp[-1]) == JS_TAG_NULL) {
+                goto set_true;
+            } else {
+                goto free_and_set_false;
+            }
 #if SHORT_OPCODES
         CASE(OP_is_undefined):
             if (JS_VALUE_GET_TAG(sp[-1]) == JS_TAG_UNDEFINED) {
@@ -17275,6 +17346,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             }
         free_and_set_true:
             JS_FreeValue(ctx, sp[-1]);
+#endif
         set_true:
             sp[-1] = JS_TRUE;
             BREAK;
@@ -17282,7 +17354,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             JS_FreeValue(ctx, sp[-1]);
             sp[-1] = JS_FALSE;
             BREAK;
-#endif
         CASE(OP_invalid):
         DEFAULT:
             JS_ThrowInternalError(ctx, "invalid opcode: pc=%u opcode=0x%02x",
@@ -17291,11 +17362,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
         }
     }
  exception:
-    if (ctx->exception_needs_backtrace) {
+    if (is_backtrace_needed(ctx, ctx->current_exception)) {
         /* add the backtrace information now (it is not done
            before if the exception happens in a bytecode
            operation */
-        build_backtrace(ctx, ctx->current_exception, NULL, 0, pc);
+        sf->cur_pc = pc;
+        build_backtrace(ctx, ctx->current_exception, NULL, 0, 0);
     }
     if (!JS_IsUncatchableError(ctx, ctx->current_exception)) {
         while (sp > stack_buf) {
@@ -17344,14 +17416,14 @@ JSValue JS_Call(JSContext *ctx, JSValueConst func_obj, JSValueConst this_obj,
                 int argc, JSValueConst *argv)
 {
     return JS_CallInternal(ctx, func_obj, this_obj, JS_UNDEFINED,
-                           argc, (JSValue *)argv, CALL_FLAG_COPY_ARGV);
+                           argc, (JSValue *)argv, JS_CALL_FLAG_COPY_ARGV);
 }
 
 static JSValue JS_CallFree(JSContext *ctx, JSValue func_obj, JSValueConst this_obj,
                            int argc, JSValueConst *argv)
 {
     JSValue res = JS_CallInternal(ctx, func_obj, this_obj, JS_UNDEFINED,
-                                  argc, (JSValue *)argv, CALL_FLAG_COPY_ARGV);
+                                  argc, (JSValue *)argv, JS_CALL_FLAG_COPY_ARGV);
     JS_FreeValue(ctx, func_obj);
     return res;
 }
@@ -17397,7 +17469,7 @@ static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
     return obj;
 }
 
-/* argv[] is modified if (flags & CALL_FLAG_COPY_ARGV) = 0. */
+/* argv[] is modified if (flags & JS_CALL_FLAG_COPY_ARGV) = 0. */
 static JSValue JS_CallConstructorInternal(JSContext *ctx,
                                           JSValueConst func_obj,
                                           JSValueConst new_target,
@@ -17408,27 +17480,21 @@ static JSValue JS_CallConstructorInternal(JSContext *ctx,
 
     if (js_poll_interrupts(ctx))
         return JS_EXCEPTION;
-    flags |= CALL_FLAG_CONSTRUCTOR;
+    flags |= JS_CALL_FLAG_CONSTRUCTOR;
     if (unlikely(JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT))
         goto not_a_function;
     p = JS_VALUE_GET_OBJ(func_obj);
     if (unlikely(!p->is_constructor))
         return JS_ThrowTypeError(ctx, "not a constructor");
     if (unlikely(p->class_id != JS_CLASS_BYTECODE_FUNCTION)) {
-        switch(p->class_id) {
-        case JS_CLASS_C_FUNCTION:
-            return js_call_c_function(ctx, func_obj, new_target,
-                                      argc, (JSValueConst *)argv, flags);
-        case JS_CLASS_BOUND_FUNCTION:
-            return js_call_bound_function(ctx, func_obj, new_target, argc,
-                                          (JSValueConst *)argv, flags);
-        case JS_CLASS_PROXY:
-            return js_proxy_call_constructor(ctx, func_obj, new_target, argc,
-                                             (JSValueConst *)argv);
-        default:
+        JSClassCall *call_func;
+        call_func = ctx->rt->class_array[p->class_id].call;
+        if (!call_func) {
         not_a_function:
             return JS_ThrowTypeError(ctx, "not a function");
         }
+        return call_func(ctx, func_obj, new_target, argc,
+                         (JSValueConst *)argv, flags);
     }
 
     b = p->u.func.function_bytecode;
@@ -17458,7 +17524,7 @@ JSValue JS_CallConstructor2(JSContext *ctx, JSValueConst func_obj,
 {
     return JS_CallConstructorInternal(ctx, func_obj, new_target,
                                       argc, (JSValue *)argv,
-                                      CALL_FLAG_COPY_ARGV);
+                                      JS_CALL_FLAG_COPY_ARGV);
 }
 
 JSValue JS_CallConstructor(JSContext *ctx, JSValueConst func_obj,
@@ -17466,7 +17532,7 @@ JSValue JS_CallConstructor(JSContext *ctx, JSValueConst func_obj,
 {
     return JS_CallConstructorInternal(ctx, func_obj, func_obj,
                                       argc, (JSValue *)argv,
-                                      CALL_FLAG_COPY_ARGV);
+                                      JS_CALL_FLAG_COPY_ARGV);
 }
 
 JSValue JS_Invoke(JSContext *ctx, JSValueConst this_val, JSAtom atom,
@@ -17570,7 +17636,7 @@ static JSValue async_func_resume(JSContext *ctx, JSAsyncFunctionState *s)
     /* the tag does not matter provided it is not an object */
     func_obj = JS_MKPTR(JS_TAG_INT, s);
     return JS_CallInternal(ctx, func_obj, s->this_val, JS_UNDEFINED,
-                           s->argc, s->frame.arg_buf, CALL_FLAG_GENERATOR);
+                           s->argc, s->frame.arg_buf, JS_CALL_FLAG_GENERATOR);
 }
 
 
@@ -17791,7 +17857,8 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
 
 static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
                                           JSValueConst this_obj,
-                                          int argc, JSValueConst *argv)
+                                          int argc, JSValueConst *argv,
+                                          int flags)
 {
     JSValue obj, func_ret;
     JSGeneratorData *s;
@@ -17824,8 +17891,7 @@ static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
 
 /* AsyncFunction */
 
-static void js_async_function_terminate(JSRuntime *rt, JSContext *ctx,
-                                        JSAsyncFunctionData *s)
+static void js_async_function_terminate(JSRuntime *rt, JSAsyncFunctionData *s)
 {
     if (s->is_active) {
         async_func_free(rt, &s->func_state);
@@ -17833,15 +17899,19 @@ static void js_async_function_terminate(JSRuntime *rt, JSContext *ctx,
     }
 }
 
-/* ctx can be NULL */
-static void js_async_function_free(JSRuntime *rt, JSContext *ctx,
-                                   JSAsyncFunctionData *s)
+static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s)
+{
+    js_async_function_terminate(rt, s);
+    JS_FreeValueRT(rt, s->resolving_funcs[0]);
+    JS_FreeValueRT(rt, s->resolving_funcs[1]);
+    remove_gc_object(&s->header);
+    js_free_rt(rt, s);
+}
+
+static void js_async_function_free(JSRuntime *rt, JSAsyncFunctionData *s)
 {
     if (--s->header.ref_count == 0) {
-        js_async_function_terminate(rt, ctx, s);
-        JS_FreeValueRT(rt, s->resolving_funcs[0]);
-        JS_FreeValueRT(rt, s->resolving_funcs[1]);
-        js_free_rt(rt, s);
+        js_async_function_free0(rt, s);
     }
 }
 
@@ -17850,7 +17920,7 @@ static void js_async_function_resolve_finalizer(JSRuntime *rt, JSValue val)
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSAsyncFunctionData *s = p->u.async_function_data;
     if (s) {
-        js_async_function_free(rt, NULL, s);
+        js_async_function_free(rt, s);
     }
 }
 
@@ -17860,7 +17930,7 @@ static void js_async_function_resolve_mark(JSRuntime *rt, JSValueConst val,
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSAsyncFunctionData *s = p->u.async_function_data;
     if (s) {
-        JS_MarkValue(rt, JS_MKPTR(JS_TAG_ASYNC_FUNCTION, s), mark_func);
+        mark_func(rt, &s->header);
     }
 }
 
@@ -17899,7 +17969,7 @@ static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionData *s)
         ret2 = JS_Call(ctx, s->resolving_funcs[1], JS_UNDEFINED,
                        1, (JSValueConst *)&error);
         JS_FreeValue(ctx, error);
-        js_async_function_terminate(ctx->rt, ctx, s);
+        js_async_function_terminate(ctx->rt, s);
         JS_FreeValue(ctx, ret2); /* XXX: what to do if exception ? */
     } else {
         JSValue value;
@@ -17911,7 +17981,7 @@ static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionData *s)
                            1, (JSValueConst *)&value);
             JS_FreeValue(ctx, ret2); /* XXX: what to do if exception ? */
             JS_FreeValue(ctx, value);
-            js_async_function_terminate(ctx->rt, ctx, s);
+            js_async_function_terminate(ctx->rt, s);
         } else {
             JSValue promise, resolving_funcs[2], resolving_funcs1[2];
             int i, res;
@@ -17947,7 +18017,8 @@ static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionData *s)
 static JSValue js_async_function_resolve_call(JSContext *ctx,
                                               JSValueConst func_obj,
                                               JSValueConst this_obj,
-                                              int argc, JSValueConst *argv)
+                                              int argc, JSValueConst *argv,
+                                              int flags)
 {
     JSObject *p = JS_VALUE_GET_OBJ(func_obj);
     JSAsyncFunctionData *s = p->u.async_function_data;
@@ -17971,7 +18042,7 @@ static JSValue js_async_function_resolve_call(JSContext *ctx,
 
 static JSValue js_async_function_call(JSContext *ctx, JSValueConst func_obj,
                                       JSValueConst this_obj,
-                                      int argc, JSValueConst *argv)
+                                      int argc, JSValueConst *argv, int flags)
 {
     JSValue promise;
     JSAsyncFunctionData *s;
@@ -17980,7 +18051,7 @@ static JSValue js_async_function_call(JSContext *ctx, JSValueConst func_obj,
     if (!s)
         return JS_EXCEPTION;
     s->header.ref_count = 1;
-    s->gc_header.mark = 0;
+    add_gc_object(ctx->rt, &s->header, JS_GC_OBJ_TYPE_ASYNC_FUNCTION);
     s->is_active = FALSE;
     s->resolving_funcs[0] = JS_UNDEFINED;
     s->resolving_funcs[1] = JS_UNDEFINED;
@@ -17992,14 +18063,14 @@ static JSValue js_async_function_call(JSContext *ctx, JSValueConst func_obj,
     if (async_func_init(ctx, &s->func_state, func_obj, this_obj, argc, argv)) {
     fail:
         JS_FreeValue(ctx, promise);
-        js_async_function_free(ctx->rt, ctx, s);
+        js_async_function_free(ctx->rt, s);
         return JS_EXCEPTION;
     }
     s->is_active = TRUE;
 
     js_async_function_resume(ctx, s);
 
-    js_async_function_free(ctx->rt, ctx, s);
+    js_async_function_free(ctx->rt, s);
 
     return promise;
 }
@@ -18401,7 +18472,8 @@ static JSValue js_async_generator_next(JSContext *ctx, JSValueConst this_val,
 
 static JSValue js_async_generator_function_call(JSContext *ctx, JSValueConst func_obj,
                                                 JSValueConst this_obj,
-                                                int argc, JSValueConst *argv)
+                                                int argc, JSValueConst *argv,
+                                                int flags)
 {
     JSValue obj, func_ret;
     JSAsyncGeneratorData *s;
@@ -18479,6 +18551,8 @@ enum {
     TOK_POW,
     TOK_ARROW,
     TOK_ELLIPSIS,
+    TOK_DOUBLE_QUESTION_MARK,
+    TOK_QUESTION_MARK_DOT,
     TOK_ERROR,
     TOK_PRIVATE_NAME,
     TOK_EOF,
@@ -18639,6 +18713,7 @@ typedef struct JSFunctionDef {
     BOOL arguments_allowed; /* true if the 'arguments' identifier is allowed */
     BOOL is_derived_class_constructor;
     BOOL in_function_body;
+    BOOL backtrace_barrier;
     JSFunctionKindEnum func_kind : 8;
     JSParseFunctionEnum func_type : 8;
     uint8_t js_mode; /* bitmap of JS_MODE_x */
@@ -18887,12 +18962,16 @@ int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const
 {
     JSContext *ctx = s->ctx;
     va_list ap;
-
+    int backtrace_flags;
+    
     va_start(ap, fmt);
-    JS_ThrowError(ctx, JS_SYNTAX_ERROR, fmt, ap);
+    JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
     va_end(ap);
-
-    build_backtrace(ctx, ctx->current_exception, s->filename, s->line_num, NULL);
+    backtrace_flags = 0;
+    if (s->cur_func && s->cur_func->backtrace_barrier)
+        backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
+    build_backtrace(ctx, ctx->current_exception, s->filename, s->line_num,
+                    backtrace_flags);
     return -1;
 }
 
@@ -19228,6 +19307,10 @@ static __exception int next_token(JSParseState *s)
     char buf[4096], *q;
     BOOL ident_has_escape;
 
+    if (js_check_stack_overflow(s->ctx, 0)) {
+        return js_parse_error(s, "stack overflow");
+    }
+    
     free_token(s, &s->token);
 
     p = s->last_ptr = s->buf_ptr;
@@ -19777,6 +19860,17 @@ static __exception int next_token(JSParseState *s)
             goto def_token;
         }
         break;
+    case '?':
+        if (p[1] == '?') {
+            p += 2;
+            s->token.val = TOK_DOUBLE_QUESTION_MARK;
+        } else if (p[1] == '.' && !(p[2] >= '0' && p[2] <= '9')) {
+            p += 2;
+            s->token.val = TOK_QUESTION_MARK_DOT;
+        } else {
+            goto def_token;
+        }
+        break;
     default:
         if (c >= 128) {
             /* unicode value */
@@ -22647,10 +22741,28 @@ typedef enum FuncCallType {
     FUNC_CALL_TEMPLATE,
 } FuncCallType;
 
+static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
+                                int drop_count)
+{
+    int label_next, i;
+    if (*poptional_chaining_label < 0)
+        *poptional_chaining_label = new_label(s);
+   /* XXX: could be more efficient with a specific opcode */
+    emit_op(s, OP_dup);
+    emit_op(s, OP_is_undefined_or_null);
+    label_next = emit_goto(s, OP_if_false, -1);
+    for(i = 0; i < drop_count; i++)
+        emit_op(s, OP_drop);
+    emit_op(s, OP_undefined);
+    emit_goto(s, OP_goto, *poptional_chaining_label);
+    emit_label(s, label_next);
+}
+
 static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen)
 {
     FuncCallType call_type;
-
+    int optional_chaining_label;
+    
     call_type = FUNC_CALL_NORMAL;
     switch(s->token.val) {
     case TOK_NUMBER:
@@ -22716,7 +22828,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
     parse_regexp:
         {
             JSValue str;
-            int ret;
+            int ret, backtrace_flags;
             if (!s->ctx->compile_regexp)
                 return js_parse_error(s, "RegExp are not supported");
             /* the previous token is '/' or '/=', so no need to free */
@@ -22727,8 +22839,12 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                                          s->token.u.regexp.flags);
             if (JS_IsException(str)) {
                 /* add the line number info */
+                backtrace_flags = 0;
+                if (s->cur_func && s->cur_func->backtrace_barrier)
+                    backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
                 build_backtrace(s->ctx, s->ctx->current_exception,
-                                s->filename, s->token.line_num, NULL);
+                                s->filename, s->token.line_num,
+                                backtrace_flags);
                 return -1;
             }
             ret = emit_push_const(s, str, 0);
@@ -22938,35 +23054,55 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                               (int)(s->buf_ptr - s->token.ptr), s->token.ptr);
     }
 
+    optional_chaining_label = -1;
     for(;;) {
         JSFunctionDef *fd = s->cur_func;
-
-        if (s->token.val == TOK_TEMPLATE && call_type == FUNC_CALL_NORMAL) {
+        BOOL has_optional_chain = FALSE;
+        
+        if (s->token.val == TOK_QUESTION_MARK_DOT) {
+            /* optional chaining */
+            if (next_token(s))
+                return -1;
+            has_optional_chain = TRUE;
+            if (s->token.val == '(' && accept_lparen) {
+                goto parse_func_call;
+            } else if (s->token.val == '[') {
+                goto parse_array_access;
+            } else {
+                goto parse_property;
+            }
+        } else if (s->token.val == TOK_TEMPLATE &&
+                   call_type == FUNC_CALL_NORMAL) {
+            if (optional_chaining_label >= 0) {
+                return js_parse_error(s, "template literal cannot appear in an optional chain");
+            }
             call_type = FUNC_CALL_TEMPLATE;
-            goto parse_func_call;
-        }
-        if (s->token.val == '(' && accept_lparen) {
-            int opcode;
-            int arg_count;
+            goto parse_func_call2;
+        } else if (s->token.val == '(' && accept_lparen) {
+            int opcode, arg_count, drop_count;
 
             /* function call */
+        parse_func_call:
             if (next_token(s))
                 return -1;
 
             if (call_type == FUNC_CALL_NORMAL) {
-            parse_func_call:
+            parse_func_call2:
                 switch(opcode = get_prev_opcode(fd)) {
                 case OP_get_field:
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
+                    drop_count = 2;
                     break;
                 case OP_scope_get_private_field:
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_scope_get_private_field2;
+                    drop_count = 2;
                     break;
                 case OP_get_array_el:
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
+                    drop_count = 2;
                     break;
                 case OP_scope_get_var:
                     {
@@ -22991,17 +23127,24 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                                 fd->byte_code.buf[fd->last_opcode_pos] = opcode;
                             }
                         }
+                        drop_count = 1;
                     }
                     break;
                 case OP_get_super_value:
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el;
                     /* on stack: this func_obj */
                     opcode = OP_get_array_el;
+                    drop_count = 2;
                     break;
                 default:
                     opcode = OP_invalid;
+                    drop_count = 1;
                     break;
                 }
+                if (has_optional_chain) {
+                    optional_chain_test(s, &optional_chaining_label,
+                                        drop_count);
+                }
             } else {
                 opcode = OP_invalid;
             }
@@ -23194,6 +23337,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 emit_atom(s, s->token.u.ident.atom);
                 emit_u16(s, s->cur_func->scope_level);
             } else {
+            parse_property:
                 if (!token_is_ident(s->token.val)) {
                     return js_parse_error(s, "expecting field name");
                 }
@@ -23207,6 +23351,9 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         return -1;
                     emit_op(s, OP_get_super_value);
                 } else {
+                    if (has_optional_chain) {
+                        optional_chain_test(s, &optional_chaining_label, 1);
+                    }
                     emit_op(s, OP_get_field);
                     emit_atom(s, s->token.u.ident.atom);
                 }
@@ -23215,9 +23362,14 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 return -1;
         } else if (s->token.val == '[') {
             int prev_op;
+
+        parse_array_access:
+            prev_op = get_prev_opcode(fd);
+            if (has_optional_chain) {
+                optional_chain_test(s, &optional_chaining_label, 1);
+            }
             if (next_token(s))
                 return -1;
-            prev_op = get_prev_opcode(fd);
             if (js_parse_expr(s))
                 return -1;
             if (js_parse_expect(s, ']'))
@@ -23227,20 +23379,12 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             } else {
                 emit_op(s, OP_get_array_el);
             }
-        } else if (!s->got_lf && (s->token.val == TOK_DEC || s->token.val == TOK_INC)) {
-            int opcode, op, scope, label;
-            JSAtom name;
-            op = s->token.val;
-            if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
-                return -1;
-            emit_op(s, OP_post_dec + op - TOK_DEC);
-            put_lvalue(s, opcode, scope, name, label, TRUE);
-            if (next_token(s))
-                return -1;
         } else {
             break;
         }
     }
+    if (optional_chaining_label >= 0)
+        emit_label(s, optional_chaining_label);
     return 0;
 }
 
@@ -23395,6 +23539,18 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
     default:
         if (js_parse_postfix_expr(s, TRUE))
             return -1;
+        if (!s->got_lf &&
+            (s->token.val == TOK_DEC || s->token.val == TOK_INC)) {
+            int opcode, op, scope, label;
+            JSAtom name;
+            op = s->token.val;
+            if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
+                return -1;
+            emit_op(s, OP_post_dec + op - TOK_DEC);
+            put_lvalue(s, opcode, scope, name, label, TRUE);
+            if (next_token(s))
+                return -1;        
+        }
         break;
     }
     if (exponentiation_flag) {
@@ -23619,8 +23775,11 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
                 if (js_parse_logical_and_or(s, TOK_LAND, in_accepted))
                     return -1;
             }
-            if (s->token.val != op)
+            if (s->token.val != op) {
+                if (s->token.val == TOK_DOUBLE_QUESTION_MARK)
+                    return js_parse_error(s, "cannot mix ?? with && or ||");
                 break;
+            }
         }
 
         emit_label(s, label1);
@@ -23628,11 +23787,38 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
     return 0;
 }
 
+static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
+{
+    int label1;
+    
+    if (js_parse_logical_and_or(s, TOK_LOR, in_accepted))
+        return -1;
+    if (s->token.val == TOK_DOUBLE_QUESTION_MARK) {
+        label1 = new_label(s);
+        for(;;) {
+            if (next_token(s))
+                return -1;
+            
+            emit_op(s, OP_dup);
+            emit_op(s, OP_is_undefined_or_null);
+            emit_goto(s, OP_if_false, label1);
+            emit_op(s, OP_drop);
+            
+            if (js_parse_expr_binary(s, 8, in_accepted))
+                return -1;
+            if (s->token.val != TOK_DOUBLE_QUESTION_MARK)
+                break;
+        }
+        emit_label(s, label1);
+    }
+    return 0;
+}
+
 static __exception int js_parse_cond_expr(JSParseState *s, BOOL in_accepted)
 {
     int label1, label2;
 
-    if (js_parse_logical_and_or(s, TOK_LOR, in_accepted))
+    if (js_parse_coalesce_expr(s, in_accepted))
         return -1;
     if (s->token.val == '?') {
         if (next_token(s))
@@ -25995,14 +26181,13 @@ static JSVarRef *js_create_module_var(JSContext *ctx, BOOL is_lexical)
     if (!var_ref)
         return NULL;
     var_ref->header.ref_count = 1;
-    var_ref->gc_header.mark = 0;
-    var_ref->link.prev = NULL;
-    var_ref->link.next = NULL;
     if (is_lexical)
         var_ref->value = JS_UNINITIALIZED;
     else
         var_ref->value = JS_UNDEFINED;
     var_ref->pvalue = &var_ref->value;
+    var_ref->is_detached = TRUE;
+    add_gc_object(ctx->rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
     return var_ref;
 }
 
@@ -30550,7 +30735,6 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     if (!b)
         goto fail;
     b->header.ref_count = 1;
-    b->gc_header.mark = 0;
 
     b->byte_code_buf = (void *)((uint8_t*)b + byte_code_offset);
     b->byte_code_len = fd->byte_code.size;
@@ -30637,7 +30821,10 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     b->super_call_allowed = fd->super_call_allowed;
     b->super_allowed = fd->super_allowed;
     b->arguments_allowed = fd->arguments_allowed;
+    b->backtrace_barrier = fd->backtrace_barrier;
 
+    add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
+    
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
     if (!(fd->js_mode & JS_MODE_STRIP)) {
         js_dump_function_bytecode(ctx, b);
@@ -30688,7 +30875,13 @@ static void free_function_bytecode(JSRuntime *rt, JSFunctionBytecode *b)
         js_free_rt(rt, b->debug.pc2line_buf);
         js_free_rt(rt, b->debug.source);
     }
-    js_free_rt(rt, b);
+
+    remove_gc_object(&b->header);
+    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES && b->header.ref_count != 0) {
+        list_add_tail(&b->header.link, &rt->gc_zero_ref_count_list);
+    } else {
+        js_free_rt(rt, b);
+    }
 }
 
 static __exception int js_parse_directives(JSParseState *s)
@@ -31545,6 +31738,7 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
     s->cur_func = fd;
     fd->eval_type = eval_type;
     fd->has_this_binding = (eval_type != JS_EVAL_TYPE_DIRECT);
+    fd->backtrace_barrier = ((flags & JS_EVAL_FLAG_BACKTRACE_BARRIER) != 0);
     if (eval_type == JS_EVAL_TYPE_DIRECT) {
         fd->new_target_allowed = b->new_target_allowed;
         fd->super_call_allowed = b->super_call_allowed;
@@ -32004,6 +32198,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
             bc_set_flags(&flags, &idx, b->super_allowed, 1);
             bc_set_flags(&flags, &idx, b->arguments_allowed, 1);
             bc_set_flags(&flags, &idx, b->has_debug, 1);
+            bc_set_flags(&flags, &idx, b->backtrace_barrier, 1);
             assert(idx <= 16);
             bc_put_u16(s, flags);
             bc_put_u8(s, b->js_mode);
@@ -32718,6 +32913,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
             bc.super_allowed = bc_get_flags(v16, &idx, 1);
             bc.arguments_allowed = bc_get_flags(v16, &idx, 1);
             bc.has_debug = bc_get_flags(v16, &idx, 1);
+            bc.backtrace_barrier = bc_get_flags(v16, &idx, 1);
             bc.read_only_bytecode = s->is_rom_data;
             if (bc_get_u8(s, &v8))
                 goto fail;
@@ -32760,8 +32956,11 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
             b = js_mallocz(ctx, function_size);
             if (!b)
                 return JS_EXCEPTION;
-
+            
             memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
+            b->header.ref_count = 1;
+            add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
+            
             obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
 
 #ifdef DUMP_READ_OBJECT
@@ -35154,7 +35353,9 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
         return proto;
     obj = JS_NewObjectProtoClass(ctx, proto, JS_CLASS_ERROR);
     JS_FreeValue(ctx, proto);
-    if (!JS_IsException(obj) && !JS_IsUndefined(argv[0])) {
+    if (JS_IsException(obj))
+        return obj;
+    if (!JS_IsUndefined(argv[0])) {
         msg = JS_ToString(ctx, argv[0]);
         if (unlikely(JS_IsException(msg))) {
             JS_FreeValue(ctx, obj);
@@ -35163,6 +35364,8 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
         JS_DefinePropertyValue(ctx, obj, JS_ATOM_message, msg,
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     }
+    /* skip the Error() function in the backtrace */
+    build_backtrace(ctx, obj, NULL, 0, JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL);
     return obj;
 }
 
@@ -37287,7 +37490,7 @@ static const JSCFunctionListEntry js_number_proto_funcs[] = {
 static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
-    const char *str;
+    const char *str, *p;
     int radix;
     JSValue ret;
 
@@ -37301,14 +37504,16 @@ static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
     if (radix != 0 && (radix < 2 || radix > 36)) {
         ret = JS_NAN;
     } else {
+        p = str;
+        p += skip_spaces(p);
 #ifdef CONFIG_BIGNUM
         int flags;
-        flags = BF_ATOF_INT_ONLY | BF_ATOF_NAN_IF_EMPTY | BF_ATOF_FLOAT64;
+        flags = BF_ATOF_INT_ONLY | BF_ATOF_FLOAT64;
         if (is_bignum_mode(ctx))
             flags |= BF_ATOF_INT_PREC_INF;
-        ret = js_atof(ctx, str, NULL, radix, flags);
+        ret = js_atof(ctx, p, NULL, radix, flags);
 #else
-        ret = js_atod(ctx, str, NULL, radix, ATOD_INT_ONLY | ATOD_NAN_IF_EMPTY);
+        ret = js_atod(ctx, p, NULL, radix, ATOD_INT_ONLY);
 #endif
     }
     JS_FreeCString(ctx, str);
@@ -37318,17 +37523,19 @@ static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
 static JSValue js_parseFloat(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
-    const char *str;
+    const char *str, *p;
     JSValue ret;
 
     str = JS_ToCString(ctx, argv[0]);
     if (!str)
         return JS_EXCEPTION;
+    p = str;
+    p += skip_spaces(p);
 #ifdef CONFIG_BIGNUM
-    ret = js_atof(ctx, str, NULL, 10,
-                  BF_ATOF_JS_QUIRKS | BF_ATOF_NAN_IF_EMPTY | BF_ATOF_FLOAT64);
+    ret = js_atof(ctx, p, NULL, 10,
+                  BF_ATOF_JS_QUIRKS | BF_ATOF_FLOAT64);
 #else
-    ret = js_atod(ctx, str, NULL, 10, ATOD_NAN_IF_EMPTY);
+    ret = js_atod(ctx, p, NULL, 10, 0);
 #endif
     JS_FreeCString(ctx, str);
     return ret;
@@ -41735,13 +41942,11 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
     return -1;
 }
 
-static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
+JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
+                         JSValueConst replacer, JSValueConst space0)
 {
-    // stringify(val, replacer, space)
     StringBuffer b_s;
     JSONStringifyContext jsc_s, *jsc = &jsc_s;
-    JSValueConst replacer = argv[1];
     JSValue val, v, space, ret, wrapper;
     int res;
     int64_t i, j, n;
@@ -41810,7 +42015,7 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
             }
         }
     }
-    space = JS_DupValue(ctx, argv[2]);
+    space = JS_DupValue(ctx, space0);
     if (JS_IsObject(space)) {
         JSObject *p = JS_VALUE_GET_OBJ(space);
         if (p->class_id == JS_CLASS_NUMBER) {
@@ -41841,9 +42046,9 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
     if (JS_IsException(wrapper))
         goto exception;
     if (JS_DefinePropertyValue(ctx, wrapper, JS_ATOM_empty_string,
-                               JS_DupValue(ctx, argv[0]), JS_PROP_C_W_E) < 0)
+                               JS_DupValue(ctx, obj), JS_PROP_C_W_E) < 0)
         goto exception;
-    val = JS_DupValue(ctx, argv[0]);
+    val = JS_DupValue(ctx, obj);
                            
     val = js_json_check(ctx, jsc, wrapper, val, jsc->empty);
     if (JS_IsException(val))
@@ -41871,6 +42076,13 @@ static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
     return ret;
 }
 
+static JSValue js_json_stringify(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    // stringify(val, replacer, space)
+    return JS_JSONStringify(ctx, argv[0], argv[1], argv[2]);
+}
+
 static const JSCFunctionListEntry js_json_funcs[] = {
     JS_CFUNC_DEF("parse", 2, js_json_parse ),
     JS_CFUNC_DEF("stringify", 3, js_json_stringify ),
@@ -42817,66 +43029,69 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
     return -1;
 }
 
-static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
-                             JSValueConst this_obj,
-                             int argc, JSValueConst *argv)
+static JSValue js_proxy_call_constructor(JSContext *ctx, JSValueConst func_obj,
+                                         JSValueConst new_target,
+                                         int argc, JSValueConst *argv)
 {
     JSProxyData *s;
     JSValue method, arg_array, ret;
     JSValueConst args[3];
 
-    s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
+    s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_construct);
     if (!s)
         return JS_EXCEPTION;
-    if (!s->is_func) {
-        JS_FreeValue(ctx, method);
-        return JS_ThrowTypeError(ctx, "not a function");
-    }
+    if (!JS_IsConstructor(ctx, s->target))
+        return JS_ThrowTypeError(ctx, "not a constructor");
     if (JS_IsUndefined(method))
-        return JS_Call(ctx, s->target, this_obj, argc, argv);
+        return JS_CallConstructor2(ctx, s->target, new_target, argc, argv);
     arg_array = js_create_array(ctx, argc, argv);
     if (JS_IsException(arg_array)) {
         ret = JS_EXCEPTION;
         goto fail;
     }
     args[0] = s->target;
-    args[1] = this_obj;
-    args[2] = arg_array;
+    args[1] = arg_array;
+    args[2] = new_target;
     ret = JS_Call(ctx, method, s->handler, 3, args);
+    if (!JS_IsException(ret) && JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT) {
+        JS_FreeValue(ctx, ret);
+        ret = JS_ThrowTypeErrorNotAnObject(ctx);
+    }
  fail:
     JS_FreeValue(ctx, method);
     JS_FreeValue(ctx, arg_array);
     return ret;
 }
 
-static JSValue js_proxy_call_constructor(JSContext *ctx, JSValueConst func_obj,
-                                         JSValueConst new_target,
-                                         int argc, JSValueConst *argv)
+static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
+                             JSValueConst this_obj,
+                             int argc, JSValueConst *argv, int flags)
 {
     JSProxyData *s;
     JSValue method, arg_array, ret;
     JSValueConst args[3];
 
-    s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_construct);
+    if (flags & JS_CALL_FLAG_CONSTRUCTOR)
+        return js_proxy_call_constructor(ctx, func_obj, this_obj, argc, argv);
+    
+    s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
     if (!s)
         return JS_EXCEPTION;
-    if (!JS_IsConstructor(ctx, s->target))
-        return JS_ThrowTypeError(ctx, "not a constructor");
+    if (!s->is_func) {
+        JS_FreeValue(ctx, method);
+        return JS_ThrowTypeError(ctx, "not a function");
+    }
     if (JS_IsUndefined(method))
-        return JS_CallConstructor2(ctx, s->target, new_target, argc, argv);
+        return JS_Call(ctx, s->target, this_obj, argc, argv);
     arg_array = js_create_array(ctx, argc, argv);
     if (JS_IsException(arg_array)) {
         ret = JS_EXCEPTION;
         goto fail;
     }
     args[0] = s->target;
-    args[1] = arg_array;
-    args[2] = new_target;
+    args[1] = this_obj;
+    args[2] = arg_array;
     ret = JS_Call(ctx, method, s->handler, 3, args);
-    if (!JS_IsException(ret) && JS_VALUE_GET_TAG(ret) != JS_TAG_OBJECT) {
-        JS_FreeValue(ctx, ret);
-        ret = JS_ThrowTypeErrorNotAnObject(ctx);
-    }
  fail:
     JS_FreeValue(ctx, method);
     JS_FreeValue(ctx, arg_array);
@@ -44006,6 +44221,14 @@ static JSValue promise_reaction_job(JSContext *ctx, int argc,
     return res2;
 }
 
+void JS_SetHostPromiseRejectionTracker(JSRuntime *rt,
+                                       JSHostPromiseRejectionTracker *cb,
+                                       void *opaque)
+{
+    rt->host_promise_rejection_tracker = cb;
+    rt->host_promise_rejection_tracker_opaque = opaque;
+}
+
 static void fulfill_or_reject_promise(JSContext *ctx, JSValueConst promise,
                                       JSValueConst value, BOOL is_reject)
 {
@@ -44021,7 +44244,14 @@ static void fulfill_or_reject_promise(JSContext *ctx, JSValueConst promise,
 #ifdef DUMP_PROMISE
     printf("fulfill_or_reject_promise: is_reject=%d\n", is_reject);
 #endif
-    /* Note: could call HostPromiseRejectTracker */
+    if (s->promise_state == JS_PROMISE_REJECTED && !s->is_handled) {
+        JSRuntime *rt = ctx->rt;
+        if (rt->host_promise_rejection_tracker) {
+            rt->host_promise_rejection_tracker(ctx, promise, value, FALSE,
+                                               rt->host_promise_rejection_tracker_opaque);
+        }
+    }
+
     list_for_each_safe(el, el1, &s->promise_reactions[is_reject]) {
         rd = list_entry(el, JSPromiseReactionData, link);
         args[0] = rd->resolving_funcs[0];
@@ -44145,7 +44375,8 @@ static void js_promise_resolve_function_mark(JSRuntime *rt, JSValueConst val,
 static JSValue js_promise_resolve_function_call(JSContext *ctx,
                                                 JSValueConst func_obj,
                                                 JSValueConst this_val,
-                                                int argc, JSValueConst *argv)
+                                                int argc, JSValueConst *argv,
+                                                int flags)
 {
     JSObject *p = JS_VALUE_GET_OBJ(func_obj);
     JSPromiseFunctionData *s;
@@ -44724,6 +44955,13 @@ static __exception int perform_promise_then(JSContext *ctx,
             list_add_tail(&rd_array[i]->link, &s->promise_reactions[i]);
     } else {
         JSValueConst args[5];
+        if (s->promise_state == JS_PROMISE_REJECTED && !s->is_handled) {
+            JSRuntime *rt = ctx->rt;
+            if (rt->host_promise_rejection_tracker) {
+                rt->host_promise_rejection_tracker(ctx, promise, s->promise_result,
+                                                   TRUE, rt->host_promise_rejection_tracker_opaque);
+            }
+        }
         i = s->promise_state - JS_PROMISE_FULFILLED;
         rd = rd_array[i];
         args[0] = rd->resolving_funcs[0];
@@ -45414,7 +45652,7 @@ static JSValue js_global_escape(JSContext *ctx, JSValueConst this_val,
     JSString *p;
     int i, len, c;
 
-    str = JS_ToStringCheckObject(ctx, argv[0]);
+    str = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str))
         return str;
 
@@ -45440,7 +45678,7 @@ static JSValue js_global_unescape(JSContext *ctx, JSValueConst this_val,
     JSString *p;
     int i, len, c, n;
 
-    str = JS_ToStringCheckObject(ctx, argv[0]);
+    str = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str))
         return str;
 
@@ -46753,17 +46991,28 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
         case JS_TAG_STRING:
             {
                 const char *str, *p;
+                size_t len;
                 int err;
 
-                str = JS_ToCString(ctx, val);
+                str = JS_ToCStringLen(ctx, &len, val);
                 JS_FreeValue(ctx, val);
                 if (!str)
                     return JS_EXCEPTION;
-                val = js_atof(ctx, str, &p, 0, BF_ATOF_BIN_OCT |
-                              BF_ATOF_NO_PREFIX_AFTER_SIGN |
-                              BF_ATOF_JS_QUIRKS);
+                p = str;
                 p += skip_spaces(p);
-                err = (*p != '\0');
+                if ((p - str) == len) {
+                    bf_t r_s, *r = &r_s;
+                    bf_init(ctx->bf_ctx, r);
+                    bf_set_si(r, 0);
+                    val = JS_NewBigFloat(ctx, r);
+                    err = 0;
+                } else {
+                    val = js_atof(ctx, p, &p, 0, BF_ATOF_BIN_OCT |
+                                  BF_ATOF_NO_PREFIX_AFTER_SIGN |
+                                  BF_ATOF_JS_QUIRKS);
+                    p += skip_spaces(p);
+                    err = ((p - str) != len);
+                }
                 JS_FreeCString(ctx, str);
                 if (err) {
                     JS_FreeValue(ctx, val);
@@ -47192,16 +47441,16 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     ctx->throw_type_error = JS_NewCFunction(ctx, js_throw_type_error, NULL, 0);
 
     /* add caller and arguments properties to throw a TypeError */
-    obj1 = JS_NewCFunction(ctx, js_function_proto_caller, "get caller", 0);
+    obj1 = JS_NewCFunction(ctx, js_function_proto_caller, NULL, 0);
     JS_DefineProperty(ctx, ctx->function_proto, JS_ATOM_caller, JS_UNDEFINED,
                       obj1, ctx->throw_type_error,
                       JS_PROP_HAS_GET | JS_PROP_HAS_SET |
                       JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE);
-    JS_FreeValue(ctx, obj1);
     JS_DefineProperty(ctx, ctx->function_proto, JS_ATOM_arguments, JS_UNDEFINED,
-                      ctx->throw_type_error, ctx->throw_type_error,
+                      obj1, ctx->throw_type_error,
                       JS_PROP_HAS_GET | JS_PROP_HAS_SET |
                       JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE);
+    JS_FreeValue(ctx, obj1);
     JS_FreeValue(ctx, js_object_seal(ctx, JS_UNDEFINED, 1, (JSValueConst *)&ctx->throw_type_error, 1));
 
     ctx->global_obj = JS_NewObject(ctx);
@@ -47527,12 +47776,10 @@ static void js_array_buffer_finalizer(JSRuntime *rt, JSValue val)
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSArrayBuffer *abuf = p->u.array_buffer;
     if (abuf) {
-        /* During the GC sweep phase the ArrayBuffer finalizer may be
-           called before the typed array finalizers using it, so
-           abuf->array_list is not necessarily empty. */
-        if (!JS_IsInGCSweep(rt)) {
-            assert(list_empty(&abuf->array_list));
-        }
+        /* The ArrayBuffer finalizer may be called before the typed
+           array finalizers using it, so abuf->array_list is not
+           necessarily empty. */
+        // assert(list_empty(&abuf->array_list));
         if (abuf->free_func)
             abuf->free_func(rt, abuf->opaque, abuf->data);
         js_free_rt(rt, abuf);
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index f6494e1205..5a06acef48 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -71,9 +71,6 @@ enum {
     JS_TAG_BIG_FLOAT   = -9,
     JS_TAG_SYMBOL      = -8,
     JS_TAG_STRING      = -7,
-    JS_TAG_SHAPE       = -6, /* used internally during GC */
-    JS_TAG_ASYNC_FUNCTION = -5, /* used internally during GC */
-    JS_TAG_VAR_REF     = -4, /* used internally during GC */
     JS_TAG_MODULE      = -3, /* used internally */
     JS_TAG_FUNCTION_BYTECODE = -2, /* used internally */
     JS_TAG_OBJECT      = -1,
@@ -283,6 +280,8 @@ static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
    JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
    with JS_EvalFunction(). */
 #define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5)
+/* don't include the stack frames before this eval in the Error() backtraces */
+#define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6)
 
 typedef JSValue JSCFunction(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
@@ -302,6 +301,8 @@ typedef struct JSMallocFunctions {
     size_t (*js_malloc_usable_size)(const void *ptr);
 } JSMallocFunctions;
 
+typedef struct JSGCObjectHeader JSGCObjectHeader;
+
 JSRuntime *JS_NewRuntime(void);
 /* info lifetime must exceed that of rt */
 void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);
@@ -309,11 +310,10 @@ void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);
 void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);
 void JS_FreeRuntime(JSRuntime *rt);
-typedef void JS_MarkFunc(JSRuntime *rt, JSValueConst val);
+typedef void JS_MarkFunc(JSRuntime *rt, JSGCObjectHeader *gp);
 void JS_MarkValue(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
 void JS_RunGC(JSRuntime *rt);
 JS_BOOL JS_IsLiveObject(JSRuntime *rt, JSValueConst obj);
-JS_BOOL JS_IsInGCSweep(JSRuntime *rt);
 
 JSContext *JS_NewContext(JSRuntime *rt);
 void JS_FreeContext(JSContext *s);
@@ -434,13 +434,20 @@ typedef struct JSClassExoticMethods {
 typedef void JSClassFinalizer(JSRuntime *rt, JSValue val);
 typedef void JSClassGCMark(JSRuntime *rt, JSValueConst val,
                            JS_MarkFunc *mark_func);
+#define JS_CALL_FLAG_CONSTRUCTOR (1 << 0)
 typedef JSValue JSClassCall(JSContext *ctx, JSValueConst func_obj,
-                            JSValueConst this_val, int argc, JSValueConst *argv);
+                            JSValueConst this_val, int argc, JSValueConst *argv,
+                            int flags);
 
 typedef struct JSClassDef {
     const char *class_name;
     JSClassFinalizer *finalizer;
     JSClassGCMark *gc_mark;
+    /* if call != NULL, the object is a function. If (flags &
+       JS_CALL_FLAG_CONSTRUCTOR) != 0, the function is called as a
+       constructor. In this case, 'this_val' is new.target. A
+       constructor call only happens if the object constructor bit is
+       set (see JS_SetConstructorBit()). */
     JSClassCall *call;
     /* XXX: suppress this indirection ? It is here only to save memory
        because only a few classes need these methods */
@@ -550,7 +557,6 @@ static inline JS_BOOL JS_IsObject(JSValueConst v)
 JSValue JS_Throw(JSContext *ctx, JSValue obj);
 JSValue JS_GetException(JSContext *ctx);
 JS_BOOL JS_IsError(JSContext *ctx, JSValueConst val);
-void JS_EnableIsErrorProperty(JSContext *ctx, JS_BOOL enable);
 void JS_ResetUncatchableError(JSContext *ctx);
 JSValue JS_NewError(JSContext *ctx);
 JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...);
@@ -633,6 +639,7 @@ JSValue JS_NewObject(JSContext *ctx);
 
 JS_BOOL JS_IsFunction(JSContext* ctx, JSValueConst val);
 JS_BOOL JS_IsConstructor(JSContext* ctx, JSValueConst val);
+JS_BOOL JS_SetConstructorBit(JSContext *ctx, JSValueConst func_obj, JS_BOOL val);
 
 JSValue JS_NewArray(JSContext *ctx);
 int JS_IsArray(JSContext *ctx, JSValueConst val);
@@ -684,9 +691,6 @@ int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
 int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
                       JSValueConst obj, JSAtom prop);
 
-/* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
-JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
-                     const char *filename);
 JSValue JS_Call(JSContext *ctx, JSValueConst func_obj, JSValueConst this_obj,
                 int argc, JSValueConst *argv);
 JSValue JS_Invoke(JSContext *ctx, JSValueConst this_val, JSAtom atom,
@@ -719,6 +723,12 @@ void JS_SetOpaque(JSValue obj, void *opaque);
 void *JS_GetOpaque(JSValueConst obj, JSClassID class_id);
 void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id);
 
+/* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
+JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
+                     const char *filename);
+JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
+                         JSValueConst replacer, JSValueConst space0);
+
 typedef void JSFreeArrayBufferDataFunc(JSRuntime *rt, void *opaque, void *ptr);
 JSValue JS_NewArrayBuffer(JSContext *ctx, uint8_t *buf, size_t len,
                           JSFreeArrayBufferDataFunc *free_func, void *opaque,
@@ -733,6 +743,12 @@ JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
 
 JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
 
+/* is_handled = TRUE means that the rejection is handled */
+typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
+                                           JSValueConst reason,
+                                           JS_BOOL is_handled, void *opaque);
+void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
+
 /* return != 0 if the JS code needs to be interrupted */
 typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);
@@ -873,24 +889,25 @@ typedef struct JSCFunctionListEntry {
 #define JS_DEF_PROP_INT32     4
 #define JS_DEF_PROP_INT64     5
 #define JS_DEF_PROP_DOUBLE    6
-#define JS_DEF_PROP_UNDEFINED  7
+#define JS_DEF_PROP_UNDEFINED 7
 #define JS_DEF_OBJECT         8
 #define JS_DEF_ALIAS          9
 
-#define JS_CFUNC_DEF(name, length, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u.func = { length, JS_CFUNC_generic, { .generic = func1 } } }
-#define JS_CFUNC_MAGIC_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u.func = { length, JS_CFUNC_generic_magic, { .generic_magic = func1 } } }
-#define JS_CFUNC_SPECIAL_DEF(name, length, cproto, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u.func = { length, JS_CFUNC_ ## cproto, { .cproto = func1 } } }
-#define JS_ITERATOR_NEXT_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u.func = { length, JS_CFUNC_iterator_next, { .iterator_next = func1 } } }
-#define JS_CGETSET_DEF(name, fgetter, fsetter) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET, 0, .u.getset.get.getter = fgetter, .u.getset.set.setter = fsetter }
-#define JS_CGETSET_MAGIC_DEF(name, fgetter, fsetter, magic) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET_MAGIC, magic, .u.getset.get.getter_magic = fgetter, .u.getset.set.setter_magic = fsetter }
-#define JS_PROP_STRING_DEF(name, cstr, prop_flags) { name, prop_flags, JS_DEF_PROP_STRING, 0, .u.str = cstr }
-#define JS_PROP_INT32_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT32, 0, .u.i32 = val }
-#define JS_PROP_INT64_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT64, 0, .u.i64 = val }
-#define JS_PROP_DOUBLE_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_DOUBLE, 0, .u.f64 = val }
-#define JS_PROP_UNDEFINED_DEF(name, prop_flags) { name, prop_flags, JS_DEF_PROP_UNDEFINED, 0, .u.i32 = 0 }
-#define JS_OBJECT_DEF(name, tab, len, prop_flags) { name, prop_flags, JS_DEF_OBJECT, 0, .u.prop_list = { tab, len } }
-#define JS_ALIAS_DEF(name, from) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u.alias = { from, -1 } }
-#define JS_ALIAS_BASE_DEF(name, from, base) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u.alias = { from, base } }
+/* Note: c++ does not like nested designators */
+#define JS_CFUNC_DEF(name, length, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u = { .func = { length, JS_CFUNC_generic, { .generic = func1 } } } }
+#define JS_CFUNC_MAGIC_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u = { .func = { length, JS_CFUNC_generic_magic, { .generic_magic = func1 } } } }
+#define JS_CFUNC_SPECIAL_DEF(name, length, cproto, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u = { .func = { length, JS_CFUNC_ ## cproto, { .cproto = func1 } } } }
+#define JS_ITERATOR_NEXT_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u = { .func = { length, JS_CFUNC_iterator_next, { .iterator_next = func1 } } } }
+#define JS_CGETSET_DEF(name, fgetter, fsetter) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET, 0, .u = { .getset = { .get = { .getter = fgetter }, .set = { .setter = fsetter } } } }
+#define JS_CGETSET_MAGIC_DEF(name, fgetter, fsetter, magic) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET_MAGIC, magic, .u = { .getset = { .get = { .getter_magic = fgetter }, .set = { .setter_magic = fsetter } } } }
+#define JS_PROP_STRING_DEF(name, cstr, prop_flags) { name, prop_flags, JS_DEF_PROP_STRING, 0, .u = { .str = cstr } }
+#define JS_PROP_INT32_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT32, 0, .u = { .i32 = val } }
+#define JS_PROP_INT64_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT64, 0, .u = { .i64 = val } }
+#define JS_PROP_DOUBLE_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_DOUBLE, 0, .u = { .f64 = val } }
+#define JS_PROP_UNDEFINED_DEF(name, prop_flags) { name, prop_flags, JS_DEF_PROP_UNDEFINED, 0, .u = { .i32 = 0 } }
+#define JS_OBJECT_DEF(name, tab, len, prop_flags) { name, prop_flags, JS_DEF_OBJECT, 0, .u = { .prop_list = { tab, len } } }
+#define JS_ALIAS_DEF(name, from) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, -1 } } }
+#define JS_ALIAS_BASE_DEF(name, from, base) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, base } } }
 
 void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
                                 const JSCFunctionListEntry *tab,

From af935586aecad27e7ed5d8292b3aed613f2600fc Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 22 Dec 2019 14:27:35 +0300
Subject: [PATCH 042/185] add flags argument to JSCAll callback

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 9c340cffd3..398b640abe 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -610,7 +610,7 @@ struct js_traits<detail::function>
                 nullptr, // mark
                 // call
                 [](JSContext * ctx, JSValueConst func_obj, JSValueConst this_val, int argc,
-                   JSValueConst * argv) -> JSValue {
+                   JSValueConst * argv, int flags) -> JSValue {
                     auto ptr = reinterpret_cast<detail::function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
                     if(!ptr)
                         return JS_EXCEPTION;

From a5c9dccc5a21f229ff6b74032fb108f1d85e24e7 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 9 Jan 2020 12:54:30 +0300
Subject: [PATCH 043/185] update quickjs to 2020-01-05

---
 quickjs/CMakeLists.txt |    8 +-
 quickjs/VERSION        |    2 +-
 quickjs/libbf.c        | 3874 ++++++++++++++++++++++++++++++++--------
 quickjs/libbf.h        |  243 ++-
 quickjs/quickjs-atom.h |    5 +
 quickjs/quickjs-libc.c |    4 +-
 quickjs/quickjs.c      | 3795 +++++++++++++++++++++++++--------------
 quickjs/quickjs.h      |   43 +-
 8 files changed, 5786 insertions(+), 2188 deletions(-)

diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index 11a94b0bee..b6733b7e3f 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -3,15 +3,9 @@ project(quickjs LANGUAGES C)
 
 file(STRINGS VERSION version)
 
-set(quickjs_src quickjs.c libunicode.c libregexp.c cutils.c quickjs-libc.c)
+set(quickjs_src quickjs.c libbf.c libunicode.c libregexp.c cutils.c quickjs-libc.c)
 set(quickjs_def CONFIG_VERSION="${version}" _GNU_SOURCE)
 
-option(QUICKJS_BIGNUM "Compile BigNum support" ON)
-
-if(QUICKJS_BIGNUM)
-  list(APPEND quickjs_src libbf.c)
-  list(APPEND quickjs_def CONFIG_BIGNUM)
-endif()
 
 add_library(quickjs ${quickjs_src})
 target_compile_definitions(quickjs PRIVATE ${quickjs_def} )
diff --git a/quickjs/VERSION b/quickjs/VERSION
index bd167284e5..242aa927f4 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2019-12-21
+2020-01-05
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index d96683de73..25e856d222 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -1,7 +1,7 @@
 /*
  * Tiny arbitrary precision floating point library
  * 
- * Copyright (c) 2017-2018 Fabrice Bellard
+ * Copyright (c) 2017-2020 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -39,6 +39,8 @@
 //#define USE_MUL_CHECK
 /* enable it to use FFT/NTT multiplication */
 #define USE_FFT_MUL
+/* enable decimal floating point support */
+#define USE_BF_DEC
 
 //#define inline __attribute__((always_inline))
 
@@ -49,8 +51,8 @@
 #endif
 
 /* XXX: adjust */
-#define BASECASE_DIV_THRESHOLD_B 300
-#define BASECASE_DIV_THRESHOLD_Q 300
+#define DIVNORM_LARGE_THRESHOLD 50
+#define UDIV1NORM_THRESHOLD 3
 
 #if LIMB_BITS == 64
 #define FMT_LIMB1 "%" PRIx64 
@@ -67,6 +69,8 @@
 
 #endif
 
+typedef intptr_t mp_size_t;
+
 typedef int bf_op2_func_t(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                           bf_flags_t flags);
 
@@ -74,11 +78,18 @@ typedef int bf_op2_func_t(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
 
 #define FFT_MUL_R_OVERLAP_A (1 << 0)
 #define FFT_MUL_R_OVERLAP_B (1 << 1)
+#define FFT_MUL_R_NORESIZE  (1 << 2)
 
-static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
-                              limb_t *b_tab, limb_t b_len, int mul_flags);
+static no_inline int fft_mul(bf_context_t *s,
+                             bf_t *res, limb_t *a_tab, limb_t a_len,
+                             limb_t *b_tab, limb_t b_len, int mul_flags);
 static void fft_clear_cache(bf_context_t *s);
 #endif
+#ifdef USE_BF_DEC
+static void mp_pow_init(void);
+static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos);
+#endif
+
 
 /* could leading zeros */
 static inline int clz(limb_t a)
@@ -115,24 +126,33 @@ static inline int ceil_log2(limb_t a)
         return LIMB_BITS - clz(a - 1);
 }
 
-#if 0
-static inline slimb_t ceil_div(slimb_t a, limb_t b)
+/* b must be >= 1 */
+static inline slimb_t ceil_div(slimb_t a, slimb_t b)
 {
     if (a >= 0)
         return (a + b - 1) / b;
     else
-        return a / (slimb_t)b;
+        return a / b;
 }
 
-static inline slimb_t floor_div(slimb_t a, limb_t b)
+/* b must be >= 1 */
+static inline slimb_t floor_div(slimb_t a, slimb_t b)
 {
     if (a >= 0) {
         return a / b;
     } else {
-        return (a - b + 1) / (slimb_t)b;
+        return (a - b + 1) / b;
     }
 }
-#endif
+
+/* return r = a modulo b (0 <= r <= b - 1. b must be >= 1 */
+static inline limb_t smod(slimb_t a, slimb_t b)
+{
+    a = a % (slimb_t)b;
+    if (a < 0)
+        a += b;
+    return a;
+}
 
 #define malloc(s) malloc_is_forbidden(s)
 #define free(p) free_is_forbidden(p)
@@ -144,6 +164,9 @@ void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
     memset(s, 0, sizeof(*s));
     s->realloc_func = realloc_func;
     s->realloc_opaque = realloc_opaque;
+#ifdef USE_BF_DEC
+    mp_pow_init();
+#endif
 }
 
 void bf_context_end(bf_context_t *s)
@@ -151,17 +174,6 @@ void bf_context_end(bf_context_t *s)
     bf_clear_cache(s);
 }
 
-/* 'size' must be > 0 */
-static void *bf_malloc(bf_context_t *s, size_t size)
-{
-    return bf_realloc(s, NULL, size);
-}
-
-static void bf_free(bf_context_t *s, void *ptr)
-{
-    bf_realloc(s, ptr, 0);
-}
-
 void bf_init(bf_context_t *s, bf_t *r)
 {
     r->ctx = s;
@@ -171,20 +183,28 @@ void bf_init(bf_context_t *s, bf_t *r)
     r->tab = NULL;
 }
 
-void bf_resize(bf_t *r, limb_t len)
+/* return 0 if OK, -1 if alloc error */
+int bf_resize(bf_t *r, limb_t len)
 {
+    limb_t *tab;
+    
     if (len != r->len) {
-        r->tab = bf_realloc(r->ctx, r->tab, len * sizeof(limb_t));
+        tab = bf_realloc(r->ctx, r->tab, len * sizeof(limb_t));
+        if (!tab && len != 0)
+            return -1;
+        r->tab = tab;
         r->len = len;
     }
+    return 0;
 }
 
-void bf_set_ui(bf_t *r, uint64_t a)
+/* return 0 or BF_ST_MEM_ERROR */
+int bf_set_ui(bf_t *r, uint64_t a)
 {
     r->sign = 0;
     if (a == 0) {
         r->expn = BF_EXP_ZERO;
-        bf_resize(r, 0);
+        bf_resize(r, 0); /* cannot fail */
     } 
 #if LIMB_BITS == 32
     else if (a <= 0xffffffff)
@@ -193,7 +213,8 @@ void bf_set_ui(bf_t *r, uint64_t a)
 #endif
     {
         int shift;
-        bf_resize(r, 1);
+        if (bf_resize(r, 1))
+            goto fail;
         shift = clz(a);
         r->tab[0] = a << shift;
         r->expn = LIMB_BITS - shift;
@@ -202,7 +223,8 @@ void bf_set_ui(bf_t *r, uint64_t a)
     else {
         uint32_t a1, a0;
         int shift;
-        bf_resize(r, 2);
+        if (bf_resize(r, 2))
+            goto fail;
         a0 = a;
         a1 = a >> 32;
         shift = clz(a1);
@@ -211,50 +233,63 @@ void bf_set_ui(bf_t *r, uint64_t a)
         r->expn = 2 * LIMB_BITS - shift;
     }
 #endif
+    return 0;
+ fail:
+    bf_set_nan(r);
+    return BF_ST_MEM_ERROR;
 }
 
-void bf_set_si(bf_t *r, int64_t a)
+/* return 0 or BF_ST_MEM_ERROR */
+int bf_set_si(bf_t *r, int64_t a)
 {
+    int ret;
+
     if (a < 0) {
-        bf_set_ui(r, -a);
+        ret = bf_set_ui(r, -a);
         r->sign = 1;
     } else {
-        bf_set_ui(r, a);
+        ret = bf_set_ui(r, a);
     }
+    return ret;
 }
 
 void bf_set_nan(bf_t *r)
 {
-    bf_resize(r, 0);
+    bf_resize(r, 0); /* cannot fail */
     r->expn = BF_EXP_NAN;
     r->sign = 0;
 }
 
 void bf_set_zero(bf_t *r, int is_neg)
 {
-    bf_resize(r, 0);
+    bf_resize(r, 0); /* cannot fail */
     r->expn = BF_EXP_ZERO;
     r->sign = is_neg;
 }
 
 void bf_set_inf(bf_t *r, int is_neg)
 {
-    bf_resize(r, 0);
+    bf_resize(r, 0); /* cannot fail */
     r->expn = BF_EXP_INF;
     r->sign = is_neg;
 }
 
-void bf_set(bf_t *r, const bf_t *a)
+/* return 0 or BF_ST_MEM_ERROR */
+int bf_set(bf_t *r, const bf_t *a)
 {
     if (r == a)
-        return;
+        return 0;
+    if (bf_resize(r, a->len)) {
+        bf_set_nan(r);
+        return BF_ST_MEM_ERROR;
+    }
     r->sign = a->sign;
     r->expn = a->expn;
-    bf_resize(r, a->len);
     memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
+    return 0;
 }
 
-/* equivalent to bf_set(r, a); bf_delete(a) */ 
+/* equivalent to bf_set(r, a); bf_delete(a) */
 void bf_move(bf_t *r, bf_t *a)
 {
     bf_context_t *s = r->ctx;
@@ -317,6 +352,16 @@ static inline limb_t limb_mask(int start, int last)
     return v;
 }
 
+static limb_t mp_scan_nz(const limb_t *tab, mp_size_t n)
+{
+    mp_size_t i;
+    for(i = 0; i < n; i++) {
+        if (tab[i] != 0)
+            return 1;
+    }
+    return 0;
+}
+
 /* return != 0 if one bit between 0 and bit_pos inclusive is not zero. */
 static inline limb_t scan_bit_nz(const bf_t *r, slimb_t bit_pos)
 {
@@ -338,7 +383,8 @@ static inline limb_t scan_bit_nz(const bf_t *r, slimb_t bit_pos)
     return 0;
 }
 
-/* return the addend for rounding. Note that prec can be <= 0 for bf_rint() */
+/* return the addend for rounding. Note that prec can be <= 0 (for
+   BF_FLAG_RADPNT_PREC) */
 static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
                           slimb_t prec, int rnd_mode)
 {
@@ -413,7 +459,10 @@ static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
     } else {
         /* set to maximum finite number */
         l = (prec + LIMB_BITS - 1) / LIMB_BITS;
-        bf_resize(r, l);
+        if (bf_resize(r, l)) {
+            bf_set_nan(r);
+            return BF_ST_MEM_ERROR;
+        }
         r->tab[0] = limb_mask((-prec) & (LIMB_BITS - 1),
                               LIMB_BITS - 1);
         for(i = 1; i < l; i++)
@@ -426,8 +475,9 @@ static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
 }
 
 /* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
-   assumed to have length 'l'. Note: 'prec1' can be negative or
-   infinite (BF_PREC_INF). */
+   assumed to have length 'l' (1 <= l <= r->len). Note: 'prec1' can be
+   infinite (BF_PREC_INF). Can fail with BF_ST_MEM_ERROR in case of
+   overflow not returning infinity. */
 static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
 {
     limb_t v, a;
@@ -439,14 +489,21 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     e_min = -e_range + 3;
     e_max = e_range;
     
-    if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
+    if (flags & BF_FLAG_RADPNT_PREC) {
+        /* 'prec' is the precision after the radix point */
+        if (prec1 != BF_PREC_INF)
+            prec = r->expn + prec1;
+        else
+            prec = prec1;
+    } else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
         /* restrict the precision in case of potentially subnormal
            result */
+        assert(prec1 != BF_PREC_INF);
         prec = prec1 - (e_min - r->expn);
     } else {
         prec = prec1;
     }
-    
+
     /* round to prec bits */
     rnd_mode = flags & BF_RND_MASK;
     ret = 0;
@@ -454,7 +511,7 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     
     if (prec <= 0) {
         if (add_one) {
-            bf_resize(r, 1);
+            bf_resize(r, 1); /* cannot fail */
             r->tab[0] = (limb_t)1 << (LIMB_BITS - 1);
             r->expn += 1 - prec;
             ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
@@ -524,11 +581,11 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
         l -= i;
         memmove(r->tab, r->tab + i, l * sizeof(limb_t));
     }
-    bf_resize(r, l);
+    bf_resize(r, l); /* cannot fail */
     return ret;
 }
 
-/* 'r' must be a finite number */
+/* 'r' must be a finite number. */
 int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
 {
     limb_t l, v, a;
@@ -542,7 +599,7 @@ int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
     if (l == 0) {
         /* zero */
         r->expn = BF_EXP_ZERO;
-        bf_resize(r, 0);
+        bf_resize(r, 0); /* cannot fail */
         ret = 0;
     } else {
         r->expn -= (r->len - l) * LIMB_BITS;
@@ -604,6 +661,7 @@ int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
     return FALSE;
 }
 
+/* Cannot fail with BF_ST_MEM_ERROR. */
 int bf_round(bf_t *r, limb_t prec, bf_flags_t flags)
 {
     if (r->len == 0)
@@ -622,6 +680,32 @@ static __maybe_unused void dump_limbs(const char *str, const limb_t *tab, limb_t
     }
 }
 
+void mp_print_str(const char *str, const limb_t *tab, limb_t n)
+{
+    slimb_t i;
+    printf("%s= 0x", str);
+    for(i = n - 1; i >= 0; i--) {
+        if (i != (n - 1))
+            printf("_");
+        printf(FMT_LIMB, tab[i]);
+    }
+    printf("\n");
+}
+
+static __maybe_unused void mp_print_str_h(const char *str,
+                                          const limb_t *tab, limb_t n,
+                                          limb_t high)
+{
+    slimb_t i;
+    printf("%s= 0x", str);
+    printf(FMT_LIMB, high);
+    for(i = n - 1; i >= 0; i--) {
+        printf("_");
+        printf(FMT_LIMB, tab[i]);
+    }
+    printf("\n");
+}
+
 /* for debugging */
 void bf_print_str(const char *str, const bf_t *a)
 {
@@ -866,7 +950,8 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         precl = (cancelled_bits + prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
         tot_len = bf_max(a->len, b->len + (d + LIMB_BITS - 1) / LIMB_BITS);
         r_len = bf_min(precl, tot_len);
-        bf_resize(r, r_len);
+        if (bf_resize(r, r_len))
+            goto fail;
         a_offset = a->len - r_len;
         b_bit_offset = (b->len - r_len) * LIMB_BITS + d;
 
@@ -933,7 +1018,8 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
 
         /* carry is only possible in add case */
         if (!is_sub && carry) {
-            bf_resize(r, r_len + 1);
+            if (bf_resize(r, r_len + 1))
+                goto fail;
             r->tab[r_len] = 1;
             r->expn += LIMB_BITS;
         }
@@ -941,6 +1027,9 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         ret = bf_normalize_and_round(r, prec, flags);
     }
     return ret;
+ fail:
+    bf_set_nan(r);
+    return BF_ST_MEM_ERROR;
 }
 
 static int __bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
@@ -955,8 +1044,8 @@ static int __bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     return bf_add_internal(r, a, b, prec, flags, 1);
 }
 
-static limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
-                     limb_t n, limb_t carry)
+limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
+              limb_t n, limb_t carry)
 {
     slimb_t i;
     limb_t k, a, v, k1;
@@ -973,9 +1062,111 @@ static limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
     return k;
 }
 
+limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n)
+{
+    size_t i;
+    limb_t k, a;
+
+    k=b;
+    for(i=0;i<n;i++) {
+        if (k == 0)
+            break;
+        a = tab[i] + k;
+        k = (a < k);
+        tab[i] = a;
+    }
+    return k;
+}
+
+limb_t mp_sub(limb_t *res, const limb_t *op1, const limb_t *op2, 
+              mp_size_t n, limb_t carry)
+{
+    int i;
+    limb_t k, a, v, k1;
+    
+    k = carry;
+    for(i=0;i<n;i++) {
+        v = op1[i];
+        a = v - op2[i];
+        k1 = a > v;
+        v = a - k;
+        k = (v > a) | k1;
+        res[i] = v;
+    }
+    return k;
+}
+
+/* compute 0 - op2 */
+static limb_t mp_neg(limb_t *res, const limb_t *op2, mp_size_t n, limb_t carry)
+{
+    int i;
+    limb_t k, a, v, k1;
+    
+    k = carry;
+    for(i=0;i<n;i++) {
+        v = 0;
+        a = v - op2[i];
+        k1 = a > v;
+        v = a - k;
+        k = (v > a) | k1;
+        res[i] = v;
+    }
+    return k;
+}
+
+limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
+{
+    mp_size_t i;
+    limb_t k, a, v;
+    
+    k=b;
+    for(i=0;i<n;i++) {
+        v = tab[i];
+        a = v - k;
+        k = a > v;
+        tab[i] = a;
+        if (k == 0)
+            break;
+    }
+    return k;
+}
+
+/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift). 
+   1 <= shift <= LIMB_BITS - 1 */
+static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+                     int shift, limb_t high)
+{
+    mp_size_t i;
+    limb_t l, a;
+
+    assert(shift >= 1 && shift < LIMB_BITS);
+    l = high;
+    for(i = n - 1; i >= 0; i--) {
+        a = tab[i];
+        tab_r[i] = (a >> shift) | (l << (LIMB_BITS - shift));
+        l = a;
+    }
+    return l & (((limb_t)1 << shift) - 1);
+}
+
+/* tabr[] = taba[] * b + l. Return the high carry */
+static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n, 
+                      limb_t b, limb_t l)
+{
+    limb_t i;
+    dlimb_t t;
+
+    for(i = 0; i < n; i++) {
+        t = (dlimb_t)taba[i] * (dlimb_t)b + l;
+        tabr[i] = t;
+        l = t >> LIMB_BITS;
+    }
+    return l;
+}
+
 /* tabr[] += taba[] * b, return the high word. */
 static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
-                              limb_t b)
+                          limb_t b)
 {
     limb_t i, l;
     dlimb_t t;
@@ -989,6 +1180,42 @@ static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
     return l;
 }
 
+/* size of the result : op1_size + op2_size. */
+static void mp_mul_basecase(limb_t *result, 
+                            const limb_t *op1, limb_t op1_size, 
+                            const limb_t *op2, limb_t op2_size) 
+{
+    limb_t i, r;
+    
+    result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
+    for(i=1;i<op2_size;i++) {
+        r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
+        result[i + op1_size] = r;
+    }
+}
+
+/* return 0 if OK, -1 if memory error */
+/* XXX: change API so that result can be allocated */
+int mp_mul(bf_context_t *s, limb_t *result, 
+           const limb_t *op1, limb_t op1_size, 
+           const limb_t *op2, limb_t op2_size) 
+{
+#ifdef USE_FFT_MUL
+    if (unlikely(bf_min(op1_size, op2_size) >= FFT_MUL_THRESHOLD)) {
+        bf_t r_s, *r = &r_s;
+        r->tab = result;
+        /* XXX: optimize memory usage in API */
+        if (fft_mul(s, r, (limb_t *)op1, op1_size,
+                    (limb_t *)op2, op2_size, FFT_MUL_R_NORESIZE))
+            return -1;
+    } else
+#endif
+    {
+        mp_mul_basecase(result, op1, op1_size, op2, op2_size);
+    }
+    return 0;
+}
+
 /* tabr[] -= taba[] * b. Return the value to substract to the high
    word. */
 static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
@@ -1043,7 +1270,7 @@ static limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
 {
     slimb_t i;
 
-    if (n >= 3) {
+    if (n >= UDIV1NORM_THRESHOLD) {
         limb_t b_inv;
         b_inv = udiv1norm_init(b);
         for(i = n - 1; i >= 0; i--) {
@@ -1060,31 +1287,50 @@ static limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
     return r;
 }
 
+static int mp_divnorm_large(bf_context_t *s, 
+                            limb_t *tabq, limb_t *taba, limb_t na, 
+                            const limb_t *tabb, limb_t nb);
+
 /* base case division: divides taba[0..na-1] by tabb[0..nb-1]. tabb[nb
    - 1] must be >= 1 << (LIMB_BITS - 1). na - nb must be >= 0. 'taba'
    is modified and contains the remainder (nb limbs). tabq[0..na-nb]
-   contains the quotient. taba[na] is modified. */
-static void mp_divnorm(limb_t *tabq, 
-                       limb_t *taba, limb_t na, 
-                       const limb_t *tabb, limb_t nb)
+   contains the quotient with tabq[na - nb] <= 1. */
+static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na, 
+                      const limb_t *tabb, limb_t nb)
 {
     limb_t r, a, c, q, v, b1, b1_inv, n, dummy_r;
-    slimb_t i;
+    slimb_t i, j;
 
     b1 = tabb[nb - 1];
     if (nb == 1) {
         taba[0] = mp_div1norm(tabq, taba, na, b1, 0);
-        return;
+        return 0;
     }
-    taba[na] = 0;
     n = na - nb;
-    if (n >= 3)
+    if (bf_min(n, nb) >= DIVNORM_LARGE_THRESHOLD) {
+        return mp_divnorm_large(s, tabq, taba, na, tabb, nb);
+    }
+    
+    if (n >= UDIV1NORM_THRESHOLD)
         b1_inv = udiv1norm_init(b1);
     else
         b1_inv = 0;
 
-    /* XXX: could simplify the first iteration */
-    for(i = n; i >= 0; i--) {
+    /* first iteration: the quotient is only 0 or 1 */
+    q = 1;
+    for(j = nb - 1; j >= 0; j--) {
+        if (taba[n + j] != tabb[j]) {
+            if (taba[n + j] < tabb[j])
+                q = 0;
+            break;
+        }
+    }
+    tabq[n] = q;
+    if (q) {
+        mp_sub(taba + n, taba + n, tabb, nb, 0);
+    }
+    
+    for(i = n - 1; i >= 0; i--) {
         if (unlikely(taba[i + nb] >= b1)) {
             q = -1;
         } else if (b1_inv) {
@@ -1117,12 +1363,190 @@ static void mp_divnorm(limb_t *tabq,
         }
         tabq[i] = q;
     }
+    return 0;
+}
+
+/* compute r=B^(2*n)/a such as a*r < B^(2*n) < a*r + 2 with n >= 1. 'a'
+   has n limbs with a[n-1] >= B/2 and 'r' has n+1 limbs with r[n] = 1.
+   
+   See Modern Computer Arithmetic by Richard P. Brent and Paul
+   Zimmermann, algorithm 3.5 */
+int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n)
+{
+    mp_size_t l, h, k, i;
+    limb_t *tabxh, *tabt, c, *tabu;
+    
+    if (n <= 2) {
+        /* return ceil(B^(2*n)/a) - 1 */
+        /* XXX: could avoid allocation */
+        tabu = bf_malloc(s, sizeof(limb_t) * (2 * n + 1));
+        tabt = bf_malloc(s, sizeof(limb_t) * (n + 2));
+        if (!tabt || !tabu)
+            goto fail;
+        for(i = 0; i < 2 * n; i++)
+            tabu[i] = 0;
+        tabu[2 * n] = 1;
+        if (mp_divnorm(s, tabt, tabu, 2 * n + 1, taba, n))
+            goto fail;
+        for(i = 0; i < n + 1; i++)
+            tabr[i] = tabt[i];
+        if (mp_scan_nz(tabu, n) == 0) {
+            /* only happens for a=B^n/2 */
+            mp_sub_ui(tabr, 1, n + 1);
+        }
+    } else {
+        l = (n - 1) / 2;
+        h = n - l;
+        /* n=2p  -> l=p-1, h = p + 1, k = p + 3
+           n=2p+1-> l=p,  h = p + 1; k = p + 2
+        */
+        tabt = bf_malloc(s, sizeof(limb_t) * (n + h + 1));
+        tabu = bf_malloc(s, sizeof(limb_t) * (n + 2 * h - l + 2));
+        if (!tabt || !tabu)
+            goto fail;
+        tabxh = tabr + l;
+        if (mp_recip(s, tabxh, taba + l, h))
+            goto fail;
+        if (mp_mul(s, tabt, taba, n, tabxh, h + 1)) /* n + h + 1 limbs */
+            goto fail;
+        while (tabt[n + h] != 0) {
+            mp_sub_ui(tabxh, 1, h + 1);
+            c = mp_sub(tabt, tabt, taba, n, 0);
+            mp_sub_ui(tabt + n, c, h + 1);
+        }
+        /* T = B^(n+h) - T */
+        mp_neg(tabt, tabt, n + h + 1, 0);
+        tabt[n + h]++;
+        if (mp_mul(s, tabu, tabt + l, n + h + 1 - l, tabxh, h + 1))
+            goto fail;
+        /* n + 2*h - l + 2 limbs */
+        k = 2 * h - l;
+        for(i = 0; i < l; i++)
+            tabr[i] = tabu[i + k];
+        mp_add(tabr + l, tabr + l, tabu + 2 * h, h, 0);
+    }
+    bf_free(s, tabt);
+    bf_free(s, tabu);
+    return 0;
+ fail:
+    bf_free(s, tabt);
+    bf_free(s, tabu);
+    return -1;
+}
+
+/* return -1, 0 or 1 */
+static int mp_cmp(const limb_t *taba, const limb_t *tabb, mp_size_t n)
+{
+    mp_size_t i;
+    for(i = n - 1; i >= 0; i--) {
+        if (taba[i] != tabb[i]) {
+            if (taba[i] < tabb[i])
+                return -1;
+            else
+                return 1;
+        }
+    }
+    return 0;
+}
+
+//#define DEBUG_DIVNORM_LARGE
+//#define DEBUG_DIVNORM_LARGE2
+
+/* subquadratic divnorm */
+static int mp_divnorm_large(bf_context_t *s, 
+                            limb_t *tabq, limb_t *taba, limb_t na, 
+                            const limb_t *tabb, limb_t nb)
+{
+    limb_t *tabb_inv, nq, *tabt, i, n;
+    nq = na - nb;
+#ifdef DEBUG_DIVNORM_LARGE
+    printf("na=%d nb=%d nq=%d\n", (int)na, (int)nb, (int)nq);
+    mp_print_str("a", taba, na);
+    mp_print_str("b", tabb, nb);
+#endif
+    assert(nq >= 1);
+    n = nq;
+    if (nq < nb)
+        n++; 
+    tabb_inv = bf_malloc(s, sizeof(limb_t) * (n + 1));
+    tabt = bf_malloc(s, sizeof(limb_t) * 2 * (n + 1));
+    if (!tabb_inv || !tabt)
+        goto fail;
+
+    if (n >= nb) {
+        for(i = 0; i < n - nb; i++)
+            tabt[i] = 0;
+        for(i = 0; i < nb; i++)
+            tabt[i + n - nb] = tabb[i];
+    } else {
+        /* truncate B: need to increment it so that the approximate
+           inverse is smaller that the exact inverse */
+        for(i = 0; i < n; i++)
+            tabt[i] = tabb[i + nb - n];
+        if (mp_add_ui(tabt, 1, n)) {
+            /* tabt = B^n : tabb_inv = B^n */
+            memset(tabb_inv, 0, n * sizeof(limb_t));
+            tabb_inv[n] = 1;
+            goto recip_done;
+        }
+    }
+    if (mp_recip(s, tabb_inv, tabt, n))
+        goto fail;
+ recip_done:
+    /* Q=A*B^-1 */
+    if (mp_mul(s, tabt, tabb_inv, n + 1, taba + na - (n + 1), n + 1))
+        goto fail;
+    
+    for(i = 0; i < nq + 1; i++)
+        tabq[i] = tabt[i + 2 * (n + 1) - (nq + 1)];
+#ifdef DEBUG_DIVNORM_LARGE
+    mp_print_str("q", tabq, nq + 1);
+#endif
+
+    bf_free(s, tabt);
+    bf_free(s, tabb_inv);
+    tabb_inv = NULL;
+    
+    /* R=A-B*Q */
+    tabt = bf_malloc(s, sizeof(limb_t) * (na + 1));
+    if (!tabt)
+        goto fail;
+    if (mp_mul(s, tabt, tabq, nq + 1, tabb, nb))
+        goto fail;
+    /* we add one more limb for the result */
+    mp_sub(taba, taba, tabt, nb + 1, 0);
+    bf_free(s, tabt);
+    /* the approximated quotient is smaller than than the exact one,
+       hence we may have to increment it */
+#ifdef DEBUG_DIVNORM_LARGE2
+    int cnt = 0;
+    static int cnt_max;
+#endif
+    for(;;) {
+        if (taba[nb] == 0 && mp_cmp(taba, tabb, nb) < 0)
+            break;
+        taba[nb] -= mp_sub(taba, taba, tabb, nb, 0);
+        mp_add_ui(tabq, 1, nq + 1);
+#ifdef DEBUG_DIVNORM_LARGE2
+        cnt++;
+#endif
+    }
+#ifdef DEBUG_DIVNORM_LARGE2
+    if (cnt > cnt_max) {
+        cnt_max = cnt;
+        printf("\ncnt=%d nq=%d nb=%d\n", cnt_max, (int)nq, (int)nb);
+    }
+#endif
+    return 0;
+ fail:
+    bf_free(s, tabb_inv);
+    bf_free(s, tabt);
+    return -1;
 }
 
 int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
            bf_flags_t flags)
 {
-    limb_t i;
     int ret, r_sign;
 
     if (a->len < b->len) {
@@ -1173,7 +1597,8 @@ int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                 mul_flags |= FFT_MUL_R_OVERLAP_A;
             if (r == b)
                 mul_flags |= FFT_MUL_R_OVERLAP_B;
-            fft_mul(r, a_tab, a_len, b_tab, b_len, mul_flags);
+            if (fft_mul(r->ctx, r, a_tab, a_len, b_tab, b_len, mul_flags))
+                goto fail;
         } else
 #endif
         {
@@ -1182,16 +1607,18 @@ int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                 r1 = r;
                 r = &tmp;
             }
-            bf_resize(r, a_len + b_len);
-            memset(r->tab, 0, sizeof(limb_t) * a_len);
-            for(i = 0; i < b_len; i++) {
-                r->tab[i + a_len] = mp_add_mul1(r->tab + i, a_tab, a_len,
-                                                b_tab[i]);
+            if (bf_resize(r, a_len + b_len)) {
+            fail:
+                bf_set_nan(r);
+                ret = BF_ST_MEM_ERROR;
+                goto done;
             }
+            mp_mul_basecase(r->tab, a_tab, a_len, b_tab, b_len);
         }
         r->sign = r_sign;
         r->expn = a->expn + b->expn;
         ret = bf_normalize_and_round(r, prec, flags);
+    done:
         if (r == &tmp)
             bf_move(r1, &tmp);
     }
@@ -1211,83 +1638,6 @@ int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags)
     return __bf_round(r, prec, flags, r->len);
 }
 
-static void bf_recip_rec(bf_t *a, const bf_t *x, limb_t prec1)
-{
-    bf_t t0;
-    limb_t prec;
-
-    bf_init(a->ctx, &t0);
-
-    if (prec1 <= LIMB_BITS - 3) {
-        limb_t v;
-        /* initial approximation */
-        v = x->tab[x->len - 1];
-        /* 2^(L-1) <= v <= 2^L-1 (L=LIMB_BITS) */
-        v = ((dlimb_t)1 << (2 * LIMB_BITS - 2)) / v;
-        /* 2^(L-2) <= v <= 2^(L-1) */
-        bf_resize(a, 1);
-        a->sign = x->sign;
-        a->expn = 2 - x->expn;
-        if (v == ((limb_t)1 << (LIMB_BITS - 1))) {
-            a->tab[0] = v;
-        } else {
-            a->tab[0] = v << 1;
-            a->expn--;
-        }
-        a->tab[0] &= limb_mask(LIMB_BITS - prec1, LIMB_BITS - 1);
-    } else {
-        /* XXX: prove the added precision */
-        bf_recip_rec(a, x, (prec1 / 2) + 8);
-        prec = prec1 + 8;
-
-        /* a = a + a * (1 - x * a) */
-        bf_mul(&t0, x, a, prec, BF_RNDF);
-        t0.sign ^= 1;
-        bf_add_si(&t0, &t0, 1, prec, BF_RNDF);
-        bf_mul(&t0, &t0, a, prec, BF_RNDF);
-        bf_add(a, a, &t0, prec1, BF_RNDF);
-    }
-    //    bf_print_str("r", a);
-    bf_delete(&t0);
-}
-
-/* Note: only faithful rounding is supported */
-void bf_recip(bf_t *r, const bf_t *a, limb_t prec)
-{
-    assert(r != a);
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_zero(r, a->sign);
-        } else {
-            bf_set_inf(r, a->sign);
-        }
-    } else {
-        //        bf_print_str("a", a);
-        bf_recip_rec(r, a, prec);
-    }
-}
-
-/* add zero limbs if necessary to have at least precl limbs */
-static void bf_add_zero_limbs(bf_t *r, limb_t precl)
-{
-    limb_t l = r->len;
-    if (l < precl) {
-        bf_resize(r, precl);
-        memmove(r->tab + precl - l, r->tab,
-                l * sizeof(limb_t));
-        memset(r->tab, 0, (precl - l) * sizeof(limb_t));
-    }
-}
-
-/* set a bit to 1 at bit position >= (precl * LIMB_BITS - 1) */
-static void bf_or_one(bf_t *r, limb_t precl)
-{
-    bf_add_zero_limbs(r, precl);
-    r->tab[0] |= 1;
-}
-
 /* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
    Infinite or Nan. */
 slimb_t bf_get_exp_min(const bf_t *a)
@@ -1311,26 +1661,21 @@ slimb_t bf_get_exp_min(const bf_t *a)
 static void bf_tdivremu(bf_t *q, bf_t *r,
                         const bf_t *a, const bf_t *b)
 {
-    if (a->expn < b->expn) {
+    if (bf_cmpu(a, b) < 0) {
         bf_set_ui(q, 0);
         bf_set(r, a);
     } else {
-        /* for large numbers, use the floating point division in
-           faithful mode */
-        bf_div(q, a, b, bf_max(a->expn - b->expn + 1, 2), BF_RNDF);
-        bf_rint(q, BF_PREC_INF, BF_RNDZ);
-        bf_mul(r, q, b, BF_PREC_INF, BF_RNDN);
-        bf_sub(r, a, r, BF_PREC_INF, BF_RNDN);
-        if (r->len != 0 && r->sign) {
-            bf_add_si(q, q, -1, BF_PREC_INF, BF_RNDZ);
-            bf_add(r, r, b, BF_PREC_INF, BF_RNDZ);
-        }
+        bf_div(q, a, b, bf_max(a->expn - b->expn + 1, 2), BF_RNDZ);
+        bf_rint(q, BF_RNDZ);
+        bf_mul(r, q, b, BF_PREC_INF, BF_RNDZ);
+        bf_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
     }
 }
 
 static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                     bf_flags_t flags)
 {
+    bf_context_t *s = r->ctx;
     int ret, r_sign;
     limb_t n, nb, precl;
     
@@ -1367,65 +1712,34 @@ static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     nb = b->len;
     n = bf_max(a->len, precl);
     
-    if (nb <= BASECASE_DIV_THRESHOLD_B ||
-        (slimb_t)n <= (BASECASE_DIV_THRESHOLD_Q - 1)) {
-        limb_t *taba, na, i;
+    {
+        limb_t *taba, na;
         slimb_t d;
         
         na = n + nb;
-        taba = bf_malloc(r->ctx, (na + 1) * sizeof(limb_t));
+        taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
+        if (!taba)
+            goto fail;
         d = na - a->len;
         memset(taba, 0, d * sizeof(limb_t));
         memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
-        bf_resize(r, n + 1);
-        mp_divnorm(r->tab, taba, na, b->tab, nb);
+        if (bf_resize(r, n + 1))
+            goto fail;
+        if (mp_divnorm(s, r->tab, taba, na, b->tab, nb))
+            goto fail;
         
         /* see if non zero remainder */
-        for(i = 0; i < nb; i++) {
-            if (taba[i] != 0) {
-                r->tab[0] |= 1;
-                break;
-            }
-        }
+        if (mp_scan_nz(taba, nb))
+            r->tab[0] |= 1;
         bf_free(r->ctx, taba);
         r->expn = a->expn - b->expn + LIMB_BITS;
         r->sign = r_sign;
         ret = bf_normalize_and_round(r, prec, flags);
-    } else if ((flags & BF_RND_MASK) == BF_RNDF) {
-        bf_t b_inv;
-        bf_init(r->ctx, &b_inv);
-        bf_recip(&b_inv, b, prec + 3);
-        ret = bf_mul(r, a, &b_inv, prec, flags);
-        bf_delete(&b_inv);
-    } else {
-        bf_t a1_s, *a1 = &a1_s;
-        bf_t b1_s, *b1 = &b1_s;
-        bf_t rem_s, *rem = &rem_s;
-        
-        /* convert the mantissa of 'a' and 'b' to integers and generate
-           a quotient with at least prec + 2 bits */
-        a1->expn = (n + nb) * LIMB_BITS;
-        a1->tab = a->tab;
-        a1->len = a->len;
-        a1->sign = 0;
-
-        b1->expn = nb * LIMB_BITS;
-        b1->tab = b->tab;
-        b1->len = nb;
-        b1->sign = 0;
-
-        bf_init(r->ctx, rem);
-        bf_tdivremu(r, rem, a1, b1);
-        /* the remainder is not zero: put it in the rounding bits */
-        if (rem->len != 0) {
-            bf_or_one(r, precl);
-        }
-        bf_delete(rem);
-        r->expn += a->expn - b->expn - n * LIMB_BITS;
-        r->sign = r_sign;
-        ret = bf_round(r, prec, flags);
     }
     return ret;
+ fail:
+    bf_set_nan(r);
+    return BF_ST_MEM_ERROR;
 }
 
 /* division and remainder. 
@@ -1441,7 +1755,7 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
 {
     bf_t a1_s, *a1 = &a1_s;
     bf_t b1_s, *b1 = &b1_s;
-    int q_sign;
+    int q_sign, ret;
     BOOL is_ceil, is_rndn;
     
     assert(q != a && q != b);
@@ -1498,6 +1812,8 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
 
     /* XXX: could improve to avoid having a large 'q' */
     bf_tdivremu(q, r, a1, b1);
+    if (bf_is_nan(q) || bf_is_nan(r))
+        goto fail;
 
     if (r->len != 0) {
         if (is_rndn) {
@@ -1513,14 +1829,20 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
             }
         } else if (is_ceil) {
         do_sub_r:
-            bf_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
-            bf_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
+            ret = bf_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
+            ret |= bf_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
+            if (ret & BF_ST_MEM_ERROR)
+                goto fail;
         }
     }
 
     r->sign ^= a->sign;
     q->sign = q_sign;
     return bf_round(r, prec, flags);
+ fail:
+    bf_set_nan(q);
+    bf_set_nan(r);
+    return BF_ST_MEM_ERROR;
 }
 
 int bf_fmod(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
@@ -1590,136 +1912,193 @@ static limb_t mp_mod1(const limb_t *tab, limb_t n, limb_t m, limb_t r)
 }
 #endif
 
-/* (128.0 / sqrt((i + 64) / 256)) & 0xff */
-static const uint8_t rsqrt_table[192] = {
-  0,254,252,250,248,247,245,243,241,240,238,236,235,233,232,230,
-229,228,226,225,223,222,221,220,218,217,216,215,214,212,211,210,
-209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,
-194,193,192,191,190,189,189,188,187,186,185,185,184,183,182,182,
-181,180,180,179,178,178,177,176,176,175,174,174,173,172,172,171,
-171,170,169,169,168,168,167,167,166,166,165,164,164,163,163,162,
-162,161,161,160,160,159,159,158,158,158,157,157,156,156,155,155,
-154,154,154,153,153,152,152,151,151,151,150,150,149,149,149,148,
-148,147,147,147,146,146,146,145,145,144,144,144,143,143,143,142,
-142,142,141,141,141,140,140,140,139,139,139,138,138,138,137,137,
-137,137,136,136,136,135,135,135,134,134,134,134,133,133,133,132,
-132,132,132,131,131,131,131,130,130,130,130,129,129,129,129,128,
+static const uint16_t sqrt_table[192] = {
+128,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,144,145,146,147,148,149,150,150,151,152,153,154,155,155,156,157,158,159,160,160,161,162,163,163,164,165,166,167,167,168,169,170,170,171,172,173,173,174,175,176,176,177,178,178,179,180,181,181,182,183,183,184,185,185,186,187,187,188,189,189,190,191,192,192,193,193,194,195,195,196,197,197,198,199,199,200,201,201,202,203,203,204,204,205,206,206,207,208,208,209,209,210,211,211,212,212,213,214,214,215,215,216,217,217,218,218,219,219,220,221,221,222,222,223,224,224,225,225,226,226,227,227,228,229,229,230,230,231,231,232,232,233,234,234,235,235,236,236,237,237,238,238,239,240,240,241,241,242,242,243,243,244,244,245,245,246,246,247,247,248,248,249,249,250,250,251,251,252,252,253,253,254,254,255,
 };
 
-static void __bf_rsqrt(bf_t *a, const bf_t *x, limb_t prec1)
-{
-    bf_t t0;
-    limb_t prec;
-
-    if (prec1 <= 7) {
-        slimb_t e;
-        limb_t v;
-        /* initial approximation using 8 mantissa bits */
-        v = x->tab[x->len - 1];
-        e = x->expn;
-        if (e & 1) {
-            v >>= 1;
-            e++;
-        }
-        v = rsqrt_table[(v >> (LIMB_BITS - 8)) - 64];
-        e = 1 - (e / 2);
-        if (v == 0) {
-            v = 128; /* real table value is 256 */
-            e++;
-        }
-        bf_resize(a, 1);
-        a->tab[0] = (v << (LIMB_BITS - 8)) &
-            limb_mask(LIMB_BITS - prec1, LIMB_BITS - 1);
-        a->expn = e;
-        a->sign = 0;
-    } else {
-        /* XXX: prove rounding */
-        __bf_rsqrt(a, x, (prec1 / 2) + 2);
-
-        prec = prec1 + 3;
+/* a >= 2^(LIMB_BITS - 2).  Return (s, r) with s=floor(sqrt(a)) and
+   r=a-s^2. 0 <= r <= 2 * s */
+static limb_t mp_sqrtrem1(limb_t *pr, limb_t a)
+{
+    limb_t s1, r1, s, r, q, u, num;
+    
+    /* use a table for the 16 -> 8 bit sqrt */
+    s1 = sqrt_table[(a >> (LIMB_BITS - 8)) - 64];
+    r1 = (a >> (LIMB_BITS - 16)) - s1 * s1;
+    if (r1 > 2 * s1) {
+        r1 -= 2 * s1 + 1;
+        s1++;
+    }
+    
+    /* one iteration to get a 32 -> 16 bit sqrt */
+    num = (r1 << 8) | ((a >> (LIMB_BITS - 32 + 8)) & 0xff);
+    q = num / (2 * s1); /* q <= 2^8 */
+    u = num % (2 * s1);
+    s = (s1 << 8) + q;
+    r = (u << 8) | ((a >> (LIMB_BITS - 32)) & 0xff);
+    r -= q * q;
+    if ((slimb_t)r < 0) {
+        s--;
+        r += 2 * s + 1;
+    }
 
-        /* x' = x + (x/2) * (1 - a * x^2) */
-        bf_init(a->ctx, &t0);
+#if LIMB_BITS == 64
+    s1 = s;
+    r1 = r;
+    /* one more iteration for 64 -> 32 bit sqrt */
+    num = (r1 << 16) | ((a >> (LIMB_BITS - 64 + 16)) & 0xffff);
+    q = num / (2 * s1); /* q <= 2^16 */
+    u = num % (2 * s1);
+    s = (s1 << 16) + q;
+    r = (u << 16) | ((a >> (LIMB_BITS - 64)) & 0xffff);
+    r -= q * q;
+    if ((slimb_t)r < 0) {
+        s--;
+        r += 2 * s + 1;
+    }
+#endif
+    *pr = r;
+    return s;
+}
 
-        bf_mul(&t0, a, a, prec, BF_RNDF);
-        bf_mul(&t0, &t0, x, prec, BF_RNDF);
-        t0.sign ^= 1;
-        bf_add_si(&t0, &t0, 1, prec, BF_RNDF);
-        bf_mul(&t0, &t0, a, prec, BF_RNDF);
-        if (t0.len != 0)
-            t0.expn--;
-        bf_add(a, a, &t0, prec1, BF_RNDF);
+/* return floor(sqrt(a)) */
+limb_t bf_isqrt(limb_t a)
+{
+    limb_t s, r;
+    int k;
 
-        bf_delete(&t0);
-    }
+    if (a == 0)
+        return 0;
+    k = clz(a) & ~1;
+    s = mp_sqrtrem1(&r, a << k);
+    s >>= (k >> 1);
+    return s;
 }
 
-static int __bf_sqrt(bf_t *x, const bf_t *a, limb_t prec1, bf_flags_t flags)
+static limb_t mp_sqrtrem2(limb_t *tabs, limb_t *taba)
 {
-    bf_t t0, t1;
-    limb_t prec;
-    int ret;
-    
-    /* XXX: prove rounding */
-    __bf_rsqrt(x, a, (prec1 / 2) + 2);
-    prec = prec1 + 3;
-
-    /* x' = a * x + (x/2) * (a - (a * x)^2) */
-    
-    bf_init(x->ctx, &t0);
-    bf_init(x->ctx, &t1);
-    bf_mul(&t1, x, a, prec, BF_RNDF);
-    bf_mul(&t0, &t1, &t1, prec, BF_RNDF);
-    t0.sign ^= 1;
-    bf_add(&t0, &t0, a, prec, BF_RNDF);
-    bf_mul(&t0, &t0, x, prec, BF_RNDF);
-    if (t0.len != 0)
-        t0.expn--;
-    ret = bf_add(x, &t1, &t0, prec1, flags);
-    
-    bf_delete(&t0);
-    bf_delete(&t1);
-    return ret;
+    limb_t s1, r1, s, q, u, a0, a1;
+    dlimb_t r, num;
+    int l;
+
+    a0 = taba[0];
+    a1 = taba[1];
+    s1 = mp_sqrtrem1(&r1, a1);
+    l = LIMB_BITS / 2;
+    num = ((dlimb_t)r1 << l) | (a0 >> l);
+    q = num / (2 * s1);
+    u = num % (2 * s1);
+    s = (s1 << l) + q;
+    r = ((dlimb_t)u << l) | (a0 & (((limb_t)1 << l) - 1));
+    if (unlikely((q >> l) != 0))
+        r -= (dlimb_t)1 << LIMB_BITS; /* special case when q=2^l */
+    else
+        r -= q * q;
+    if ((slimb_t)(r >> LIMB_BITS) < 0) {
+        s--;
+        r += 2 * (dlimb_t)s + 1;
+    }
+    tabs[0] = s;
+    taba[0] = r;
+    return r >> LIMB_BITS;
 }
 
-/* Note: only faithful rounding is supported */
-void bf_rsqrt(bf_t *r, const bf_t *a, limb_t prec)
+//#define DEBUG_SQRTREM
+
+/* tmp_buf must contain (n / 2 + 1 limbs). *prh contains the highest
+   limb of the remainder. */
+static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
+                          limb_t *tmp_buf, limb_t *prh)
 {
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN ||
-            (a->sign && a->expn != BF_EXP_ZERO)) {
-            bf_set_nan(r);
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_zero(r, a->sign);
-        } else {
-            bf_set_inf(r, 0);
-        }
-    } else if (a->sign) {
-        bf_set_nan(r);
+    limb_t l, h, rh, ql, qh, c, i;
+    
+    if (n == 1) {
+        *prh = mp_sqrtrem2(tabs, taba);
+        return 0;
+    }
+#ifdef DEBUG_SQRTREM
+    mp_print_str("a", taba, 2 * n);
+#endif
+    l = n / 2;
+    h = n - l;
+    if (mp_sqrtrem_rec(s, tabs + l, taba + 2 * l, h, tmp_buf, &qh))
+        return -1;
+#ifdef DEBUG_SQRTREM
+    mp_print_str("s1", tabs + l, h);
+    mp_print_str_h("r1", taba + 2 * l, h, qh);
+    mp_print_str_h("r2", taba + l, n, qh);
+#endif
+    
+    /* the remainder is in taba + 2 * l. Its high bit is in qh */
+    if (qh) {
+        mp_sub(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
+    }
+    /* instead of dividing by 2*s, divide by s (which is normalized)
+       and update q and r */
+    if (mp_divnorm(s, tmp_buf, taba + l, n, tabs + l, h))
+        return -1;
+    qh += tmp_buf[l];
+    for(i = 0; i < l; i++)
+        tabs[i] = tmp_buf[i];
+    ql = mp_shr(tabs, tabs, l, 1, qh & 1);
+    qh = qh >> 1; /* 0 or 1 */
+    if (ql)
+        rh = mp_add(taba + l, taba + l, tabs + l, h, 0);
+    else
+        rh = 0;
+#ifdef DEBUG_SQRTREM
+    mp_print_str_h("q", tabs, l, qh);
+    mp_print_str_h("u", taba + l, h, rh);
+#endif
+    
+    mp_add_ui(tabs + l, qh, h);
+#ifdef DEBUG_SQRTREM
+    mp_print_str_h("s2", tabs, n, sh);
+#endif
+    
+    /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
+    /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
+    if (qh) {
+        c = qh;
     } else {
-        //        bf_print_str("a", a);
-        __bf_rsqrt(r, a, prec);
+        if (mp_mul(s, taba + n, tabs, l, tabs, l))
+            return -1;
+        c = mp_sub(taba, taba, taba + n, 2 * l, 0);
     }
+    rh -= mp_sub_ui(taba + 2 * l, c, n - 2 * l);
+    if ((slimb_t)rh < 0) {
+        mp_sub_ui(tabs, 1, n);
+        rh += mp_add_mul1(taba, tabs, n, 2);
+        rh += mp_add_ui(taba, 1, n);
+    }
+    *prh = rh;
+    return 0;
 }
 
-/* return floor(sqrt(a)) */
-static limb_t bf_isqrt(limb_t a)
+/* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= 2 ^ (LIMB_BITS
+   - 2). Return (s, r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2
+   * s. tabs has n limbs. r is returned in the lower n limbs of
+   taba. Its r[n] is the returned value of the function. */
+/* Algorithm from the article "Karatsuba Square Root" by Paul Zimmermann and
+   inspirated from its GMP implementation */
+int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
 {
-    unsigned int l;
-    limb_t u, s;
-    
-    if (a == 0)
-        return 0;
-    l = ceil_log2(a);
-    u = (limb_t)1 << ((l + 1) / 2);
-    /* u >= floor(sqrt(a)) */
-    for(;;) {
-        s = u;
-        u = ((a / s) + s) / 2;
-        if (u >= s)
-            break;
+    limb_t tmp_buf1[8];
+    limb_t *tmp_buf;
+    mp_size_t n2;
+    int ret;
+    n2 = n / 2 + 1;
+    if (n2 <= countof(tmp_buf1)) {
+        tmp_buf = tmp_buf1;
+    } else {
+        tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
+        if (!tmp_buf)
+            return -1;
     }
-    return s;
+    ret = mp_sqrtrem_rec(s, tabs, taba, n, tmp_buf, taba + n);
+    if (tmp_buf != tmp_buf1)
+        bf_free(s, tmp_buf);
+    return ret;
 }
 
 /* Integer square root with remainder. 'a' must be an integer. r =
@@ -1748,10 +2127,9 @@ int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
         ret = BF_ST_INVALID_OP;
     } else {
         bf_t rem_s, *rem;
-        int res;
         
-        bf_sqrt(r, a, (a->expn + 1) / 2, BF_RNDF);
-        bf_rint(r, BF_PREC_INF, BF_RNDZ);
+        bf_sqrt(r, a, (a->expn + 1) / 2, BF_RNDZ);
+        bf_rint(r, BF_RNDZ);
         /* see if the result is exact by computing the remainder */
         if (rem1) {
             rem = rem1;
@@ -1759,43 +2137,30 @@ int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
             rem = &rem_s;
             bf_init(r->ctx, rem);
         }
+        /* XXX: could avoid recomputing the remainder */
         bf_mul(rem, r, r, BF_PREC_INF, BF_RNDZ);
-        ret = 0;
-        if (rem1) {
-            bf_neg(rem);
-            bf_add(rem, rem, a, BF_PREC_INF, BF_RNDZ);
-            if (rem->len != 0) {
-                ret = BF_ST_INEXACT;
-                if (rem->sign) {
-                    bf_t a1_s, *a1 = &a1_s;
-                    bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ);
-                    a1->tab = a->tab;
-                    a1->len = a->len;
-                    a1->sign = a->sign;
-                    a1->expn = a->expn + 1;
-                    bf_add(rem, rem, r, BF_PREC_INF, BF_RNDZ);
-                    bf_add_si(rem, rem, 1, BF_PREC_INF, BF_RNDZ);
-                }
-            } else {
-                ret = 0;
-            }
+        bf_neg(rem);
+        bf_add(rem, rem, a, BF_PREC_INF, BF_RNDZ);
+        if (bf_is_nan(rem)) {
+            ret = BF_ST_MEM_ERROR;
+            goto done;
+        }
+        if (rem->len != 0) {
+            ret = BF_ST_INEXACT;
         } else {
-            res = bf_cmpu(rem, a);
-            bf_delete(rem);
-            //            printf("res2=%d\n", res2);
-            if (res > 0) {
-                /* need to correct the result */
-                bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ);
-            }
-            ret = (res != 0 ? BF_ST_INEXACT : 0);
+            ret = 0;
         }
+    done:
+        if (!rem1)
+            bf_delete(rem);
     }
     return ret;
 }
 
 int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
-    int rnd_mode, ret;
+    bf_context_t *s = a->ctx;
+    int ret;
 
     assert(r != a);
 
@@ -1813,34 +2178,47 @@ int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
         bf_set_nan(r);
         ret = BF_ST_INVALID_OP;
     } else {
-        rnd_mode = flags & BF_RND_MASK;
-        if (rnd_mode == BF_RNDF) {
-            ret = __bf_sqrt(r, a, prec, flags);
+        limb_t *a1;
+        slimb_t n, n1;
+        limb_t res;
+        
+        /* convert the mantissa to an integer with at least 2 *
+           prec + 4 bits */
+        n = (2 * (prec + 2) + 2 * LIMB_BITS - 1) / (2 * LIMB_BITS);
+        if (bf_resize(r, n))
+            goto fail;
+        a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
+        if (!a1)
+            goto fail;
+        n1 = bf_min(2 * n, a->len);
+        memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
+        memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
+        if (a->expn & 1) {
+            res = mp_shr(a1, a1, 2 * n, 1, 0);
         } else {
-            bf_t a1_s, *a1 = &a1_s;
-            slimb_t d, prec2;
-            int res1, res2;
-
-            bf_init(r->ctx, a1);
-            bf_set(a1, a);
-            /* convert the mantissa to an integer with at most 2 *
-               prec + 4 bits */
-            prec2 = prec + 2;
-            /* make '-a->expn + d' divisible by two */
-            d = prec2 * 2 - (a->expn & 1);
-            a1->expn = d;
-            res1 = bf_rint(a1, BF_PREC_INF, BF_RNDZ);
-            res2 = bf_sqrtrem(r, NULL, a1);
-            bf_delete(a1);
-            if ((res2 | res1) != 0) {
-                bf_or_one(r, (prec2 + LIMB_BITS - 1) / LIMB_BITS);
-            }
-            /* update the exponent */
-            r->expn -= (-a->expn + d) >> 1;
-            ret = bf_round(r, prec, flags);
+            res = 0;
+        }
+        if (mp_sqrtrem(s, r->tab, a1, n)) {
+            bf_free(s, a1);
+            goto fail;
         }
+        if (!res) {
+            res = mp_scan_nz(a1, n + 1);
+        }
+        bf_free(s, a1);
+        if (!res) {
+            res = mp_scan_nz(a->tab, a->len - n1);
+        }
+        if (res != 0)
+            r->tab[0] |= 1;
+        r->sign = 0;
+        r->expn = (a->expn + 1) >> 1;
+        ret = bf_round(r, prec, flags);
     }
     return ret;
+ fail:
+    bf_set_nan(r);
+    return BF_ST_MEM_ERROR;
 }
 
 static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
@@ -1883,8 +2261,8 @@ int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec,
     bf_t b;
     int ret;
     bf_init(r->ctx, &b);
-    bf_set_ui(&b, b1);
-    ret = bf_mul(r, a, &b, prec, flags);
+    ret = bf_set_ui(&b, b1);
+    ret |= bf_mul(r, a, &b, prec, flags);
     bf_delete(&b);
     return ret;
 }
@@ -1895,8 +2273,8 @@ int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
     bf_t b;
     int ret;
     bf_init(r->ctx, &b);
-    bf_set_si(&b, b1);
-    ret = bf_mul(r, a, &b, prec, flags);
+    ret = bf_set_si(&b, b1);
+    ret |= bf_mul(r, a, &b, prec, flags);
     bf_delete(&b);
     return ret;
 }
@@ -1908,24 +2286,21 @@ int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
     int ret;
     
     bf_init(r->ctx, &b);
-    bf_set_si(&b, b1);
-    ret = bf_add(r, a, &b, prec, flags);
+    ret = bf_set_si(&b, b1);
+    ret |= bf_add(r, a, &b, prec, flags);
     bf_delete(&b);
     return ret;
 }
 
-int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
-              bf_flags_t flags)
+static int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
+                     bf_flags_t flags)
 {
     int ret, n_bits, i;
     
     assert(r != a);
-    if (b == 0) {
-        bf_set_ui(r, 1);
-        return 0;
-    }
-    bf_set(r, a);
-    ret = 0;
+    if (b == 0)
+        return bf_set_ui(r, 1);
+    ret = bf_set(r, a);
     n_bits = LIMB_BITS - clz(b);
     for(i = n_bits - 2; i >= 0; i--) {
         ret |= bf_mul(r, r, r, prec, flags);
@@ -1935,31 +2310,29 @@ int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
     return ret;
 }
 
-int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b, limb_t prec, bf_flags_t flags)
+static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
+                        limb_t prec, bf_flags_t flags)
 {
     bf_t a;
     int ret;
     
-    bf_init(r->ctx, &a);
-    bf_set_ui(&a, a1);
-    ret = bf_pow_ui(r, &a, b, prec, flags);
-    bf_delete(&a);
+    if (a1 == 10 && b <= LIMB_DIGITS) {
+        /* use precomputed powers. We do not round at this point
+           because we expect the caller to do it */
+        ret = bf_set_ui(r, mp_pow_dec[b]);
+    } else {
+        bf_init(r->ctx, &a);
+        ret = bf_set_ui(&a, a1);
+        ret |= bf_pow_ui(r, &a, b, prec, flags);
+        bf_delete(&a);
+    }
     return ret;
 }
 
-/* convert to integer (single rounding) */
-int bf_rint(bf_t *r, limb_t prec, bf_flags_t flags)
+/* convert to integer (infinite precision) */
+int bf_rint(bf_t *r, int rnd_mode)
 {
-    int ret;
-    if (r->len == 0)
-        return 0;
-    if (r->expn <= 0) {
-        ret = __bf_round(r, r->expn, flags & ~BF_FLAG_SUBNORMAL, r->len) &
-            ~BF_ST_UNDERFLOW;
-    } else {
-        ret = __bf_round(r, bf_min(r->expn, prec), flags, r->len);
-    }
-    return ret;
+    return bf_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
 }
 
 /* logical operations */
@@ -1980,12 +2353,13 @@ static inline limb_t bf_logic_op1(limb_t a, limb_t b, int op)
     }
 }
 
-static void bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
+static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
 {
     bf_t b1_s, a1_s, *a, *b;
     limb_t a_sign, b_sign, r_sign;
     slimb_t l, i, a_bit_offset, b_bit_offset;
     limb_t v1, v2, v1_mask, v2_mask, r_mask;
+    int ret;
     
     assert(r != a1 && r != b1);
 
@@ -2002,7 +2376,10 @@ static void bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     if (a_sign) {
         a = &a1_s;
         bf_init(r->ctx, a);
-        bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ);
+        if (bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ)) {
+            b = NULL;
+            goto fail;
+        }
     } else {
         a = (bf_t *)a1;
     }
@@ -2010,7 +2387,8 @@ static void bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     if (b_sign) {
         b = &b1_s;
         bf_init(r->ctx, b);
-        bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ);
+        if (bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ))
+            goto fail;
     } else {
         b = (bf_t *)b1;
     }
@@ -2029,7 +2407,8 @@ static void bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     }
     /* Note: a or b can be zero */
     l = (bf_max(l, 1) + LIMB_BITS - 1) / LIMB_BITS;
-    bf_resize(r, l);
+    if (bf_resize(r, l))
+        goto fail;
     a_bit_offset = a->len * LIMB_BITS - a->expn;
     b_bit_offset = b->len * LIMB_BITS - b->expn;
     v1_mask = -a_sign;
@@ -2042,31 +2421,40 @@ static void bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     }
     r->expn = l * LIMB_BITS;
     r->sign = r_sign;
-    bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ);
-    if (r_sign)
-        bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ);
+    bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ); /* cannot fail */
+    if (r_sign) {
+        if (bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ))
+            goto fail;
+    }
+    ret = 0;
+ done:
     if (a == &a1_s)
         bf_delete(a);
     if (b == &b1_s)
         bf_delete(b);
+    return ret;
+ fail:
+    bf_set_nan(r);
+    ret = BF_ST_MEM_ERROR;
+    goto done;
 }
 
-/* 'a' and 'b' must be integers */
-void bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b)
+/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
+int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b)
 {
-    bf_logic_op(r, a, b, BF_LOGIC_OR);
+    return bf_logic_op(r, a, b, BF_LOGIC_OR);
 }
 
-/* 'a' and 'b' must be integers */
-void bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b)
+/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
+int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b)
 {
-    bf_logic_op(r, a, b, BF_LOGIC_XOR);
+    return bf_logic_op(r, a, b, BF_LOGIC_XOR);
 }
 
-/* 'a' and 'b' must be integers */
-void bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b)
+/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
+int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b)
 {
-    bf_logic_op(r, a, b, BF_LOGIC_AND);
+    return bf_logic_op(r, a, b, BF_LOGIC_AND);
 }
 
 /* conversion between fixed size types */
@@ -2125,7 +2513,7 @@ int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode)
     return ret;
 }
 
-void bf_set_float64(bf_t *a, double d)
+int bf_set_float64(bf_t *a, double d)
 {
     Float64Union u;
     uint64_t m;
@@ -2157,15 +2545,21 @@ void bf_set_float64(bf_t *a, double d)
     norm:
         a->expn = e - 1023 + 1;
 #if LIMB_BITS == 32
-        bf_resize(a, 2);
+        if (bf_resize(a, 2))
+            goto fail;
         a->tab[0] = m;
         a->tab[1] = m >> 32;
 #else
-        bf_resize(a, 1);
+        if (bf_resize(a, 1))
+            goto fail;
         a->tab[0] = m;
 #endif
         a->sign = sgn;
     }
+    return 0;
+fail:
+    bf_set_nan(a);
+    return BF_ST_MEM_ERROR;
 }
 
 /* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
@@ -2180,6 +2574,7 @@ int bf_get_int32(int *pres, const bf_t *a, int flags)
             v = 0;
         } else if (a->expn == BF_EXP_INF) {
             v = (uint32_t)INT32_MAX + a->sign;
+            /* XXX: return overflow ? */
         } else {
             v = INT32_MAX;
         }
@@ -2251,7 +2646,7 @@ int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
             if (a->expn == 64) {
                 v1 = a->tab[a->len - 1];
 #if LIMB_BITS == 32
-                v1 |= (v1 << 32) | get_limbz(a, a->len - 2);
+                v1 = (v1 << 32) | get_limbz(a, a->len - 2);
 #endif
                 if (v1 == v)
                     ret = 0;
@@ -2295,12 +2690,14 @@ static limb_t get_limb_radix(int radix)
     return radixl;
 }
 
-static void bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
-                                      limb_t n, int level, limb_t n0,
-                                      limb_t radix, bf_t *pow_tab)
+/* return != 0 if error */
+static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
+                                     limb_t n, int level, limb_t n0,
+                                     limb_t radix, bf_t *pow_tab)
 {
+    int ret;
     if (n == 1) {
-        bf_set_ui(r, tab[0]);
+        ret = bf_set_ui(r, tab[0]);
     } else {
         bf_t T_s, *T = &T_s, *B;
         limb_t n1, n2;
@@ -2310,38 +2707,50 @@ static void bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
         //        printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
         B = &pow_tab[level];
         if (B->len == 0) {
-            bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
+            ret = bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
+            if (ret)
+                return ret;
         }
-        bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
-                                  radix, pow_tab);
-        bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
+        ret = bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
+                                        radix, pow_tab);
+        if (ret)
+            return ret;
+        ret = bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
+        if (ret)
+            return ret;
         bf_init(r->ctx, T);
-        bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
-                                  radix, pow_tab);
-        bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
+        ret = bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
+                                        radix, pow_tab);
+        if (!ret)
+            ret = bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
         bf_delete(T);
     }
+    return ret;
     //    bf_print_str("  r=", r);
 }
 
-static void bf_integer_from_radix(bf_t *r, const limb_t *tab,
+/* return 0 if OK != 0 if memory error */
+static int bf_integer_from_radix(bf_t *r, const limb_t *tab,
                                  limb_t n, limb_t radix)
 {
     bf_context_t *s = r->ctx;
-    int pow_tab_len, i;
+    int pow_tab_len, i, ret;
     limb_t radixl;
     bf_t *pow_tab;
     
     radixl = get_limb_radix(radix);
     pow_tab_len = ceil_log2(n) + 2; /* XXX: check */
     pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
+    if (!pow_tab)
+        return -1;
     for(i = 0; i < pow_tab_len; i++)
         bf_init(r->ctx, &pow_tab[i]);
-    bf_integer_from_radix_rec(r, tab, n, 0, n, radixl, pow_tab);
+    ret = bf_integer_from_radix_rec(r, tab, n, 0, n, radixl, pow_tab);
     for(i = 0; i < pow_tab_len; i++) {
         bf_delete(&pow_tab[i]);
     }
     bf_free(s, pow_tab);
+    return ret;
 }
 
 /* compute and round T * radix^expn. */
@@ -2353,11 +2762,11 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
     bf_t B_s, *B = &B_s;
 
     if (T->len == 0) {
-        bf_set(r, T);
-        return 0;
+        return bf_set(r, T);
     } else if (expn == 0) {
-        bf_set(r, T);
-        return bf_round(r, prec, flags);
+        ret = bf_set(r, T);
+        ret |= bf_round(r, prec, flags);
+        return ret;
     }
 
     e = expn;
@@ -2369,11 +2778,11 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
     bf_init(r->ctx, B);
     if (prec == BF_PREC_INF) {
         /* infinite precision: only used if the result is known to be exact */
-        bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
+        ret = bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
         if (expn_sign) {
-            ret = bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
+            ret |= bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
         } else {
-            ret = bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
+            ret |= bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
         }
     } else {
         ziv_extra_bits = 16;
@@ -2390,6 +2799,8 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
                 ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN);
             else
                 ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN);
+            if (ret & BF_ST_MEM_ERROR)
+                break;
             if ((ret & BF_ST_INEXACT) &&
                 !bf_can_round(r, prec, flags & BF_RND_MASK, prec1) &&
                 !overflow) {
@@ -2417,15 +2828,19 @@ static inline int to_digit(int c)
         return 36;
 }
 
-/* add a limb at 'pos' and decrement pos. new space is created if needed */
-static void bf_add_limb(bf_t *a, slimb_t *ppos, limb_t v)
+/* add a limb at 'pos' and decrement pos. new space is created if
+   needed. Return 0 if OK, -1 if memory error */
+static int bf_add_limb(bf_t *a, slimb_t *ppos, limb_t v)
 {
     slimb_t pos;
     pos = *ppos;
     if (unlikely(pos < 0)) {
-        limb_t new_size, d;
+        limb_t new_size, d, *new_tab;
         new_size = bf_max(a->len + 1, a->len * 3 / 2);
-        a->tab = bf_realloc(a->ctx, a->tab, sizeof(limb_t) * new_size);
+        new_tab = bf_realloc(a->ctx, a->tab, sizeof(limb_t) * new_size);
+        if (!new_tab)
+            return -1;
+        a->tab = new_tab;
         d = new_size - a->len;
         memmove(a->tab + d, a->tab, a->len * sizeof(limb_t));
         a->len = new_size;
@@ -2433,6 +2848,7 @@ static void bf_add_limb(bf_t *a, slimb_t *ppos, limb_t v)
     }
     a->tab[pos--] = v;
     *ppos = pos;
+    return 0;
 }
 
 static int bf_tolower(int c)
@@ -2458,35 +2874,20 @@ static int strcasestart(const char *str, const char *val, const char **ptr)
     return 1;
 }
 
-/* 
-   Return (status, n, exp). 'status' is the floating point status. 'n'
-   is the parsed number. 
-   If prec = BF_PREC_INF:
-      If the number is an integer or if the radix is a power of two,
-      *pexponent = 0. 
-      Otherwise, '*pexponent' is the exponent in radix 'radix'.
-   Otherwise
-      *pexponent = 0
-*/
-int bf_atof2(bf_t *r, slimb_t *pexponent,
-             const char *str, const char **pnext, int radix,
-             limb_t prec, bf_flags_t flags)
+static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
+                            const char *str, const char **pnext, int radix,
+                            limb_t prec, bf_flags_t flags, BOOL is_dec)
 {
     const char *p, *p_start;
-    int is_neg, radix_bits, exp_is_neg, ret, digits_per_limb, shift, sep;
-    int ret_legacy_octal = 0;
+    int is_neg, radix_bits, exp_is_neg, ret, digits_per_limb, shift;
     limb_t cur_limb;
     slimb_t pos, expn, int_len, digit_count;
-    BOOL has_decpt, is_bin_exp, is_float;
+    BOOL has_decpt, is_bin_exp;
     bf_t a_s, *a;
     
-    /* optional separator between digits */
-    sep = (flags & BF_ATOF_UNDERSCORE_SEP) ? '_' : 256;
-    
     *pexponent = 0;
     p = str;
-    if (!(flags & (BF_ATOF_INT_ONLY | BF_ATOF_JS_QUIRKS)) &&
-        radix <= 16 &&
+    if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
         strcasestart(p, "nan", &p)) {
         bf_set_nan(r);
         ret = 0;
@@ -2497,14 +2898,10 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     if (p[0] == '+') {
         p++;
         p_start = p;
-        if (flags & BF_ATOF_NO_PREFIX_AFTER_SIGN)
-            goto no_radix_prefix;
     } else if (p[0] == '-') {
         is_neg = 1;
         p++;
         p_start = p;
-        if (flags & BF_ATOF_NO_PREFIX_AFTER_SIGN)
-            goto no_radix_prefix;
     } else {
         p_start = p;
     }
@@ -2522,28 +2919,7 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
                    radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
             p += 2;
             radix = 2;
-        } else if ((p[1] >= '0' && p[1] <= '9') &&
-                   radix == 0 && (flags & BF_ATOF_LEGACY_OCTAL)) {
-            int i;
-            ret_legacy_octal = BF_ATOF_ST_LEGACY_OCTAL;
-            /* the separator is not allowed in legacy octal literals */
-            sep = 256;
-            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
-                continue;
-            if (p[i] == '8' || p[i] == '9')
-                goto no_prefix;
-            p += 1;
-            radix = 8;
         } else {
-            /* 0 cannot be followed by a separator */
-            if (p[1] == sep) {
-                p++;
-                bf_set_zero(r, 0);
-                ret = 0;
-                if (flags & BF_ATOF_INT_PREC_INF)
-                    ret |= BF_ATOF_ST_INTEGER;
-                goto done;
-            }
             goto no_prefix;
         }
         /* there must be a digit after the prefix */
@@ -2554,10 +2930,8 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
         }
     no_prefix: ;
     } else {
-    no_radix_prefix:
-        if (!(flags & BF_ATOF_INT_ONLY) && radix <= 16 &&
-            ((!(flags & BF_ATOF_JS_QUIRKS) && strcasestart(p, "inf", &p)) ||
-             ((flags & BF_ATOF_JS_QUIRKS) && strstart(p, "Infinity", &p)))) {
+        if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
+            strcasestart(p, "inf", &p)) {
             bf_set_inf(r, is_neg);
             ret = 0;
             goto done;
@@ -2566,7 +2940,11 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     
     if (radix == 0)
         radix = 10;
-    if ((radix & (radix - 1)) != 0) {
+    if (is_dec) {
+        assert(radix == 10);
+        radix_bits = 0;
+        a = r;
+    } else if ((radix & (radix - 1)) != 0) {
         radix_bits = 0; /* base is not a power of two */
         a = &a_s;
         bf_init(r->ctx, a);
@@ -2577,7 +2955,7 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
 
     /* skip leading zeros */
     /* XXX: could also skip zeros after the decimal point */
-    while (*p == '0' || (*p == sep && to_digit(p[1]) < radix))
+    while (*p == '0')
         p++;
 
     if (radix_bits) {
@@ -2591,22 +2969,15 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     pos = 0;
     has_decpt = FALSE;
     int_len = digit_count = 0;
-    is_float = FALSE;
     for(;;) {
         limb_t c;
         if (*p == '.' && (p > p_start || to_digit(p[1]) < radix)) {
-            if ((flags & BF_ATOF_INT_ONLY) ||
-                (radix != 10 && (flags & BF_ATOF_ONLY_DEC_FLOAT)))
-                break;
             if (has_decpt)
                 break;
-            is_float = TRUE;
             has_decpt = TRUE;
             int_len = digit_count;
             p++;
         }
-        if (*p == sep && to_digit(p[1]) < radix)
-            p++;
         c = to_digit(*p);
         if (c >= radix)
             break;
@@ -2616,7 +2987,8 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
             shift -= radix_bits;
             if (shift <= 0) {
                 cur_limb |= c >> (-shift);
-                bf_add_limb(a, &pos, cur_limb);
+                if (bf_add_limb(a, &pos, cur_limb))
+                    goto mem_error;
                 if (shift < 0)
                     cur_limb = c << (LIMB_BITS + shift);
                 else
@@ -2629,7 +3001,8 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
             cur_limb = cur_limb * radix + c;
             shift--;
             if (shift == 0) {
-                bf_add_limb(a, &pos, cur_limb);
+                if (bf_add_limb(a, &pos, cur_limb))
+                    goto mem_error;
                 shift = digits_per_limb;
                 cur_limb = 0;
             }
@@ -2646,7 +3019,14 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
                 shift--;
             }
         }
-        bf_add_limb(a, &pos, cur_limb);
+        if (bf_add_limb(a, &pos, cur_limb)) {
+        mem_error:
+            ret = BF_ST_MEM_ERROR;
+            if (!radix_bits)
+                bf_delete(a);
+            bf_set_nan(r);
+            goto done;
+        }
     }
             
     /* reset the next limbs to zero (we prefer to reallocate in the
@@ -2654,9 +3034,9 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     memset(a->tab, 0, (pos + 1) * sizeof(limb_t));
 
     if (p == p_start) {
+        ret = 0;
         if (!radix_bits)
             bf_delete(a);
-        ret = 0;
         bf_set_nan(r);
         goto done;
     }
@@ -2664,15 +3044,12 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
     /* parse the exponent, if any */
     expn = 0;
     is_bin_exp = FALSE;
-    if (!(flags & BF_ATOF_INT_ONLY) && 
-        !(radix != 10 && (flags & BF_ATOF_ONLY_DEC_FLOAT)) &&
-        ((radix == 10 && (*p == 'e' || *p == 'E')) ||
+    if (((radix == 10 && (*p == 'e' || *p == 'E')) ||
          (radix != 10 && (*p == '@' ||
                           (radix_bits && (*p == 'p' || *p == 'P'))))) &&
         p > p_start) {
         is_bin_exp = (*p == 'p' || *p == 'P');
         p++;
-        is_float = TRUE;
         exp_is_neg = 0;
         if (*p == '+') {
             p++;
@@ -2682,8 +3059,6 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
         }
         for(;;) {
             int c;
-            if (*p == sep && to_digit(p[1]) < 10)
-                p++;
             c = to_digit(*p);
             if (c >= 10)
                 break;
@@ -2703,17 +3078,12 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
         }
         if (exp_is_neg)
             expn = -expn;
-    } else if (!is_float) {
-        if (*p == 'n' && (flags & BF_ATOF_INT_N_SUFFIX)) {
-            p++;
-            prec = BF_PREC_INF;
-        } else if (flags & BF_ATOF_INT_PREC_INF) {
-            prec = BF_PREC_INF;
-        } else {
-            is_float = TRUE;
-        }
     }
-    if (radix_bits) {
+    if (is_dec) {
+        a->expn = expn + int_len;
+        a->sign = is_neg;
+        ret = bfdec_normalize_and_round((bfdec_t *)a, prec, flags);
+    } else if (radix_bits) {
         /* XXX: may overflow */
         if (!is_bin_exp)
             expn *= radix_bits; 
@@ -2732,33 +3102,50 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
 
             expn -= l * digits_per_limb - int_len;
             bf_init(r->ctx, T);
-            bf_integer_from_radix(T, a->tab + pos, l, radix);
-            T->sign = is_neg;
-            if (prec == BF_PREC_INF && is_float) {
-                /* return the exponent */
-                *pexponent = expn;
-                bf_set(r, T);
-                ret = 0;
+            if (bf_integer_from_radix(T, a->tab + pos, l, radix)) {
+                bf_set_nan(r);
+                ret = BF_ST_MEM_ERROR;
             } else {
-                ret = bf_mul_pow_radix(r, T, radix, expn, prec, flags);
+                T->sign = is_neg;
+                if (flags & BF_ATOF_EXPONENT) {
+                    /* return the exponent */
+                    *pexponent = expn;
+                    ret = bf_set(r, T);
+                } else {
+                    ret = bf_mul_pow_radix(r, T, radix, expn, prec, flags);
+                }
             }
             bf_delete(T);
         }
         bf_delete(a);
     }
-    if (!is_float)
-        ret |= BF_ATOF_ST_INTEGER;
  done:
     if (pnext)
         *pnext = p;
-    return ret | ret_legacy_octal;
+    return ret;
+}
+
+/* 
+   Return (status, n, exp). 'status' is the floating point status. 'n'
+   is the parsed number. 
+
+   If (flags & BF_ATOF_EXPONENT) and if the radix is not a power of
+   two, the parsed number is equal to r *
+   (*pexponent)^radix. Otherwise *pexponent = 0.
+*/
+int bf_atof2(bf_t *r, slimb_t *pexponent,
+             const char *str, const char **pnext, int radix,
+             limb_t prec, bf_flags_t flags)
+{
+    return bf_atof_internal(r, pexponent, str, pnext, radix, prec, flags,
+                            FALSE);
 }
 
 int bf_atof(bf_t *r, const char *str, const char **pnext, int radix,
             limb_t prec, bf_flags_t flags)
 {
     slimb_t dummy_exp;
-    return bf_atof2(r, &dummy_exp, str, pnext, radix, prec, flags);
+    return bf_atof_internal(r, &dummy_exp, str, pnext, radix, prec, flags, FALSE);
 }
 
 /* base conversion to radix */
@@ -2769,7 +3156,7 @@ int bf_atof(bf_t *r, const char *str, const char **pnext, int radix,
 #define RADIXL_10 UINT64_C(1000000000)
 #endif
 
-static const uint32_t inv_log2_radix[BF_RADIX_MAX - 1][LIMB_BITS / 2 + 1] = {
+static const uint32_t inv_log2_radix[BF_RADIX_MAX - 1][LIMB_BITS / 32 + 1] = {
 #if LIMB_BITS == 32
 { 0x80000000, 0x00000000,},
 { 0x50c24e60, 0xd4d4f4a7,},
@@ -3019,12 +3406,13 @@ static void bf_integer_to_radix_rec(bf_t *pow_tab,
             bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
             /* we use enough bits for the maximum possible 'n1' value,
                i.e. n2 + 1 */
-            bf_recip(B_inv, B, (n2 + 1) * radixl_bits + 2);
+            bf_set_ui(&R, 1);
+            bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
         }
         //        printf("%d: n1=% " PRId64 " n2=%" PRId64 "\n", level, n1, n2);
         q_prec = n1 * radixl_bits;
         bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
-        bf_rint(&Q, BF_PREC_INF, BF_RNDZ);
+        bf_rint(&Q, BF_RNDZ);
         
         bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
         bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
@@ -3074,11 +3462,11 @@ static void bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
 
 /* a must be >= 0. 'P' is the wanted number of digits in radix
    'radix'. 'r' is the mantissa represented as an integer. *pE
-   contains the exponent. */
-static void bf_convert_to_radix(bf_t *r, slimb_t *pE,
-                                const bf_t *a, int radix,
-                                limb_t P, bf_rnd_t rnd_mode,
-                                BOOL is_fixed_exponent)
+   contains the exponent. Return != 0 if memory error. */
+static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
+                               const bf_t *a, int radix,
+                               limb_t P, bf_rnd_t rnd_mode,
+                               BOOL is_fixed_exponent)
 {
     slimb_t E, e, prec, extra_bits, ziv_extra_bits, prec0;
     bf_t B_s, *B = &B_s;
@@ -3087,8 +3475,7 @@ static void bf_convert_to_radix(bf_t *r, slimb_t *pE,
     if (a->len == 0) {
         /* zero case */
         *pE = 0;
-        bf_set(r, a);
-        return;
+        return bf_set(r, a);
     }
 
     if (is_fixed_exponent) {
@@ -3119,6 +3506,8 @@ static void bf_convert_to_radix(bf_t *r, slimb_t *pE,
                 ret |= bf_mul(r, r, a, prec + extra_bits, BF_RNDN);
             else
                 ret |= bf_div(r, a, r, prec + extra_bits, BF_RNDN);
+            if (ret & BF_ST_MEM_ERROR)
+                return BF_ST_MEM_ERROR;
             /* if the result is not exact, check that it can be safely
                rounded to an integer */
             if ((ret & BF_ST_INEXACT) &&
@@ -3127,16 +3516,22 @@ static void bf_convert_to_radix(bf_t *r, slimb_t *pE,
                 ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
                 continue;
             } else {
-                bf_rint(r, BF_PREC_INF, rnd_mode);
+                ret = bf_rint(r, rnd_mode);
+                if (ret & BF_ST_MEM_ERROR)
+                    return BF_ST_MEM_ERROR;
                 break;
             }
         }
         if (is_fixed_exponent)
             break;
         /* check that the result is < B^P */
-        /* XXX: do an fast approximate test first ? */
+        /* XXX: do a fast approximate test first ? */
         bf_init(r->ctx, B);
-        bf_pow_ui_ui(B, radix, P, BF_PREC_INF, BF_RNDZ);
+        ret = bf_pow_ui_ui(B, radix, P, BF_PREC_INF, BF_RNDZ);
+        if (ret) {
+            bf_delete(B);
+            return ret;
+        }
         res = bf_cmpu(r, B);
         bf_delete(B);
         if (res < 0)
@@ -3145,6 +3540,7 @@ static void bf_convert_to_radix(bf_t *r, slimb_t *pE,
         E++;
     }
     *pE = E;
+    return 0;
 }
 
 static void limb_to_a(char *buf, limb_t n, unsigned int radix, int len)
@@ -3189,19 +3585,27 @@ static void limb_to_a2(char *buf, limb_t n, unsigned int radix_bits, int len)
     }
 }
 
-/* 'a' must be an integer. A dot is added before the 'dot_pos'
-   digit. dot_pos = n_digits does not display the dot. 0 <= dot_pos <=
+/* 'a' must be an integer if the is_dec = FALSE or if the radix is not
+   a power of two. A dot is added before the 'dot_pos' digit. dot_pos
+   = n_digits does not display the dot. 0 <= dot_pos <=
    n_digits. n_digits >= 1. */
 static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
-                          limb_t dot_pos)
+                          limb_t dot_pos, BOOL is_dec)
 {
     limb_t i, v, l;
     slimb_t pos, pos_incr;
     int digits_per_limb, buf_pos, radix_bits, first_buf_pos;
     char buf[65];
     bf_t a_s, *a;
-    
-    if ((radix & (radix - 1)) != 0) {
+
+    if (is_dec) {
+        digits_per_limb = LIMB_DIGITS;
+        a = (bf_t *)a1;
+        radix_bits = 0;
+        pos = a->len;
+        pos_incr = 1;
+        first_buf_pos = 0;
+    } else if ((radix & (radix - 1)) != 0) {
         limb_t n, radixl;
 
         digits_per_limb = digits_per_limb_table[radix - 2];
@@ -3261,8 +3665,8 @@ static void *bf_dbuf_realloc(void *opaque, void *ptr, size_t size)
 }
 
 /* return the length in bytes. A trailing '\0' is added */
-size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
-               bf_flags_t flags)
+static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
+                              limb_t prec, bf_flags_t flags, BOOL is_dec)
 {
     DynBuf s_s, *s = &s_s;
     int radix_bits;
@@ -3281,7 +3685,7 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
             else
                 dbuf_putstr(s, "Inf");
         } else {
-            int fmt;
+            int fmt, ret;
             slimb_t n_digits, n, i, n_max, n1;
             bf_t a1_s, *a1;
             bf_t a_s, *a = &a_s;
@@ -3302,14 +3706,16 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
             bf_init(a2->ctx, a1);
             if (fmt == BF_FTOA_FORMAT_FRAC) {
                 size_t pos, start;
+                assert(!is_dec);
                 /* one more digit for the rounding */
                 n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
                 n_digits = n + prec;
                 n1 = n;
-                bf_convert_to_radix(a1, &n1, a, radix, n_digits,
-                                    flags & BF_RND_MASK, TRUE);
+                if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
+                                        flags & BF_RND_MASK, TRUE))
+                    goto fail1;
                 start = s->size;
-                output_digits(s, a1, radix, n_digits, n);
+                output_digits(s, a1, radix, n_digits, n, is_dec);
                 /* remove leading zeros because we allocated one more digit */
                 pos = start;
                 while ((pos + 1) < s->size && s->buf[pos] == '0' &&
@@ -3320,51 +3726,85 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
                     s->size -= (pos - start);
                 }
             } else {
-                if (fmt == BF_FTOA_FORMAT_FIXED) {
-                    n_digits = prec;
-                    n_max = n_digits;
-                } else {
-                    slimb_t n_digits_max, n_digits_min;
-                    
-                    if (prec == BF_PREC_INF) {
-                        assert(radix_bits != 0);
-                        /* XXX: could use the exact number of bits */
-                        prec = a->len * LIMB_BITS;
+#ifdef USE_BF_DEC
+                if (is_dec) {
+                    if (fmt == BF_FTOA_FORMAT_FIXED) {
+                        n_digits = prec;
+                        n_max = n_digits;
+                    } else {
+                        /* prec is ignored */
+                        prec = n_digits = a->len * LIMB_DIGITS;
+                        /* remove trailing zero digits */
+                        while (n_digits > 1 &&
+                               get_digit(a->tab, a->len, prec - n_digits) == 0) {
+                            n_digits--;
+                        }
+                        n_max = n_digits + 4;
                     }
-                    n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
-                    /* max number of digits for non exponential
-                       notation. The rational is to have the same rule
-                       as JS i.e. n_max = 21 for 64 bit float in base 10. */
-                    n_max = n_digits + 4;
-                    if (fmt == BF_FTOA_FORMAT_FREE_MIN) {
-                        bf_t b_s, *b = &b_s;
+                    bf_init(a2->ctx, a1);
+                    bf_set(a1, a);
+                    n = a1->expn;
+                } else
+#endif
+                {
+                    if (fmt == BF_FTOA_FORMAT_FIXED) {
+                        n_digits = prec;
+                        n_max = n_digits;
+                    } else {
+                        slimb_t n_digits_max, n_digits_min;
                         
-                        /* find the minimum number of digits by
-                           dichotomy. */
-                        n_digits_max = n_digits;
-                        n_digits_min = 1;
-                        bf_init(a2->ctx, b);
-                        while (n_digits_min < n_digits_max) {
-                            n_digits = (n_digits_min + n_digits_max) / 2;
-                            bf_convert_to_radix(a1, &n, a, radix, n_digits,
-                                                flags & BF_RND_MASK, FALSE);
-                            /* convert back to a number and compare */
-                            bf_mul_pow_radix(b, a1, radix, n - n_digits,
-                                             prec,
-                                             (flags & ~BF_RND_MASK) |
-                                             BF_RNDN);
-                            if (bf_cmpu(b, a) == 0) {
-                                n_digits_max = n_digits;
-                            } else {
-                                n_digits_min = n_digits + 1;
+                        if (prec == BF_PREC_INF) {
+                            assert(radix_bits != 0);
+                            /* XXX: could use the exact number of bits */
+                            prec = a->len * LIMB_BITS;
+                        }
+                        n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
+                        /* max number of digits for non exponential
+                           notation. The rational is to have the same rule
+                           as JS i.e. n_max = 21 for 64 bit float in base 10. */
+                        n_max = n_digits + 4;
+                        if (fmt == BF_FTOA_FORMAT_FREE_MIN) {
+                            bf_t b_s, *b = &b_s;
+                            
+                            /* find the minimum number of digits by
+                               dichotomy. */
+                            /* XXX: inefficient */
+                            n_digits_max = n_digits;
+                            n_digits_min = 1;
+                            bf_init(a2->ctx, b);
+                            while (n_digits_min < n_digits_max) {
+                                n_digits = (n_digits_min + n_digits_max) / 2;
+                                if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
+                                                        flags & BF_RND_MASK, FALSE)) {
+                                    bf_delete(b);
+                                    goto fail1;
+                                }
+                                /* convert back to a number and compare */
+                                ret = bf_mul_pow_radix(b, a1, radix, n - n_digits,
+                                                       prec,
+                                                       (flags & ~BF_RND_MASK) |
+                                                       BF_RNDN);
+                                if (ret & BF_ST_MEM_ERROR) {
+                                    bf_delete(b);
+                                    goto fail1;
+                                }
+                                if (bf_cmpu(b, a) == 0) {
+                                    n_digits_max = n_digits;
+                                } else {
+                                    n_digits_min = n_digits + 1;
+                                }
                             }
+                            bf_delete(b);
+                            n_digits = n_digits_max;
                         }
-                        bf_delete(b);
-                        n_digits = n_digits_max;
+                    }
+                    if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
+                                            flags & BF_RND_MASK, FALSE)) {
+                    fail1:
+                        bf_delete(a1);
+                        goto fail;
                     }
                 }
-                bf_convert_to_radix(a1, &n, a, radix, n_digits,
-                                    flags & BF_RND_MASK, FALSE);
                 if (a1->expn == BF_EXP_ZERO &&
                     fmt != BF_FTOA_FORMAT_FIXED &&
                     !(flags & BF_FTOA_FORCE_EXP)) {
@@ -3385,7 +3825,7 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
                         n <= -6 || n > n_max) {
                         const char *fmt;
                         /* exponential notation */
-                        output_digits(s, a1, radix, n_digits, 1);
+                        output_digits(s, a1, radix, n_digits, 1, is_dec);
                         if (radix_bits != 0 && radix <= 16) {
                             if (flags & BF_FTOA_JS_QUIRKS)
                                 fmt = "p%+" PRId_LIMB;
@@ -3406,15 +3846,15 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
                         for(i = 0; i < -n; i++) {
                             dbuf_putc(s, '0');
                         }
-                        output_digits(s, a1, radix, n_digits, n_digits);
+                        output_digits(s, a1, radix, n_digits, n_digits, is_dec);
                     } else {
                         if (n_digits <= n) {
                             /* no dot */
-                            output_digits(s, a1, radix, n_digits, n_digits);
+                            output_digits(s, a1, radix, n_digits, n_digits, is_dec);
                             for(i = 0; i < (n - n_digits); i++)
                                 dbuf_putc(s, '0');
                         } else {
-                            output_digits(s, a1, radix, n_digits, n);
+                            output_digits(s, a1, radix, n_digits, n, is_dec);
                         }
                     }
                 }
@@ -3423,8 +3863,22 @@ size_t bf_ftoa(char **pbuf, const bf_t *a2, int radix, limb_t prec,
         }
     }
     dbuf_putc(s, '\0');
-    *pbuf = (char *)s->buf;
-    return s->size - 1;
+    if (dbuf_error(s))
+        goto fail;
+    if (plen)
+        *plen = s->size - 1;
+    return (char *)s->buf;
+ fail:
+    bf_free(a2->ctx, s->buf);
+    if (plen)
+        *plen = 0;
+    return NULL;
+}
+
+char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
+              bf_flags_t flags)
+{
+    return bf_ftoa_internal(plen, a, radix, prec, flags, FALSE);
 }
 
 /***************************************************************/
@@ -3571,9 +4025,9 @@ static void bf_const_pi_internal(bf_t *Q, limb_t prec)
     bf_add(&P, &G, &P, prec1, BF_RNDN);
     bf_div(Q, Q, &P, prec1, BF_RNDF);
  
-    bf_set_ui(&P, CHUD_C / 64);
-    bf_rsqrt(&G, &P, prec1);
-    bf_mul_ui(&G, &G, (uint64_t)CHUD_C * CHUD_C / (8 * 12), prec1, BF_RNDF);
+    bf_set_ui(&P, CHUD_C);
+    bf_sqrt(&G, &P, prec1, BF_RNDF);
+    bf_mul_ui(&G, &G, (uint64_t)CHUD_C / 12, prec1, BF_RNDF);
     bf_mul(Q, Q, &G, prec, BF_RNDN);
     bf_delete(&P);
     bf_delete(&G);
@@ -3656,10 +4110,10 @@ static int bf_ziv_rounding(bf_t *r, const bf_t *a,
         for(;;) {
             prec1 = prec + ziv_extra_bits;
             ret = f(r, a, prec1, opaque);
-            if (ret & (BF_ST_OVERFLOW | BF_ST_UNDERFLOW)) {
-                /* should never happen because it indicates the
-                   rounding cannot be done correctly, but we do not
-                   catch all the cases */
+            if (ret & (BF_ST_OVERFLOW | BF_ST_UNDERFLOW | BF_ST_MEM_ERROR)) {
+                /* overflow or underflow should never happen because
+                   it indicates the rounding cannot be done correctly,
+                   but we do not catch all the cases */
                 return ret;
             }
             /* if the result is exact, we can stop */
@@ -4610,110 +5064,1979 @@ int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
     return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
 }
 
-#ifdef USE_FFT_MUL
 /***************************************************************/
-/* Integer multiplication with FFT */
-
-/* or LIMB_BITS at bit position 'pos' in tab */
-static inline void put_bits(limb_t *tab, limb_t len, slimb_t pos, limb_t val)
-{
-    limb_t i;
-    int p;
-
-    i = pos >> LIMB_LOG2_BITS;
-    p = pos & (LIMB_BITS - 1);
-    if (i < len)
-        tab[i] |= val << p;
-    if (p != 0) {
-        i++;
-        if (i < len) {
-            tab[i] |= val >> (LIMB_BITS - p);
-        }
-    }
-}
+/* decimal floating point numbers */
 
-#if defined(__AVX2__)
-
-typedef double NTTLimb;
+#ifdef USE_BF_DEC
 
-/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
-#define NTT_MOD_LOG2_MIN 50
-#define NTT_MOD_LOG2_MAX 51
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 39
-static const int ntt_int_bits[NB_MODS] = { 254, 203, 152, 101, 50, };
+#define adddq(r1, r0, a1, a0)                   \
+    do {                                        \
+        limb_t __t = r0;                        \
+        r0 += (a0);                             \
+        r1 += (a1) + (r0 < __t);                \
+    } while (0)
 
-static const limb_t ntt_mods[NB_MODS] = { 0x00073a8000000001, 0x0007858000000001, 0x0007a38000000001, 0x0007a68000000001, 0x0007fd8000000001,
-};
+#define subdq(r1, r0, a1, a0)                   \
+    do {                                        \
+        limb_t __t = r0;                        \
+        r0 -= (a0);                             \
+        r1 -= (a1) + (r0 > __t);                \
+    } while (0)
 
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x00056198d44332c8, 0x0002eb5d640aad39, 0x00047e31eaa35fd0, 0x0005271ac118a150, 0x00075e0ce8442bd5, },
-    { 0x000461169761bcc5, 0x0002dac3cb2da688, 0x0004abc97751e3bf, 0x000656778fc8c485, 0x0000dc6469c269fa, },
-};
+#if LIMB_BITS == 64
 
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x00020e4da740da8e, 0x0004c3dc09c09c1d, 0x000063bd097b4271, 0x000799d8f18f18fd,
- 0x0005384222222264, 0x000572b07c1f07fe, 0x00035cd08888889a,
- 0x00066015555557e3, 0x000725960b60b623,
- 0x0002fc1fa1d6ce12,
-};
+/* Note: we assume __int128 is available */
+#define muldq(r1, r0, a, b)                     \
+    do {                                        \
+        unsigned __int128 __t;                          \
+        __t = (unsigned __int128)(a) * (unsigned __int128)(b);  \
+        r0 = __t;                               \
+        r1 = __t >> 64;                         \
+    } while (0)
+
+#define divdq(q, r, a1, a0, b)                  \
+    do {                                        \
+        unsigned __int128 __t;                  \
+        limb_t __b = (b);                       \
+        __t = ((unsigned __int128)(a1) << 64) | (a0);   \
+        q = __t / __b;                                  \
+        r = __t % __b;                                  \
+    } while (0)
 
 #else
 
-typedef limb_t NTTLimb;
-
-#if LIMB_BITS == 64
+#define muldq(r1, r0, a, b)                     \
+    do {                                        \
+        uint64_t __t;                          \
+        __t = (uint64_t)(a) * (uint64_t)(b);  \
+        r0 = __t;                               \
+        r1 = __t >> 32;                         \
+    } while (0)
 
-#define NTT_MOD_LOG2_MIN 61
-#define NTT_MOD_LOG2_MAX 62
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 51
-static const int ntt_int_bits[NB_MODS] = { 307, 246, 185, 123, 61, };
+#define divdq(q, r, a1, a0, b)                  \
+    do {                                        \
+        uint64_t __t;                  \
+        limb_t __b = (b);                       \
+        __t = ((uint64_t)(a1) << 32) | (a0);   \
+        q = __t / __b;                                  \
+        r = __t % __b;                                  \
+    } while (0)
 
-static const limb_t ntt_mods[NB_MODS] = { 0x28d8000000000001, 0x2a88000000000001, 0x2ed8000000000001, 0x3508000000000001, 0x3aa8000000000001,
-};
+#endif /* LIMB_BITS != 64 */
 
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x1b8ea61034a2bea7, 0x21a9762de58206fb, 0x02ca782f0756a8ea, 0x278384537a3e50a1, 0x106e13fee74ce0ab, },
-    { 0x233513af133e13b8, 0x1d13140d1c6f75f1, 0x12cde57f97e3eeda, 0x0d6149e23cbe654f, 0x36cd204f522a1379, },
-};
+static inline limb_t shrd(limb_t low, limb_t high, long shift)
+{
+    if (shift != 0)
+        low = (low >> shift) | (high << (LIMB_BITS - shift));
+    return low;
+}
 
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x08a9ed097b425eea, 0x18a44aaaaaaaaab3, 0x2493f57f57f57f5d, 0x126b8d0649a7f8d4,
- 0x09d80ed7303b5ccc, 0x25b8bcf3cf3cf3d5, 0x2ce6ce63398ce638,
- 0x0e31fad40a57eb59, 0x02a3529fd4a7f52f,
- 0x3a5493e93e93e94a,
-};
+static inline limb_t shld(limb_t a1, limb_t a0, long shift)
+{
+    if (shift != 0)
+        return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
+    else
+        return a1;
+}
+
+#if LIMB_DIGITS == 19
+
+/* WARNING: hardcoded for b = 1e19. It is assumed that:
+   0 <= a1 < 2^63 */
+#define divdq_base(q, r, a1, a0)\
+do {\
+    uint64_t __a0, __a1, __t0, __t1, __b = BF_DEC_BASE; \
+    __a0 = a0;\
+    __a1 = a1;\
+    __t0 = __a1;\
+    __t0 = shld(__t0, __a0, 1);\
+    muldq(q, __t1, __t0, UINT64_C(17014118346046923173)); \
+    muldq(__t1, __t0, q, __b);\
+    subdq(__a1, __a0, __t1, __t0);\
+    subdq(__a1, __a0, 1, __b * 2);    \
+    __t0 = (slimb_t)__a1 >> 1; \
+    q += 2 + __t0;\
+    adddq(__a1, __a0, 0, __b & __t0);\
+    q += __a1;                  \
+    __a0 += __b & __a1;           \
+    r = __a0;\
+} while(0)
+
+#elif LIMB_DIGITS == 9
+
+/* WARNING: hardcoded for b = 1e9. It is assumed that:
+   0 <= a1 < 2^29 */
+#define divdq_base(q, r, a1, a0)\
+do {\
+    uint32_t __t0, __t1, __b = BF_DEC_BASE; \
+    __t0 = a1;\
+    __t1 = a0;\
+    __t0 = (__t0 << 3) | (__t1 >> (32 - 3));    \
+    muldq(q, __t1, __t0, 2305843009U);\
+    r = a0 - q * __b;\
+    __t1 = (r >= __b);\
+    q += __t1;\
+    if (__t1)\
+        r -= __b;\
+} while(0)
 
-#elif LIMB_BITS == 32
+#endif
 
-/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
-#define NTT_MOD_LOG2_MIN 29
-#define NTT_MOD_LOG2_MAX 30
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 20
-static const int ntt_int_bits[NB_MODS] = { 148, 119, 89, 59, 29, };
+/* fast integer division by a fixed constant */
 
-static const limb_t ntt_mods[NB_MODS] = { 0x0000000032b00001, 0x0000000033700001, 0x0000000036d00001, 0x0000000037300001, 0x000000003e500001,
-};
+typedef struct FastDivData {
+    limb_t d; /* divisor (only user visible field) */
+    limb_t m1; /* multiplier */
+    int shift1;
+    int shift2;
+} FastDivData;
 
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x0000000032525f31, 0x0000000005eb3b37, 0x00000000246eda9f, 0x0000000035f25901, 0x00000000022f5768, },
-    { 0x00000000051eba1a, 0x00000000107be10e, 0x000000001cd574e0, 0x00000000053806e6, 0x000000002cd6bf98, },
-};
+#if 1
+/* From "Division by Invariant Integers using Multiplication" by
+   Torborn Granlund and Peter L. Montgomery */
+/* d must be != 0 */
+static inline void fast_udiv_init(FastDivData *s, limb_t d)
+{
+    int l;
+    limb_t q, r, m1;
+    s->d = d;
+    if (d == 1)
+        l = 0;
+    else
+        l = 64 - clz64(d - 1);
+    divdq(q, r, ((limb_t)1 << l) - d, 0, d);
+    (void)r;
+    m1 = q + 1;
+    //    printf("d=%lu l=%d m1=0x%016lx\n", d, l, m1);
+    s->m1 = m1;
+    s->shift1 = l;
+    if (s->shift1 > 1)
+        s->shift1 = 1;
+    s->shift2 = l - 1;
+    if (s->shift2 < 0)
+        s->shift2 = 0;
+}
 
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x000000000449559a, 0x000000001eba6ca9, 0x000000002ec18e46, 0x000000000860160b,
- 0x000000000d321307, 0x000000000bf51120, 0x000000000f662938,
- 0x000000000932ab3e, 0x000000002f40eef8,
- 0x000000002e760905,
-};
+static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
+{
+    limb_t t0, t1;
+    muldq(t1, t0, s->m1, a);
+    t0 = (a - t1) >> s->shift1;
+    return (t1 + t0) >> s->shift2;
+}
 
-#endif /* LIMB_BITS */
+static inline limb_t fast_urem(limb_t a, const FastDivData *s)
+{
+    limb_t q;
+    q = fast_udiv(a, s);
+    return a - q * s->d;
+}
 
-#endif /* !AVX2 */
+#define fast_udivrem(q, r, a, s) q = fast_udiv(a, s), r = a - q * (s)->d
+    
+#else
 
-#if defined(__AVX2__)
+static inline void fast_udiv_init(FastDivData *s, limb_t d)
+{
+    s->d = d;
+}
+static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
+{
+    return a / s->d;
+}
+static inline limb_t fast_urem(limb_t a, const FastDivData *s)
+{
+    return a % s->d;
+}
+
+#define fast_udivrem(q, r, a, s) q = a / (s)->d, r = a % (s)->d
+
+#endif
+
+/* contains 10^i */
+/* XXX: make it const */
+limb_t mp_pow_dec[LIMB_DIGITS + 1];
+static FastDivData mp_pow_div[LIMB_DIGITS + 1];
+
+static void mp_pow_init(void)
+{
+    limb_t a;
+    int i;
+    
+    a = 1;
+    for(i = 0; i <= LIMB_DIGITS; i++) {
+        mp_pow_dec[i] = a;
+        fast_udiv_init(&mp_pow_div[i], a);
+        a = a * 10;
+    }
+}
+
+limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
+                  mp_size_t n, limb_t carry)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t k, a, v;
+
+    k=carry;
+    for(i=0;i<n;i++) {
+        /* XXX: reuse the trick in add_mod */
+        v = op1[i];
+        a = v + op2[i] + k - base;
+        k = a <= v;
+        if (!k) 
+            a += base;
+        res[i]=a;
+    }
+    return k;
+}
+
+limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t k, a, v;
+
+    k=b;
+    for(i=0;i<n;i++) {
+        v = tab[i];
+        a = v + k - base;
+        k = a <= v;
+        if (!k) 
+            a += base;
+        tab[i] = a;
+        if (k == 0)
+            break;
+    }
+    return k;
+}
+
+limb_t mp_sub_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
+                  mp_size_t n, limb_t carry)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t k, v, a;
+
+    k=carry;
+    for(i=0;i<n;i++) {
+        v = op1[i];
+        a = v - op2[i] - k;
+        k = a > v;
+        if (k)
+            a += base;
+        res[i] = a;
+    }
+    return k;
+}
+
+limb_t mp_sub_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t k, v, a;
+    
+    k=b;
+    for(i=0;i<n;i++) {
+        v = tab[i];
+        a = v - k;
+        k = a > v;
+        if (k)
+            a += base;
+        tab[i]=a;
+        if (k == 0)
+            break;
+    }
+    return k;
+}
+
+/* taba[] = taba[] * b + l. 0 <= b, l <= base - 1. Return the high carry */
+limb_t mp_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n, 
+                   limb_t b, limb_t l)
+{
+    mp_size_t i;
+    limb_t t0, t1, r;
+
+    for(i = 0; i < n; i++) {
+        muldq(t1, t0, taba[i], b);
+        adddq(t1, t0, 0, l);
+        divdq_base(l, r, t1, t0);
+        tabr[i] = r;
+    }
+    return l;
+}
+
+/* tabr[] += taba[] * b. 0 <= b <= base - 1. Return the value to add
+   to the high word */
+limb_t mp_add_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
+                       limb_t b)
+{
+    mp_size_t i;
+    limb_t l, t0, t1, r;
+
+    l = 0;
+    for(i = 0; i < n; i++) {
+        muldq(t1, t0, taba[i], b);
+        adddq(t1, t0, 0, l);
+        adddq(t1, t0, 0, tabr[i]);
+        divdq_base(l, r, t1, t0);
+        tabr[i] = r;
+    }
+    return l;
+}
+
+/* tabr[] -= taba[] * b. 0 <= b <= base - 1. Return the value to
+   substract to the high word. */
+limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
+                       limb_t b)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t l, t0, t1, r, a, v, c;
+
+    /* XXX: optimize */
+    l = 0;
+    for(i = 0; i < n; i++) {
+        muldq(t1, t0, taba[i], b);
+        adddq(t1, t0, 0, l);
+        divdq_base(l, r, t1, t0);
+        v = tabr[i];
+        a = v - r;
+        c = a > v;
+        if (c)
+            a += base;
+        /* never bigger than base because r = 0 when l = base - 1 */
+        l += c;
+        tabr[i] = a;
+    }
+    return l;
+}
+
+/* size of the result : op1_size + op2_size. */
+void mp_mul_basecase_dec(limb_t *result, 
+                         const limb_t *op1, mp_size_t op1_size, 
+                         const limb_t *op2, mp_size_t op2_size) 
+{
+    mp_size_t i;
+    limb_t r;
+    
+    result[op1_size] = mp_mul1_dec(result, op1, op1_size, op2[0], 0);
+
+    for(i=1;i<op2_size;i++) {
+        r = mp_add_mul1_dec(result + i, op1, op1_size, op2[i]);
+        result[i + op1_size] = r;
+    }
+}
+
+/* taba[] = (taba[] + r*base^na) / b. 0 <= b < base. 0 <= r <
+   b. Return the remainder. */
+limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na, 
+                   limb_t b, limb_t r)
+{
+    limb_t base = BF_DEC_BASE;
+    mp_size_t i;
+    limb_t t0, t1, q;
+    int shift;
+
+#if (BF_DEC_BASE % 2) == 0
+    if (b == 2) {
+        limb_t base_div2;
+        /* Note: only works if base is even */
+        base_div2 = base >> 1;
+        if (r)
+            r = base_div2;
+        for(i = na - 1; i >= 0; i--) {
+            t0 = taba[i];
+            tabr[i] = (t0 >> 1) + r;
+            r = 0;
+            if (t0 & 1)
+                r = base_div2;
+        }
+        if (r)
+            r = 1;
+    } else 
+#endif
+    if (na >= UDIV1NORM_THRESHOLD) {
+        shift = clz(b);
+        if (shift == 0) {
+            /* normalized case: b >= 2^(LIMB_BITS-1) */
+            limb_t b_inv;
+            b_inv = udiv1norm_init(b);
+            for(i = na - 1; i >= 0; i--) {
+                muldq(t1, t0, r, base);
+                adddq(t1, t0, 0, taba[i]);
+                q = udiv1norm(&r, t1, t0, b, b_inv);
+                tabr[i] = q;
+            }
+        } else {
+            limb_t b_inv;
+            b <<= shift;
+            b_inv = udiv1norm_init(b);
+            for(i = na - 1; i >= 0; i--) {
+                muldq(t1, t0, r, base);
+                adddq(t1, t0, 0, taba[i]);
+                t1 = (t1 << shift) | (t0 >> (LIMB_BITS - shift));
+                t0 <<= shift;
+                q = udiv1norm(&r, t1, t0, b, b_inv);
+                r >>= shift;
+                tabr[i] = q;
+            }
+        }
+    } else {
+        for(i = na - 1; i >= 0; i--) {
+            muldq(t1, t0, r, base);
+            adddq(t1, t0, 0, taba[i]);
+            divdq(q, r, t1, t0, b);
+            tabr[i] = q;
+        }
+    }
+    return r;
+}
+
+static __maybe_unused void mp_print_str_dec(const char *str,
+                                       const limb_t *tab, slimb_t n)
+{
+    slimb_t i;
+    printf("%s=", str);
+    for(i = n - 1; i >= 0; i--) {
+        if (i != n - 1)
+            printf("_");
+        printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
+    }
+    printf("\n");
+}
+
+static __maybe_unused void mp_print_str_h_dec(const char *str,
+                                              const limb_t *tab, slimb_t n,
+                                              limb_t high)
+{
+    slimb_t i;
+    printf("%s=", str);
+    printf("%0*" PRIu_LIMB, LIMB_DIGITS, high);
+    for(i = n - 1; i >= 0; i--) {
+        printf("_");
+        printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
+    }
+    printf("\n");
+}
+
+//#define DEBUG_DIV_SLOW
+
+#define DIV_STATIC_ALLOC_LEN 16
+
+/* return q = a / b and r = a % b. 
+
+   taba[na] must be allocated if tabb1[nb - 1] < B / 2.  tabb1[nb - 1]
+   must be != zero. na must be >= nb. 's' can be NULL if tabb1[nb - 1]
+   >= B / 2.
+
+   The remainder is is returned in taba and contains nb libms. tabq
+   contains na - nb + 1 limbs. No overlap is permitted.
+
+   Running time of the standard method: (na - nb + 1) * nb
+   Return 0 if OK, -1 if memory alloc error
+*/
+/* XXX: optimize */
+static int mp_div_dec(bf_context_t *s, limb_t *tabq,
+                      limb_t *taba, mp_size_t na, 
+                      const limb_t *tabb1, mp_size_t nb)
+{
+    limb_t base = BF_DEC_BASE;
+    limb_t r, mult, t0, t1, a, c, q, v, *tabb;
+    mp_size_t i, j;
+    limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
+    
+#ifdef DEBUG_DIV_SLOW
+    mp_print_str_dec("a", taba, na);
+    mp_print_str_dec("b", tabb1, nb);
+#endif
+
+    /* normalize tabb */
+    r = tabb1[nb - 1];
+    assert(r != 0);
+    i = na - nb;
+    if (r >= BF_DEC_BASE / 2) {
+        mult = 1;
+        tabb = (limb_t *)tabb1;
+        q = 1;
+        for(j = nb - 1; j >= 0; j--) {
+            if (taba[i + j] != tabb[j]) {
+                if (taba[i + j] < tabb[j])
+                    q = 0;
+                break;
+            }
+        }
+        tabq[i] = q;
+        if (q) {
+            mp_sub_dec(taba + i, taba + i, tabb, nb, 0);
+        }
+        i--;
+    } else {
+        mult = base / (r + 1);
+        if (likely(nb <= DIV_STATIC_ALLOC_LEN)) {
+            tabb = static_tabb;
+        } else {
+            tabb = bf_malloc(s, sizeof(limb_t) * nb);
+            if (!tabb)
+                return -1;
+        }
+        mp_mul1_dec(tabb, tabb1, nb, mult, 0);
+        taba[na] = mp_mul1_dec(taba, taba, na, mult, 0);
+    }
+
+#ifdef DEBUG_DIV_SLOW
+    printf("mult=" FMT_LIMB "\n", mult);
+    mp_print_str_dec("a_norm", taba, na + 1);
+    mp_print_str_dec("b_norm", tabb, nb);
+#endif
+
+    for(; i >= 0; i--) {
+        if (unlikely(taba[i + nb] >= tabb[nb - 1])) {
+            /* XXX: check if it is really possible */
+            q = base - 1;
+        } else {
+            muldq(t1, t0, taba[i + nb], base);
+            adddq(t1, t0, 0, taba[i + nb - 1]);
+            divdq(q, r, t1, t0, tabb[nb - 1]);
+        }
+        //        printf("i=%d q1=%ld\n", i, q);
+
+        r = mp_sub_mul1_dec(taba + i, tabb, nb, q);
+        //        mp_dump("r1", taba + i, nb, bd);
+        //        printf("r2=%ld\n", r);
+
+        v = taba[i + nb];
+        a = v - r;
+        c = a > v;
+        if (c)
+            a += base;
+        taba[i + nb] = a;
+
+        if (c != 0) {
+            /* negative result */
+            for(;;) {
+                q--;
+                c = mp_add_dec(taba + i, taba + i, tabb, nb, 0);
+                /* propagate carry and test if positive result */
+                if (c != 0) {
+                    if (++taba[i + nb] == base) {
+                        break;
+                    }
+                }
+            }
+        }
+        tabq[i] = q;
+    }
+
+#ifdef DEBUG_DIV_SLOW
+    mp_print_str_dec("q", tabq, na - nb + 1);
+    mp_print_str_dec("r", taba, nb);
+#endif
+
+    /* remove the normalization */
+    if (mult != 1) {
+        mp_div1_dec(taba, taba, nb, mult, 0);
+        if (unlikely(tabb != static_tabb))
+            bf_free(s, tabb);
+    }
+    return 0;
+}
+
+/* divide by 10^shift */
+static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+                         limb_t shift, limb_t high)
+{
+    mp_size_t i;
+    limb_t l, a, q, r;
+
+    assert(shift >= 1 && shift < LIMB_DIGITS);
+    l = high;
+    for(i = n - 1; i >= 0; i--) {
+        a = tab[i];
+        fast_udivrem(q, r, a, &mp_pow_div[shift]);
+        tab_r[i] = q + l * mp_pow_dec[LIMB_DIGITS - shift];
+        l = r;
+    }
+    return l;
+}
+
+/* multiply by 10^shift */
+static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+                         limb_t shift, limb_t low)
+{
+    mp_size_t i;
+    limb_t l, a, q, r;
+
+    assert(shift >= 1 && shift < LIMB_DIGITS);
+    l = low;
+    for(i = 0; i < n; i++) {
+        a = tab[i];
+        fast_udivrem(q, r, a, &mp_pow_div[LIMB_DIGITS - shift]);
+        tab_r[i] = r * mp_pow_dec[shift] + l;
+        l = q;
+    }
+    return l;
+}
+
+static limb_t mp_sqrtrem2_dec(limb_t *tabs, limb_t *taba)
+{
+    int k;
+    dlimb_t a, b, r;
+    limb_t taba1[2], s, r0, r1;
+
+    /* convert to binary and normalize */
+    a = (dlimb_t)taba[1] * BF_DEC_BASE + taba[0];
+    k = clz(a >> LIMB_BITS) & ~1;
+    b = a << k;
+    taba1[0] = b;
+    taba1[1] = b >> LIMB_BITS;
+    mp_sqrtrem2(&s, taba1);
+    s >>= (k >> 1);
+    /* convert the remainder back to decimal */
+    r = a - (dlimb_t)s * (dlimb_t)s;
+    divdq_base(r1, r0, r >> LIMB_BITS, r);
+    taba[0] = r0;
+    tabs[0] = s;
+    return r1;
+}
+
+//#define DEBUG_SQRTREM_DEC
+
+/* tmp_buf must contain (n / 2 + 1 limbs) */
+static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
+                                 limb_t *tmp_buf)
+{
+    limb_t l, h, rh, ql, qh, c, i;
+    
+    if (n == 1)
+        return mp_sqrtrem2_dec(tabs, taba);
+#ifdef DEBUG_SQRTREM_DEC
+    mp_print_str_dec("a", taba, 2 * n);
+#endif
+    l = n / 2;
+    h = n - l;
+    qh = mp_sqrtrem_rec_dec(tabs + l, taba + 2 * l, h, tmp_buf);
+#ifdef DEBUG_SQRTREM_DEC
+    mp_print_str_dec("s1", tabs + l, h);
+    mp_print_str_h_dec("r1", taba + 2 * l, h, qh);
+    mp_print_str_h_dec("r2", taba + l, n, qh);
+#endif
+    
+    /* the remainder is in taba + 2 * l. Its high bit is in qh */
+    if (qh) {
+        mp_sub_dec(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
+    }
+    /* instead of dividing by 2*s, divide by s (which is normalized)
+       and update q and r */
+    mp_div_dec(NULL, tmp_buf, taba + l, n, tabs + l, h);
+    qh += tmp_buf[l];
+    for(i = 0; i < l; i++)
+        tabs[i] = tmp_buf[i];
+    ql = mp_div1_dec(tabs, tabs, l, 2, qh & 1);
+    qh = qh >> 1; /* 0 or 1 */
+    if (ql)
+        rh = mp_add_dec(taba + l, taba + l, tabs + l, h, 0);
+    else
+        rh = 0;
+#ifdef DEBUG_SQRTREM_DEC
+    mp_print_str_h_dec("q", tabs, l, qh);
+    mp_print_str_h_dec("u", taba + l, h, rh);
+#endif
+    
+    mp_add_ui_dec(tabs + l, qh, h);
+#ifdef DEBUG_SQRTREM_DEC
+    mp_print_str_dec("s2", tabs, n);
+#endif
+    
+    /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
+    /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
+    if (qh) {
+        c = qh;
+    } else {
+        mp_mul_basecase_dec(taba + n, tabs, l, tabs, l);
+        c = mp_sub_dec(taba, taba, taba + n, 2 * l, 0);
+    }
+    rh -= mp_sub_ui_dec(taba + 2 * l, c, n - 2 * l);
+    if ((slimb_t)rh < 0) {
+        mp_sub_ui_dec(tabs, 1, n);
+        rh += mp_add_mul1_dec(taba, tabs, n, 2);
+        rh += mp_add_ui_dec(taba, 1, n);
+    }
+    return rh;
+}
+
+/* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= B/4. Return (s,
+   r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2 * s. tabs has n
+   limbs. r is returned in the lower n limbs of taba. Its r[n] is the
+   returned value of the function. */
+int mp_sqrtrem_dec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
+{
+    limb_t tmp_buf1[8];
+    limb_t *tmp_buf;
+    mp_size_t n2;
+    n2 = n / 2 + 1;
+    if (n2 <= countof(tmp_buf1)) {
+        tmp_buf = tmp_buf1;
+    } else {
+        tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
+        if (!tmp_buf)
+            return -1;
+    }
+    taba[n] = mp_sqrtrem_rec_dec(tabs, taba, n, tmp_buf);
+    if (tmp_buf != tmp_buf1)
+        bf_free(s, tmp_buf);
+    return 0;
+}
+
+/* return the number of leading zero digits, from 0 to LIMB_DIGITS */
+static int clz_dec(limb_t a)
+{
+    if (a == 0)
+        return LIMB_DIGITS;
+    switch(LIMB_BITS - 1 - clz(a)) {
+    case 0: /* 1-1 */
+        return LIMB_DIGITS - 1;
+    case 1: /* 2-3 */
+        return LIMB_DIGITS - 1;
+    case 2: /* 4-7 */
+        return LIMB_DIGITS - 1;
+    case 3: /* 8-15 */
+        if (a < 10)
+            return LIMB_DIGITS - 1;
+        else
+            return LIMB_DIGITS - 2;
+    case 4: /* 16-31 */
+        return LIMB_DIGITS - 2;
+    case 5: /* 32-63 */
+        return LIMB_DIGITS - 2;
+    case 6: /* 64-127 */
+        if (a < 100)
+            return LIMB_DIGITS - 2;
+        else
+            return LIMB_DIGITS - 3;
+    case 7: /* 128-255 */
+        return LIMB_DIGITS - 3;
+    case 8: /* 256-511 */
+        return LIMB_DIGITS - 3;
+    case 9: /* 512-1023 */
+        if (a < 1000)
+            return LIMB_DIGITS - 3;
+        else
+            return LIMB_DIGITS - 4;
+    case 10: /* 1024-2047 */
+        return LIMB_DIGITS - 4;
+    case 11: /* 2048-4095 */
+        return LIMB_DIGITS - 4;
+    case 12: /* 4096-8191 */
+        return LIMB_DIGITS - 4;
+    case 13: /* 8192-16383 */
+        if (a < 10000)
+            return LIMB_DIGITS - 4;
+        else
+            return LIMB_DIGITS - 5;
+    case 14: /* 16384-32767 */
+        return LIMB_DIGITS - 5;
+    case 15: /* 32768-65535 */
+        return LIMB_DIGITS - 5;
+    case 16: /* 65536-131071 */
+        if (a < 100000)
+            return LIMB_DIGITS - 5;
+        else
+            return LIMB_DIGITS - 6;
+    case 17: /* 131072-262143 */
+        return LIMB_DIGITS - 6;
+    case 18: /* 262144-524287 */
+        return LIMB_DIGITS - 6;
+    case 19: /* 524288-1048575 */
+        if (a < 1000000)
+            return LIMB_DIGITS - 6;
+        else
+            return LIMB_DIGITS - 7;
+    case 20: /* 1048576-2097151 */
+        return LIMB_DIGITS - 7;
+    case 21: /* 2097152-4194303 */
+        return LIMB_DIGITS - 7;
+    case 22: /* 4194304-8388607 */
+        return LIMB_DIGITS - 7;
+    case 23: /* 8388608-16777215 */
+        if (a < 10000000)
+            return LIMB_DIGITS - 7;
+        else
+            return LIMB_DIGITS - 8;
+    case 24: /* 16777216-33554431 */
+        return LIMB_DIGITS - 8;
+    case 25: /* 33554432-67108863 */
+        return LIMB_DIGITS - 8;
+    case 26: /* 67108864-134217727 */
+        if (a < 100000000)
+            return LIMB_DIGITS - 8;
+        else
+            return LIMB_DIGITS - 9;
+#if LIMB_BITS == 64
+    case 27: /* 134217728-268435455 */
+        return LIMB_DIGITS - 9;
+    case 28: /* 268435456-536870911 */
+        return LIMB_DIGITS - 9;
+    case 29: /* 536870912-1073741823 */
+        if (a < 1000000000)
+            return LIMB_DIGITS - 9;
+        else
+            return LIMB_DIGITS - 10;
+    case 30: /* 1073741824-2147483647 */
+        return LIMB_DIGITS - 10;
+    case 31: /* 2147483648-4294967295 */
+        return LIMB_DIGITS - 10;
+    case 32: /* 4294967296-8589934591 */
+        return LIMB_DIGITS - 10;
+    case 33: /* 8589934592-17179869183 */
+        if (a < 10000000000)
+            return LIMB_DIGITS - 10;
+        else
+            return LIMB_DIGITS - 11;
+    case 34: /* 17179869184-34359738367 */
+        return LIMB_DIGITS - 11;
+    case 35: /* 34359738368-68719476735 */
+        return LIMB_DIGITS - 11;
+    case 36: /* 68719476736-137438953471 */
+        if (a < 100000000000)
+            return LIMB_DIGITS - 11;
+        else
+            return LIMB_DIGITS - 12;
+    case 37: /* 137438953472-274877906943 */
+        return LIMB_DIGITS - 12;
+    case 38: /* 274877906944-549755813887 */
+        return LIMB_DIGITS - 12;
+    case 39: /* 549755813888-1099511627775 */
+        if (a < 1000000000000)
+            return LIMB_DIGITS - 12;
+        else
+            return LIMB_DIGITS - 13;
+    case 40: /* 1099511627776-2199023255551 */
+        return LIMB_DIGITS - 13;
+    case 41: /* 2199023255552-4398046511103 */
+        return LIMB_DIGITS - 13;
+    case 42: /* 4398046511104-8796093022207 */
+        return LIMB_DIGITS - 13;
+    case 43: /* 8796093022208-17592186044415 */
+        if (a < 10000000000000)
+            return LIMB_DIGITS - 13;
+        else
+            return LIMB_DIGITS - 14;
+    case 44: /* 17592186044416-35184372088831 */
+        return LIMB_DIGITS - 14;
+    case 45: /* 35184372088832-70368744177663 */
+        return LIMB_DIGITS - 14;
+    case 46: /* 70368744177664-140737488355327 */
+        if (a < 100000000000000)
+            return LIMB_DIGITS - 14;
+        else
+            return LIMB_DIGITS - 15;
+    case 47: /* 140737488355328-281474976710655 */
+        return LIMB_DIGITS - 15;
+    case 48: /* 281474976710656-562949953421311 */
+        return LIMB_DIGITS - 15;
+    case 49: /* 562949953421312-1125899906842623 */
+        if (a < 1000000000000000)
+            return LIMB_DIGITS - 15;
+        else
+            return LIMB_DIGITS - 16;
+    case 50: /* 1125899906842624-2251799813685247 */
+        return LIMB_DIGITS - 16;
+    case 51: /* 2251799813685248-4503599627370495 */
+        return LIMB_DIGITS - 16;
+    case 52: /* 4503599627370496-9007199254740991 */
+        return LIMB_DIGITS - 16;
+    case 53: /* 9007199254740992-18014398509481983 */
+        if (a < 10000000000000000)
+            return LIMB_DIGITS - 16;
+        else
+            return LIMB_DIGITS - 17;
+    case 54: /* 18014398509481984-36028797018963967 */
+        return LIMB_DIGITS - 17;
+    case 55: /* 36028797018963968-72057594037927935 */
+        return LIMB_DIGITS - 17;
+    case 56: /* 72057594037927936-144115188075855871 */
+        if (a < 100000000000000000)
+            return LIMB_DIGITS - 17;
+        else
+            return LIMB_DIGITS - 18;
+    case 57: /* 144115188075855872-288230376151711743 */
+        return LIMB_DIGITS - 18;
+    case 58: /* 288230376151711744-576460752303423487 */
+        return LIMB_DIGITS - 18;
+    case 59: /* 576460752303423488-1152921504606846975 */
+        if (a < 1000000000000000000)
+            return LIMB_DIGITS - 18;
+        else
+            return LIMB_DIGITS - 19;
+#endif
+    default:
+        return 0;
+    }
+}
+
+/* for debugging */
+void bfdec_print_str(const char *str, const bfdec_t *a)
+{
+    slimb_t i;
+    printf("%s=", str);
+
+    if (a->expn == BF_EXP_NAN) {
+        printf("NaN");
+    } else {
+        if (a->sign)
+            putchar('-');
+        if (a->expn == BF_EXP_ZERO) {
+            putchar('0');
+        } else if (a->expn == BF_EXP_INF) {
+            printf("Inf");
+        } else {
+            printf("0.");
+            for(i = a->len - 1; i >= 0; i--)
+                printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
+            printf("e%" PRId_LIMB, a->expn);
+        }
+    }
+    printf("\n");
+}
+
+/* return != 0 if one digit between 0 and bit_pos inclusive is not zero. */
+static inline limb_t scan_digit_nz(const bfdec_t *r, slimb_t bit_pos)
+{
+    slimb_t pos;
+    limb_t v, q;
+    int shift;
+
+    if (bit_pos < 0)
+        return 0;
+    pos = (limb_t)bit_pos / LIMB_DIGITS;
+    shift = (limb_t)bit_pos % LIMB_DIGITS;
+    fast_udivrem(q, v, r->tab[pos], &mp_pow_div[shift + 1]);
+    (void)q;
+    if (v != 0)
+        return 1;
+    pos--;
+    while (pos >= 0) {
+        if (r->tab[pos] != 0)
+            return 1;
+        pos--;
+    }
+    return 0;
+}
+
+static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos)
+{
+    slimb_t i;
+    int shift;
+    i = floor_div(pos, LIMB_DIGITS);
+    if (i < 0 || i >= len)
+        return 0;
+    shift = pos - i * LIMB_DIGITS;
+    return fast_udiv(tab[i], &mp_pow_div[shift]) % 10;
+}
+
+#if 0
+static limb_t get_digits(const limb_t *tab, limb_t len, slimb_t pos)
+{
+    limb_t a0, a1;
+    int shift;
+    slimb_t i;
+    
+    i = floor_div(pos, LIMB_DIGITS);
+    shift = pos - i * LIMB_DIGITS;
+    if (i >= 0 && i < len)
+        a0 = tab[i];
+    else
+        a0 = 0;
+    if (shift == 0) {
+        return a0;
+    } else {
+        i++;
+        if (i >= 0 && i < len)
+            a1 = tab[i];
+        else
+            a1 = 0;
+        return fast_udiv(a0, &mp_pow_div[shift]) +
+            fast_urem(a1, &mp_pow_div[LIMB_DIGITS - shift]) *
+            mp_pow_dec[shift];
+    }
+}
+#endif
+
+/* return the addend for rounding. Note that prec can be <= 0 for bf_rint() */
+static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
+                             slimb_t prec, int rnd_mode)
+{
+    int add_one, inexact;
+    limb_t digit1, digit0;
+    
+    //    bfdec_print_str("get_rnd_add", r);
+    if (rnd_mode == BF_RNDF) {
+        digit0 = 1; /* faithful rounding does not honor the INEXACT flag */
+    } else {
+        /* starting limb for bit 'prec + 1' */
+        digit0 = scan_digit_nz(r, l * LIMB_DIGITS - 1 - bf_max(0, prec + 1));
+    }
+
+    /* get the digit at 'prec' */
+    digit1 = get_digit(r->tab, l, l * LIMB_DIGITS - 1 - prec);
+    inexact = (digit1 | digit0) != 0;
+    
+    add_one = 0;
+    switch(rnd_mode) {
+    case BF_RNDZ:
+        break;
+    case BF_RNDN:
+        if (digit1 == 5) {
+            if (digit0) {
+                add_one = 1;
+            } else {
+                /* round to even */
+                add_one =
+                    get_digit(r->tab, l, l * LIMB_DIGITS - 1 - (prec - 1)) & 1;
+            }
+        } else if (digit1 > 5) {
+            add_one = 1;
+        }
+        break;
+    case BF_RNDD:
+    case BF_RNDU:
+        if (r->sign == (rnd_mode == BF_RNDD))
+            add_one = inexact;
+        break;
+    case BF_RNDNA:
+    case BF_RNDF:
+        add_one = (digit1 >= 5);
+        break;
+    case BF_RNDNU:
+        if (digit1 >= 5) {
+            if (r->sign)
+                add_one = (digit0 != 0);
+            else
+                add_one = 1;
+        }
+        break;
+    default:
+        abort();
+    }
+    
+    if (inexact)
+        *pret |= BF_ST_INEXACT;
+    return add_one;
+}
+
+/* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
+   assumed to have length 'l' (1 <= l <= r->len). prec1 can be
+   BF_PREC_INF. BF_FLAG_SUBNORMAL is not supported. Cannot fail with
+   BF_ST_MEM_ERROR.
+ */
+static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
+{
+    int shift, add_one, rnd_mode, ret;
+    slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
+
+    /* e_min and e_max are computed to match the IEEE 754 conventions */
+    /* XXX: does not matter for decimal numbers */
+    e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
+    e_min = -e_range + 3;
+    e_max = e_range;
+    
+    if (flags & BF_FLAG_RADPNT_PREC) {
+        /* 'prec' is the precision after the decimal point */
+        if (prec1 != BF_PREC_INF)
+            prec = r->expn + prec1;
+        else
+            prec = prec1;
+    } else {
+        prec = prec1;
+    }
+    
+    /* round to prec bits */
+    rnd_mode = flags & BF_RND_MASK;
+    ret = 0;
+    add_one = bfdec_get_rnd_add(&ret, r, l, prec, rnd_mode);
+    
+    if (prec <= 0) {
+        if (add_one) {
+            bfdec_resize(r, 1); /* cannot fail because r is non zero */
+            r->tab[0] = BF_DEC_BASE / 10;
+            r->expn += 1 - prec;
+            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
+            return ret;
+        } else {
+            goto underflow;
+        }
+    } else if (add_one) {
+        limb_t carry;
+        
+        /* add one starting at digit 'prec - 1' */
+        bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
+        pos = bit_pos / LIMB_DIGITS;
+        carry = mp_pow_dec[bit_pos % LIMB_DIGITS];
+        carry = mp_add_ui_dec(r->tab + pos, carry, l - pos);
+        if (carry) {
+            /* shift right by one digit */
+            mp_shr_dec(r->tab + pos, r->tab + pos, l - pos, 1, 1);
+            r->expn++;
+        }
+    }
+    
+    /* check underflow */
+    if (unlikely(r->expn < e_min)) {
+    underflow:
+        bfdec_set_zero(r, r->sign);
+        ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
+        return ret;
+    }
+    
+    /* check overflow */
+    if (unlikely(r->expn > e_max)) {
+        bfdec_set_inf(r, r->sign);
+        ret |= BF_ST_OVERFLOW | BF_ST_INEXACT;
+        return ret;
+    }
+    
+    /* keep the bits starting at 'prec - 1' */
+    bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
+    i = floor_div(bit_pos, LIMB_DIGITS);
+    if (i >= 0) {
+        shift = smod(bit_pos, LIMB_DIGITS);
+        if (shift != 0) {
+            r->tab[i] = fast_udiv(r->tab[i], &mp_pow_div[shift]) *
+                mp_pow_dec[shift];
+        }
+    } else {
+        i = 0;
+    }
+    /* remove trailing zeros */
+    while (r->tab[i] == 0)
+        i++;
+    if (i > 0) {
+        l -= i;
+        memmove(r->tab, r->tab + i, l * sizeof(limb_t));
+    }
+    bfdec_resize(r, l); /* cannot fail */
+    return ret;
+}
+
+/* Cannot fail with BF_ST_MEM_ERROR. */
+int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags)
+{
+    if (r->len == 0)
+        return 0;
+    return __bfdec_round(r, prec, flags, r->len);
+}
+
+/* 'r' must be a finite number. Cannot fail with BF_ST_MEM_ERROR.  */
+int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags)
+{
+    limb_t l, v;
+    int shift, ret;
+    
+    //    bfdec_print_str("bf_renorm", r);
+    l = r->len;
+    while (l > 0 && r->tab[l - 1] == 0)
+        l--;
+    if (l == 0) {
+        /* zero */
+        r->expn = BF_EXP_ZERO;
+        bfdec_resize(r, 0); /* cannot fail */
+        ret = 0;
+    } else {
+        r->expn -= (r->len - l) * LIMB_DIGITS;
+        /* shift to have the MSB set to '1' */
+        v = r->tab[l - 1];
+        shift = clz_dec(v);
+        if (shift != 0) {
+            mp_shl_dec(r->tab, r->tab, l, shift, 0);
+            r->expn -= shift;
+        }
+        ret = __bfdec_round(r, prec1, flags, l);
+    }
+    //    bf_print_str("r_final", r);
+    return ret;
+}
+
+int bfdec_set_ui(bfdec_t *r, uint64_t v)
+{
+#if LIMB_BITS == 32
+    if (v >= BF_DEC_BASE * BF_DEC_BASE) {
+        if (bfdec_resize(r, 3))
+            goto fail;
+        r->tab[0] = v % BF_DEC_BASE;
+        v /= BF_DEC_BASE;
+        r->tab[1] = v % BF_DEC_BASE;
+        r->tab[2] = v / BF_DEC_BASE;
+        r->expn = 3 * LIMB_DIGITS;
+    } else
+#endif
+    if (v >= BF_DEC_BASE) {
+        if (bfdec_resize(r, 2))
+            goto fail;
+        r->tab[0] = v % BF_DEC_BASE;
+        r->tab[1] = v / BF_DEC_BASE;
+        r->expn = 2 * LIMB_DIGITS;
+    } else {
+        if (bfdec_resize(r, 1))
+            goto fail;
+        r->tab[0] = v;
+        r->expn = LIMB_DIGITS;
+    }
+    r->sign = 0;
+    return bfdec_normalize_and_round(r, BF_PREC_INF, 0);
+ fail:
+    bfdec_set_nan(r);
+    return BF_ST_MEM_ERROR;
+}
+
+int bfdec_set_si(bfdec_t *r, int64_t v)
+{
+    int ret;
+    if (v < 0) {
+        ret = bfdec_set_ui(r, -v);
+        r->sign = 1;
+    } else {
+        ret = bfdec_set_ui(r, v);
+    }
+    return ret;
+}
+
+static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec, bf_flags_t flags, int b_neg)
+{
+    bf_context_t *s = r->ctx;
+    int is_sub, cmp_res, a_sign, b_sign, ret;
+
+    a_sign = a->sign;
+    b_sign = b->sign ^ b_neg;
+    is_sub = a_sign ^ b_sign;
+    cmp_res = bfdec_cmpu(a, b);
+    if (cmp_res < 0) {
+        const bfdec_t *tmp;
+        tmp = a;
+        a = b;
+        b = tmp;
+        a_sign = b_sign; /* b_sign is never used later */
+    }
+    /* abs(a) >= abs(b) */
+    if (cmp_res == 0 && is_sub && a->expn < BF_EXP_INF) {
+        /* zero result */
+        bfdec_set_zero(r, (flags & BF_RND_MASK) == BF_RNDD);
+        ret = 0;
+    } else if (a->len == 0 || b->len == 0) {
+        ret = 0;
+        if (a->expn >= BF_EXP_INF) {
+            if (a->expn == BF_EXP_NAN) {
+                /* at least one operand is NaN */
+                bfdec_set_nan(r);
+                ret = 0;
+            } else if (b->expn == BF_EXP_INF && is_sub) {
+                /* infinities with different signs */
+                bfdec_set_nan(r);
+                ret = BF_ST_INVALID_OP;
+            } else {
+                bfdec_set_inf(r, a_sign);
+            }
+        } else {
+            /* at least one zero and not subtract */
+            if (bfdec_set(r, a))
+                return BF_ST_MEM_ERROR;
+            r->sign = a_sign;
+            goto renorm;
+        }
+    } else {
+        slimb_t d, a_offset, b_offset, i, r_len;
+        limb_t carry;
+        limb_t *b1_tab;
+        int b_shift;
+        mp_size_t b1_len;
+        
+        d = a->expn - b->expn;
+
+        /* XXX: not efficient in time and memory if the precision is
+           not infinite */
+        r_len = bf_max(a->len, b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
+        if (bfdec_resize(r, r_len))
+            goto fail;
+        r->sign = a_sign;
+        r->expn = a->expn;
+
+        a_offset = r_len - a->len;
+        for(i = 0; i < a_offset; i++)
+            r->tab[i] = 0;
+        for(i = 0; i < a->len; i++)
+            r->tab[a_offset + i] = a->tab[i];
+        
+        b_shift = d % LIMB_DIGITS;
+        if (b_shift == 0) {
+            b1_len = b->len;
+            b1_tab = (limb_t *)b->tab;
+        } else {
+            b1_len = b->len + 1;
+            b1_tab = bf_malloc(s, sizeof(limb_t) * b1_len);
+            if (!b1_tab)
+                goto fail;
+            b1_tab[0] = mp_shr_dec(b1_tab + 1, b->tab, b->len, b_shift, 0) *
+                mp_pow_dec[LIMB_DIGITS - b_shift];
+        }
+        b_offset = r_len - (b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
+        
+        if (is_sub) {
+            carry = mp_sub_dec(r->tab + b_offset, r->tab + b_offset,
+                               b1_tab, b1_len, 0);
+            if (carry != 0) {
+                carry = mp_sub_ui_dec(r->tab + b_offset + b1_len, carry,
+                                      r_len - (b_offset + b1_len));
+                assert(carry == 0);
+            }
+        } else {
+            carry = mp_add_dec(r->tab + b_offset, r->tab + b_offset,
+                               b1_tab, b1_len, 0);
+            if (carry != 0) {
+                carry = mp_add_ui_dec(r->tab + b_offset + b1_len, carry,
+                                      r_len - (b_offset + b1_len));
+            }
+            if (carry != 0) {
+                if (bfdec_resize(r, r_len + 1)) {
+                    if (b_shift != 0)
+                        bf_free(s, b1_tab);
+                    goto fail;
+                }
+                r->tab[r_len] = 1;
+                r->expn += LIMB_DIGITS;
+            }
+        }
+        if (b_shift != 0)
+            bf_free(s, b1_tab);
+    renorm:
+        ret = bfdec_normalize_and_round(r, prec, flags);
+    }
+    return ret;
+ fail:
+    bfdec_set_nan(r);
+    return BF_ST_MEM_ERROR;
+}
+
+static int __bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+                     bf_flags_t flags)
+{
+    return bfdec_add_internal(r, a, b, prec, flags, 0);
+}
+
+static int __bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+                     bf_flags_t flags)
+{
+    return bfdec_add_internal(r, a, b, prec, flags, 1);
+}
+
+int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags)
+{
+    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
+                  (bf_op2_func_t *)__bfdec_add);
+}
+
+int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags)
+{
+    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
+                  (bf_op2_func_t *)__bfdec_sub);
+}
+
+int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags)
+{
+    int ret, r_sign;
+
+    if (a->len < b->len) {
+        const bfdec_t *tmp = a;
+        a = b;
+        b = tmp;
+    }
+    r_sign = a->sign ^ b->sign;
+    /* here b->len <= a->len */
+    if (b->len == 0) {
+        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
+            bfdec_set_nan(r);
+            ret = 0;
+        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_INF) {
+            if ((a->expn == BF_EXP_INF && b->expn == BF_EXP_ZERO) ||
+                (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_INF)) {
+                bfdec_set_nan(r);
+                ret = BF_ST_INVALID_OP;
+            } else {
+                bfdec_set_inf(r, r_sign);
+                ret = 0;
+            }
+        } else {
+            bfdec_set_zero(r, r_sign);
+            ret = 0;
+        }
+    } else {
+        bfdec_t tmp, *r1 = NULL;
+        limb_t a_len, b_len;
+        limb_t *a_tab, *b_tab;
+            
+        a_len = a->len;
+        b_len = b->len;
+        a_tab = a->tab;
+        b_tab = b->tab;
+        
+        if (r == a || r == b) {
+            bfdec_init(r->ctx, &tmp);
+            r1 = r;
+            r = &tmp;
+        }
+        if (bfdec_resize(r, a_len + b_len)) {
+            bfdec_set_nan(r);
+            ret = BF_ST_MEM_ERROR;
+            goto done;
+        }
+        mp_mul_basecase_dec(r->tab, a_tab, a_len, b_tab, b_len);
+        r->sign = r_sign;
+        r->expn = a->expn + b->expn;
+        ret = bfdec_normalize_and_round(r, prec, flags);
+    done:
+        if (r == &tmp)
+            bfdec_move(r1, &tmp);
+    }
+    return ret;
+}
+
+int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags)
+{
+    bfdec_t b;
+    int ret;
+    bfdec_init(r->ctx, &b);
+    ret = bfdec_set_si(&b, b1);
+    ret |= bfdec_mul(r, a, &b, prec, flags);
+    bfdec_delete(&b);
+    return ret;
+}
+
+int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags)
+{
+    bfdec_t b;
+    int ret;
+    
+    bfdec_init(r->ctx, &b);
+    ret = bfdec_set_si(&b, b1);
+    ret |= bfdec_add(r, a, &b, prec, flags);
+    bfdec_delete(&b);
+    return ret;
+}
+
+static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
+                       limb_t prec, bf_flags_t flags)
+{
+    int ret, r_sign;
+    limb_t n, nb, precl;
+    
+    r_sign = a->sign ^ b->sign;
+    if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
+        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
+            bfdec_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
+            bfdec_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else if (a->expn == BF_EXP_INF) {
+            bfdec_set_inf(r, r_sign);
+            return 0;
+        } else {
+            bfdec_set_zero(r, r_sign);
+            return 0;
+        }
+    } else if (a->expn == BF_EXP_ZERO) {
+        if (b->expn == BF_EXP_ZERO) {
+            bfdec_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bfdec_set_zero(r, r_sign);
+            return 0;
+        }
+    } else if (b->expn == BF_EXP_ZERO) {
+        bfdec_set_inf(r, r_sign);
+        return BF_ST_DIVIDE_ZERO;
+    }
+
+    nb = b->len;
+    if (prec == BF_PREC_INF) {
+        /* infinite precision: return BF_ST_INVALID_OP if not an exact
+           result */
+        /* XXX: check */
+        precl = nb + 1;
+    } else if (flags & BF_FLAG_RADPNT_PREC) {
+        /* number of digits after the decimal point */
+        /* XXX: check (2 extra digits for rounding + 2 digits) */
+        precl = (bf_max(a->expn - b->expn, 0) + 2 +
+                 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+    } else {
+        /* number of limbs of the quotient (2 extra digits for rounding) */
+         precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+    }
+    n = bf_max(a->len, precl);
+    
+    {
+        limb_t *taba, na, i;
+        slimb_t d;
+        
+        na = n + nb;
+        taba = bf_malloc(r->ctx, (na + 1) * sizeof(limb_t));
+        if (!taba)
+            goto fail;
+        d = na - a->len;
+        memset(taba, 0, d * sizeof(limb_t));
+        memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
+        if (bfdec_resize(r, n + 1))
+            goto fail1;
+        if (mp_div_dec(r->ctx, r->tab, taba, na, b->tab, nb)) {
+        fail1:
+            bf_free(r->ctx, taba);
+            goto fail;
+        }
+        /* see if non zero remainder */
+        for(i = 0; i < nb; i++) {
+            if (taba[i] != 0)
+                break;
+        }
+        bf_free(r->ctx, taba);
+        if (i != nb) {
+            if (prec == BF_PREC_INF) {
+                bfdec_set_nan(r);
+                return BF_ST_INVALID_OP;
+            } else {
+                r->tab[0] |= 1;
+            }
+        }
+        r->expn = a->expn - b->expn + LIMB_DIGITS;
+        r->sign = r_sign;
+        ret = bfdec_normalize_and_round(r, prec, flags);
+    }
+    return ret;
+ fail:
+    bfdec_set_nan(r);
+    return BF_ST_MEM_ERROR;
+}
+
+int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags)
+{
+    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
+                  (bf_op2_func_t *)__bfdec_div);
+}
+
+/* a and b must be finite numbers with a >= 0 and b > 0. 'q' is the
+   integer defined as floor(a/b) and r = a - q * b. */
+static void bfdec_tdivremu(bf_context_t *s, bfdec_t *q, bfdec_t *r,
+                           const bfdec_t *a, const bfdec_t *b)
+{
+    if (bfdec_cmpu(a, b) < 0) {
+        bfdec_set_ui(q, 0);
+        bfdec_set(r, a);
+    } else {
+        bfdec_div(q, a, b, 0, BF_RNDZ | BF_FLAG_RADPNT_PREC);
+        bfdec_mul(r, q, b, BF_PREC_INF, BF_RNDZ);
+        bfdec_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
+    }
+}
+
+/* division and remainder. 
+   
+   rnd_mode is the rounding mode for the quotient. The additional
+   rounding mode BF_RND_EUCLIDIAN is supported.
+
+   'q' is an integer. 'r' is rounded with prec and flags (prec can be
+   BF_PREC_INF).
+*/
+int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
+                 limb_t prec, bf_flags_t flags, int rnd_mode)
+{
+    bf_context_t *s = q->ctx;
+    bfdec_t a1_s, *a1 = &a1_s;
+    bfdec_t b1_s, *b1 = &b1_s;
+    bfdec_t r1_s, *r1 = &r1_s;
+    int q_sign, res;
+    BOOL is_ceil, is_rndn;
+    
+    assert(q != a && q != b);
+    assert(r != a && r != b);
+    assert(q != r);
+    
+    if (a->len == 0 || b->len == 0) {
+        bfdec_set_zero(q, 0);
+        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
+            bfdec_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_ZERO) {
+            bfdec_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bfdec_set(r, a);
+            return bfdec_round(r, prec, flags);
+        }
+    }
+
+    q_sign = a->sign ^ b->sign;
+    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
+               rnd_mode == BF_RNDNU);
+    switch(rnd_mode) {
+    default:
+    case BF_RNDZ:
+    case BF_RNDN:
+    case BF_RNDNA:
+        is_ceil = FALSE;
+        break;
+    case BF_RNDD:
+        is_ceil = q_sign;
+        break;
+    case BF_RNDU:
+        is_ceil = q_sign ^ 1;
+        break;
+    case BF_DIVREM_EUCLIDIAN:
+        is_ceil = a->sign;
+        break;
+    case BF_RNDNU:
+        /* XXX: unsupported yet */
+        abort();
+    }
+
+    a1->expn = a->expn;
+    a1->tab = a->tab;
+    a1->len = a->len;
+    a1->sign = 0;
+    
+    b1->expn = b->expn;
+    b1->tab = b->tab;
+    b1->len = b->len;
+    b1->sign = 0;
+
+    //    bfdec_print_str("a1", a1);
+    //    bfdec_print_str("b1", b1);
+    /* XXX: could improve to avoid having a large 'q' */
+    bfdec_tdivremu(s, q, r, a1, b1);
+    if (bfdec_is_nan(q) || bfdec_is_nan(r))
+        goto fail;
+    //    bfdec_print_str("q", q);
+    //    bfdec_print_str("r", r);
+    
+    if (r->len != 0) {
+        if (is_rndn) {
+            bfdec_init(s, r1);
+            if (bfdec_set(r1, r))
+                goto fail;
+            if (bfdec_mul_si(r1, r1, 2, BF_PREC_INF, BF_RNDZ)) {
+                bfdec_delete(r1);
+                goto fail;
+            }
+            res = bfdec_cmpu(r1, b);
+            bfdec_delete(r1);
+            if (res > 0 ||
+                (res == 0 &&
+                 (rnd_mode == BF_RNDNA ||
+                  (get_digit(q->tab, q->len, q->len * LIMB_DIGITS - q->expn) & 1) != 0))) {
+                goto do_sub_r;
+            }
+        } else if (is_ceil) {
+        do_sub_r:
+            res = bfdec_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
+            res |= bfdec_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
+            if (res & BF_ST_MEM_ERROR)
+                goto fail;
+        }
+    }
+
+    r->sign ^= a->sign;
+    q->sign = q_sign;
+    return bfdec_round(r, prec, flags);
+ fail:
+    bfdec_set_nan(q);
+    bfdec_set_nan(r);
+    return BF_ST_MEM_ERROR;
+}
+
+int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+               bf_flags_t flags)
+{
+    bfdec_t q_s, *q = &q_s;
+    int ret;
+    
+    bfdec_init(r->ctx, q);
+    ret = bfdec_divrem(q, r, a, b, prec, flags, BF_RNDZ);
+    bfdec_delete(q);
+    return ret;
+}
+
+/* convert to integer (infinite precision) */
+int bfdec_rint(bfdec_t *r, int rnd_mode)
+{
+    return bfdec_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
+}
+
+int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags)
+{
+    bf_context_t *s = a->ctx;
+    int ret, k;
+    limb_t *a1, v;
+    slimb_t n, n1;
+    limb_t res;
+
+    assert(r != a);
+
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bfdec_set_nan(r);
+        } else if (a->expn == BF_EXP_INF && a->sign) {
+            goto invalid_op;
+        } else {
+            bfdec_set(r, a);
+        }
+        ret = 0;
+    } else if (a->sign || prec == BF_PREC_INF) {
+ invalid_op:
+        bfdec_set_nan(r);
+        ret = BF_ST_INVALID_OP;
+    } else {
+        /* convert the mantissa to an integer with at least 2 *
+           prec + 4 digits */
+        n = (2 * (prec + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
+        if (bfdec_resize(r, n))
+            goto fail;
+        a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
+        if (!a1)
+            goto fail;
+        n1 = bf_min(2 * n, a->len);
+        memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
+        memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
+        if (a->expn & 1) {
+            res = mp_shr_dec(a1, a1, 2 * n, 1, 0);
+        } else {
+            res = 0;
+        }
+        /* normalize so that a1 >= B^(2*n)/4. Not need for n = 1
+           because mp_sqrtrem2_dec already does it */
+        k = 0;
+        if (n > 1) {
+            v = a1[2 * n - 1];
+            while (v < BF_DEC_BASE / 4) {
+                k++;
+                v *= 4;
+            }
+            if (k != 0)
+                mp_mul1_dec(a1, a1, 2 * n, 1 << (2 * k), 0);
+        }
+        if (mp_sqrtrem_dec(s, r->tab, a1, n)) {
+            bf_free(s, a1);
+            goto fail;
+        }
+        if (k != 0)
+            mp_div1_dec(r->tab, r->tab, n, 1 << k, 0);
+        if (!res) {
+            res = mp_scan_nz(a1, n + 1);
+        }
+        bf_free(s, a1);
+        if (!res) {
+            res = mp_scan_nz(a->tab, a->len - n1);
+        }
+        if (res != 0)
+            r->tab[0] |= 1;
+        r->sign = 0;
+        r->expn = (a->expn + 1) >> 1;
+        ret = bfdec_round(r, prec, flags);
+    }
+    return ret;
+ fail:
+    bfdec_set_nan(r);
+    return BF_ST_MEM_ERROR;
+}
+
+/* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
+   is an overflow and 0 otherwise. No memory error is possible. */
+int bfdec_get_int32(int *pres, const bfdec_t *a)
+{
+    uint32_t v;
+    int ret;
+    if (a->expn >= BF_EXP_INF) {
+        ret = 0;
+        if (a->expn == BF_EXP_INF) {
+            v = (uint32_t)INT32_MAX + a->sign;
+             /* XXX: return overflow ? */
+        } else {
+            v = INT32_MAX;
+        }
+    } else if (a->expn <= 0) {
+        v = 0;
+        ret = 0;
+    } else if (a->expn <= 9) {
+        v = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+        if (a->sign)
+            v = -v;
+        ret = 0;
+    } else if (a->expn == 10) {
+        uint64_t v1;
+        uint32_t v_max;
+#if LIMB_BITS == 64
+        v1 = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+#else
+        v1 = (uint64_t)a->tab[a->len - 1] * 10 +
+            get_digit(a->tab, a->len, (a->len - 1) * LIMB_DIGITS - 1);
+#endif
+        v_max = (uint32_t)INT32_MAX + a->sign;
+        if (v1 > v_max) {
+            v = v_max;
+            ret = BF_ST_OVERFLOW;
+        } else {
+            v = v1;
+            if (a->sign)
+                v = -v;
+            ret = 0;
+        }
+    } else {
+        v = (uint32_t)INT32_MAX + a->sign;
+        ret = BF_ST_OVERFLOW;
+    }
+    *pres = v;
+    return ret;
+}
+
+/* power to an integer with infinite precision */
+int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b)
+{
+    int ret, n_bits, i;
+    
+    assert(r != a);
+    if (b == 0)
+        return bfdec_set_ui(r, 1);
+    ret = bfdec_set(r, a);
+    n_bits = LIMB_BITS - clz(b);
+    for(i = n_bits - 2; i >= 0; i--) {
+        ret |= bfdec_mul(r, r, r, BF_PREC_INF, BF_RNDZ);
+        if ((b >> i) & 1)
+            ret |= bfdec_mul(r, r, a, BF_PREC_INF, BF_RNDZ);
+    }
+    return ret;
+}
+
+char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags)
+{
+    return bf_ftoa_internal(plen, (const bf_t *)a, 10, prec, flags, TRUE);
+}
+
+int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
+               limb_t prec, bf_flags_t flags)
+{
+    slimb_t dummy_exp;
+    return bf_atof_internal((bf_t *)r, &dummy_exp, str, pnext, 10, prec,
+                            flags, TRUE);
+}
+
+#endif /* USE_BF_DEC */
+
+#ifdef USE_FFT_MUL
+/***************************************************************/
+/* Integer multiplication with FFT */
+
+/* or LIMB_BITS at bit position 'pos' in tab */
+static inline void put_bits(limb_t *tab, limb_t len, slimb_t pos, limb_t val)
+{
+    limb_t i;
+    int p;
+
+    i = pos >> LIMB_LOG2_BITS;
+    p = pos & (LIMB_BITS - 1);
+    if (i < len)
+        tab[i] |= val << p;
+    if (p != 0) {
+        i++;
+        if (i < len) {
+            tab[i] |= val >> (LIMB_BITS - p);
+        }
+    }
+}
+
+#if defined(__AVX2__)
+
+typedef double NTTLimb;
+
+/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
+#define NTT_MOD_LOG2_MIN 50
+#define NTT_MOD_LOG2_MAX 51
+#define NB_MODS 5
+#define NTT_PROOT_2EXP 39
+static const int ntt_int_bits[NB_MODS] = { 254, 203, 152, 101, 50, };
+
+static const limb_t ntt_mods[NB_MODS] = { 0x00073a8000000001, 0x0007858000000001, 0x0007a38000000001, 0x0007a68000000001, 0x0007fd8000000001,
+};
+
+static const limb_t ntt_proot[2][NB_MODS] = {
+    { 0x00056198d44332c8, 0x0002eb5d640aad39, 0x00047e31eaa35fd0, 0x0005271ac118a150, 0x00075e0ce8442bd5, },
+    { 0x000461169761bcc5, 0x0002dac3cb2da688, 0x0004abc97751e3bf, 0x000656778fc8c485, 0x0000dc6469c269fa, },
+};
+
+static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
+ 0x00020e4da740da8e, 0x0004c3dc09c09c1d, 0x000063bd097b4271, 0x000799d8f18f18fd,
+ 0x0005384222222264, 0x000572b07c1f07fe, 0x00035cd08888889a,
+ 0x00066015555557e3, 0x000725960b60b623,
+ 0x0002fc1fa1d6ce12,
+};
+
+#else
+
+typedef limb_t NTTLimb;
+
+#if LIMB_BITS == 64
+
+#define NTT_MOD_LOG2_MIN 61
+#define NTT_MOD_LOG2_MAX 62
+#define NB_MODS 5
+#define NTT_PROOT_2EXP 51
+static const int ntt_int_bits[NB_MODS] = { 307, 246, 185, 123, 61, };
+
+static const limb_t ntt_mods[NB_MODS] = { 0x28d8000000000001, 0x2a88000000000001, 0x2ed8000000000001, 0x3508000000000001, 0x3aa8000000000001,
+};
+
+static const limb_t ntt_proot[2][NB_MODS] = {
+    { 0x1b8ea61034a2bea7, 0x21a9762de58206fb, 0x02ca782f0756a8ea, 0x278384537a3e50a1, 0x106e13fee74ce0ab, },
+    { 0x233513af133e13b8, 0x1d13140d1c6f75f1, 0x12cde57f97e3eeda, 0x0d6149e23cbe654f, 0x36cd204f522a1379, },
+};
+
+static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
+ 0x08a9ed097b425eea, 0x18a44aaaaaaaaab3, 0x2493f57f57f57f5d, 0x126b8d0649a7f8d4,
+ 0x09d80ed7303b5ccc, 0x25b8bcf3cf3cf3d5, 0x2ce6ce63398ce638,
+ 0x0e31fad40a57eb59, 0x02a3529fd4a7f52f,
+ 0x3a5493e93e93e94a,
+};
+
+#elif LIMB_BITS == 32
+
+/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
+#define NTT_MOD_LOG2_MIN 29
+#define NTT_MOD_LOG2_MAX 30
+#define NB_MODS 5
+#define NTT_PROOT_2EXP 20
+static const int ntt_int_bits[NB_MODS] = { 148, 119, 89, 59, 29, };
+
+static const limb_t ntt_mods[NB_MODS] = { 0x0000000032b00001, 0x0000000033700001, 0x0000000036d00001, 0x0000000037300001, 0x000000003e500001,
+};
+
+static const limb_t ntt_proot[2][NB_MODS] = {
+    { 0x0000000032525f31, 0x0000000005eb3b37, 0x00000000246eda9f, 0x0000000035f25901, 0x00000000022f5768, },
+    { 0x00000000051eba1a, 0x00000000107be10e, 0x000000001cd574e0, 0x00000000053806e6, 0x000000002cd6bf98, },
+};
+
+static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
+ 0x000000000449559a, 0x000000001eba6ca9, 0x000000002ec18e46, 0x000000000860160b,
+ 0x000000000d321307, 0x000000000bf51120, 0x000000000f662938,
+ 0x000000000932ab3e, 0x000000002f40eef8,
+ 0x000000002e760905,
+};
+
+#endif /* LIMB_BITS */
+
+#endif /* !AVX2 */
+
+#if defined(__AVX2__)
 #define NTT_TRIG_K_MAX 18
 #else
 #define NTT_TRIG_K_MAX 19
@@ -4914,10 +7237,10 @@ static void ntt_free(BFNTTState *s, void *ptr)
     bf_aligned_free(s->ctx, ptr);
 }
 
-static no_inline void ntt_fft(BFNTTState *s,
-                              NTTLimb *out_buf, NTTLimb *in_buf,
-                              NTTLimb *tmp_buf, int fft_len_log2,
-                              int inverse, int m_idx)
+static no_inline int ntt_fft(BFNTTState *s,
+                             NTTLimb *out_buf, NTTLimb *in_buf,
+                             NTTLimb *tmp_buf, int fft_len_log2,
+                             int inverse, int m_idx)
 {
     limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j;
     NTTLimb *tab_in, *tab_out, *tmp, *trig;
@@ -4938,6 +7261,8 @@ static no_inline void ntt_fft(BFNTTState *s,
     tab_in = in_buf;
     tab_out = tmp_buf;
     trig = get_trig(s, fft_len_log2, inverse, m_idx);
+    if (!trig)
+        return -1;
     p = 0;
     for(k = 0; k < stride_in; k += 4) {
         a0 = _mm256_load_pd(&tab_in[k]);
@@ -4959,6 +7284,8 @@ static no_inline void ntt_fft(BFNTTState *s,
     tab_out = tmp;
 
     trig = get_trig(s, fft_len_log2 - 1, inverse, m_idx);
+    if (!trig)
+        return -1;
     p = 0;
     for(k = 0; k < stride_in; k += 4) {
         a0 = _mm256_load_pd(&tab_in[k]);
@@ -4986,6 +7313,8 @@ static no_inline void ntt_fft(BFNTTState *s,
         p = 0;
         k = 0;
         trig = get_trig(s, l, inverse, m_idx);
+        if (!trig)
+            return -1;
         for(i = 0; i < nb_blocks; i++) {
             c = _mm256_set1_pd(trig[0]);
             trig++;
@@ -5016,6 +7345,7 @@ static no_inline void ntt_fft(BFNTTState *s,
         _mm256_store_pd(&tab_out[k], b0);
         _mm256_store_pd(&tab_out[k + stride_in], b1);
     }
+    return 0;
 }
 
 static void ntt_vec_mul(BFNTTState *s,
@@ -5088,9 +7418,9 @@ static inline NTTLimb int_to_ntt_limb(slimb_t a, limb_t m)
     return a;
 }
 
-static no_inline void ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
-                              NTTLimb *tmp_buf, int fft_len_log2,
-                              int inverse, int m_idx)
+static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
+                             NTTLimb *tmp_buf, int fft_len_log2,
+                             int inverse, int m_idx)
 {
     limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j, m, m2;
     NTTLimb *tab_in, *tab_out, *tmp, a0, a1, b0, b1, c, *trig, c_inv;
@@ -5110,6 +7440,8 @@ static no_inline void ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
         p = 0;
         k = 0;
         trig = get_trig(s, l, inverse, m_idx);
+        if (!trig)
+            return -1;
         for(i = 0; i < nb_blocks; i++) {
             c = trig[0];
             c_inv = trig[1];
@@ -5142,6 +7474,7 @@ static no_inline void ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
         tab_out[k] = b0;
         tab_out[k + stride_in] = b1;
     }
+    return 0;
 }
 
 static void ntt_vec_mul(BFNTTState *s,
@@ -5183,44 +7516,40 @@ static no_inline void mul_trig(NTTLimb *buf,
 #endif /* !AVX2 */
 
 static no_inline NTTLimb *get_trig(BFNTTState *s,
-                                   int k, int inverse1, int m_idx1)
+                                   int k, int inverse, int m_idx)
 {
     NTTLimb *tab;
     limb_t i, n2, c, c_mul, m, c_mul_inv;
-    int m_idx, inverse;
     
     if (k > NTT_TRIG_K_MAX)
         return NULL;
 
-    for(;;) {
-        tab = s->ntt_trig[m_idx1][inverse1][k];
-        if (tab)
-            return tab;
-        n2 = (limb_t)1 << (k - 1);
-        for(m_idx = 0; m_idx < NB_MODS; m_idx++) {
-            m = ntt_mods[m_idx];
-            for(inverse = 0; inverse < 2; inverse++) {
+    tab = s->ntt_trig[m_idx][inverse][k];
+    if (tab)
+        return tab;
+    n2 = (limb_t)1 << (k - 1);
+    m = ntt_mods[m_idx];
 #ifdef __AVX2__
-                tab = ntt_malloc(s, sizeof(NTTLimb) * n2);
+    tab = ntt_malloc(s, sizeof(NTTLimb) * n2);
 #else
-                tab = ntt_malloc(s, sizeof(NTTLimb) * n2 * 2);
+    tab = ntt_malloc(s, sizeof(NTTLimb) * n2 * 2);
 #endif
-                c = 1;
-                c_mul = s->ntt_proot_pow[m_idx][inverse][k];
-                c_mul_inv = s->ntt_proot_pow_inv[m_idx][inverse][k];
-                for(i = 0; i < n2; i++) {
+    if (!tab)
+        return NULL;
+    c = 1;
+    c_mul = s->ntt_proot_pow[m_idx][inverse][k];
+    c_mul_inv = s->ntt_proot_pow_inv[m_idx][inverse][k];
+    for(i = 0; i < n2; i++) {
 #ifdef __AVX2__
-                    tab[i] = int_to_ntt_limb2(c, m);
+        tab[i] = int_to_ntt_limb2(c, m);
 #else
-                    tab[2 * i] = int_to_ntt_limb(c, m);
-                    tab[2 * i + 1] = init_mul_mod_fast2(c, m);
+        tab[2 * i] = int_to_ntt_limb(c, m);
+        tab[2 * i + 1] = init_mul_mod_fast2(c, m);
 #endif
-                    c = mul_mod_fast2(c, c_mul, m, c_mul_inv);
-                }
-                s->ntt_trig[m_idx][inverse][k] = tab;
-            }
-        }
+        c = mul_mod_fast2(c, c_mul, m, c_mul_inv);
     }
+    s->ntt_trig[m_idx][inverse][k] = tab;
+    return tab;
 }
 
 void fft_clear_cache(bf_context_t *s1)
@@ -5250,20 +7579,25 @@ void fft_clear_cache(bf_context_t *s1)
 #define STRIP_LEN 16
 
 /* dst = buf1, src = buf2 */
-static void ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
-                            int k1, int k2, limb_t n1, limb_t n2, int inverse,
-                            limb_t m_idx)
+static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
+                           int k1, int k2, limb_t n1, limb_t n2, int inverse,
+                           limb_t m_idx)
 {
     limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
     NTTLimb *buf2, *buf3;
     
+    buf2 = NULL;
     buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
+    if (!buf3)
+        goto fail;
     if (k2 == 0) {
-        ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx);
+        if (ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx))
+            goto fail;
     } else {
         strip_len = STRIP_LEN;
         buf2 = ntt_malloc(s, sizeof(NTTLimb) * n1 * strip_len);
-
+        if (!buf2)
+            goto fail;
         m = ntt_mods[m_idx];
         m_inv = s->ntt_mods_div[m_idx];
         c0 = s->ntt_proot_pow[m_idx][inverse][k1 + k2];
@@ -5278,7 +7612,8 @@ static void ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
             for(l = 0; l < strip_len; l++) {
                 if (inverse)
                     mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
-                ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx);
+                if (ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx))
+                    goto fail;
                 if (!inverse)
                     mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
                 c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
@@ -5293,12 +7628,17 @@ static void ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
         ntt_free(s, buf2);
     }
     ntt_free(s, buf3);
+    return 0;
+ fail:
+    ntt_free(s, buf2);
+    ntt_free(s, buf3);
+    return -1;
 }
 
 
 /* dst = buf1, src = buf2, tmp = buf3 */
-static void ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
-                     int k, int k_tot, limb_t m_idx)
+static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
+                    int k, int k_tot, limb_t m_idx)
 {
     limb_t n1, n2, i;
     int k1, k2;
@@ -5313,8 +7653,10 @@ static void ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
     n1 = (limb_t)1 << k1;
     n2 = (limb_t)1 << k2;
     
-    ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx);
-    ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx);
+    if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
+        return -1;
+    if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
+        return -1;
     if (k2 == 0) {
         ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
     } else {
@@ -5322,7 +7664,9 @@ static void ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
             ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
         }
     }
-    ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx);
+    if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
+        return -1;
+    return 0;
 }
 
 
@@ -5710,10 +8054,11 @@ int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
     return fft_len_log2_found;
 }
 
-static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
-                              limb_t *b_tab, limb_t b_len, int mul_flags)
+/* return 0 if OK, -1 if memory error */
+static no_inline int fft_mul(bf_context_t *s1,
+                             bf_t *res, limb_t *a_tab, limb_t a_len,
+                             limb_t *b_tab, limb_t b_len, int mul_flags)
 {
-    bf_context_t *s1 = res->ctx;
     BFNTTState *s;
     int dpl, fft_len_log2, j, nb_mods, reduced_mem;
     slimb_t len, fft_len;
@@ -5722,7 +8067,8 @@ static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
     limb_t ha, hb, hr, h_ref;
 #endif
     
-    ntt_static_init(s1);
+    if (ntt_static_init(s1))
+        return -1;
     s = s1->ntt_state;
     
     /* find the optimal number of digits per limb (dpl) */
@@ -5735,7 +8081,8 @@ static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
     hb = mp_mod1(b_tab, b_len, BF_CHKSUM_MOD, 0);
 #endif
     if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 0) {
-        bf_resize(res, 0);
+        if (!(mul_flags & FFT_MUL_R_NORESIZE))
+            bf_resize(res, 0);
     } else if (mul_flags & FFT_MUL_R_OVERLAP_B) {
         limb_t *tmp_tab, tmp_len;
         /* it is better to free 'b' first */
@@ -5747,20 +8094,28 @@ static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
         b_len = tmp_len;
     }
     buf1 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
+    if (!buf1)
+        return -1;
     limb_to_ntt(s, buf1, fft_len, a_tab, a_len, dpl,
                 NB_MODS - nb_mods, nb_mods);
     if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 
         FFT_MUL_R_OVERLAP_A) {
-        bf_resize(res, 0);
+        if (!(mul_flags & FFT_MUL_R_NORESIZE))
+            bf_resize(res, 0);
     }
     reduced_mem = (fft_len_log2 >= 14);
     if (!reduced_mem) {
         buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
+        if (!buf2)
+            goto fail;
         limb_to_ntt(s, buf2, fft_len, b_tab, b_len, dpl,
                     NB_MODS - nb_mods, nb_mods);
-        bf_resize(res, 0); /* in case res == b */
+        if (!(mul_flags & FFT_MUL_R_NORESIZE))
+            bf_resize(res, 0); /* in case res == b */
     } else {
         buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len);
+        if (!buf2)
+            goto fail;
     }
     for(j = 0; j < nb_mods; j++) {
         if (reduced_mem) {
@@ -5770,12 +8125,18 @@ static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
         } else {
             ptr = buf2 + fft_len * j;
         }
-        ntt_conv(s, buf1 + fft_len * j, ptr,
-                 fft_len_log2, fft_len_log2, j + NB_MODS - nb_mods);
+        if (ntt_conv(s, buf1 + fft_len * j, ptr,
+                     fft_len_log2, fft_len_log2, j + NB_MODS - nb_mods))
+            goto fail;
     }
-    bf_resize(res, 0); /* in case res == b and reduced mem */
+    if (!(mul_flags & FFT_MUL_R_NORESIZE))
+        bf_resize(res, 0); /* in case res == b and reduced mem */
     ntt_free(s, buf2);
-    bf_resize(res, len);
+    buf2 = NULL;
+    if (!(mul_flags & FFT_MUL_R_NORESIZE)) {
+        if (bf_resize(res, len))
+            goto fail;
+    }
     ntt_to_limb(s, res->tab, len, buf1, fft_len_log2, dpl, nb_mods);
     ntt_free(s, buf1);
 #if defined(USE_MUL_CHECK)
@@ -5788,6 +8149,11 @@ static no_inline void fft_mul(bf_t *res, limb_t *a_tab, limb_t a_len,
         exit(1);
     }
 #endif    
+    return 0;
+ fail:
+    ntt_free(s, buf1);
+    ntt_free(s, buf2);
+    return -1;
 }
 
 #else /* USE_FFT_MUL */
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index f5d42f2af0..500124c293 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -1,7 +1,7 @@
 /*
  * Tiny arbitrary precision floating point library
  * 
- * Copyright (c) 2017-2018 Fabrice Bellard
+ * Copyright (c) 2017-2020 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -44,6 +44,9 @@ typedef uint128_t dlimb_t;
 #define EXP_MIN INT64_MIN
 #define EXP_MAX INT64_MAX
 
+#define LIMB_DIGITS 19
+#define BF_DEC_BASE UINT64_C(10000000000000000000)
+
 #else
 
 typedef int32_t slimb_t;
@@ -52,6 +55,9 @@ typedef uint64_t dlimb_t;
 #define EXP_MIN INT32_MIN
 #define EXP_MAX INT32_MAX
 
+#define LIMB_DIGITS 9
+#define BF_DEC_BASE 1000000000U
+
 #endif
 
 /* in bits */
@@ -83,6 +89,15 @@ typedef struct {
     limb_t *tab;
 } bf_t;
 
+typedef struct {
+    /* must be kept identical to bf_t */
+    struct bf_context_t *ctx;
+    int sign;
+    slimb_t expn;
+    limb_t len;
+    limb_t *tab;
+} bfdec_t;
+
 typedef enum {
     BF_RNDN, /* round to nearest, ties to even */
     BF_RNDZ, /* round to zero */
@@ -94,12 +109,17 @@ typedef enum {
                 inexact flag is always set)  */
 } bf_rnd_t;
 
-/* allow subnormal numbers (only available if the number of exponent
-   bits is < BF_EXP_BITS_MAX and prec != BF_PREC_INF) */
+/* allow subnormal numbers. Only available if the number of exponent
+   bits is < BF_EXP_BITS_MAX and prec != BF_PREC_INF. Not supported
+   for decimal floating point numbers. */
 #define BF_FLAG_SUBNORMAL (1 << 3)
+/* 'prec' is the precision after the radix point instead of the whole
+   mantissa. Can only be used with bf_round(), bfdec_round() and
+   bfdev_div(). */
+#define BF_FLAG_RADPNT_PREC (1 << 4)
 
 #define BF_RND_MASK 0x7
-#define BF_EXP_BITS_SHIFT 4
+#define BF_EXP_BITS_SHIFT 5
 #define BF_EXP_BITS_MASK 0x3f
 
 /* contains the rounding mode and number of exponents bits */
@@ -136,8 +156,7 @@ static inline bf_flags_t bf_set_exp_bits(int n)
 #define BF_ST_OVERFLOW    (1 << 2)
 #define BF_ST_UNDERFLOW   (1 << 3)
 #define BF_ST_INEXACT     (1 << 4)
-/* not used yet, indicate that a memory allocation error occured. NaN
-   is returned */
+/* indicate that a memory allocation error occured. NaN is returned */
 #define BF_ST_MEM_ERROR   (1 << 5) 
 
 #define BF_RADIX_MAX 36 /* maximum radix for bf_atof() and bf_ftoa() */
@@ -169,13 +188,26 @@ static inline void *bf_realloc(bf_context_t *s, void *ptr, size_t size)
     return s->realloc_func(s->realloc_opaque, ptr, size);
 }
 
+/* 'size' must be != 0 */
+static inline void *bf_malloc(bf_context_t *s, size_t size)
+{
+    return bf_realloc(s, NULL, size);
+}
+
+static inline void bf_free(bf_context_t *s, void *ptr)
+{
+    /* must test ptr otherwise equivalent to malloc(0) */
+    if (ptr)
+        bf_realloc(s, ptr, 0);
+}
+
 void bf_init(bf_context_t *s, bf_t *r);
 
 static inline void bf_delete(bf_t *r)
 {
     bf_context_t *s = r->ctx;
     /* we accept to delete a zeroed bf_t structure */
-    if (s) {
+    if (s && r->tab) {
         bf_realloc(s, r->tab, 0);
     }
 }
@@ -200,15 +232,20 @@ static inline int bf_is_zero(const bf_t *a)
     return (a->expn == BF_EXP_ZERO);
 }
 
-void bf_set_ui(bf_t *r, uint64_t a);
-void bf_set_si(bf_t *r, int64_t a);
+static inline void bf_memcpy(bf_t *r, const bf_t *a)
+{
+    *r = *a;
+}
+
+int bf_set_ui(bf_t *r, uint64_t a);
+int bf_set_si(bf_t *r, int64_t a);
 void bf_set_nan(bf_t *r);
 void bf_set_zero(bf_t *r, int is_neg);
 void bf_set_inf(bf_t *r, int is_neg);
-void bf_set(bf_t *r, const bf_t *a);
+int bf_set(bf_t *r, const bf_t *a);
 void bf_move(bf_t *r, bf_t *a);
 int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode);
-void bf_set_float64(bf_t *a, double d);
+int bf_set_float64(bf_t *a, double d);
 
 int bf_cmpu(const bf_t *a, const bf_t *b);
 int bf_cmp_full(const bf_t *a, const bf_t *b);
@@ -233,46 +270,25 @@ int bf_remainder(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                  bf_flags_t flags);
 int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
               bf_flags_t flags);
-int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
-              bf_flags_t flags);
-int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b, limb_t prec, bf_flags_t flags);
-int bf_rint(bf_t *r, limb_t prec, bf_flags_t flags);
+/* round to integer with infinite precision */
+int bf_rint(bf_t *r, int rnd_mode);
 int bf_round(bf_t *r, limb_t prec, bf_flags_t flags);
 int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a);
 int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
 slimb_t bf_get_exp_min(const bf_t *a);
-void bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b);
-void bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b);
-void bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
+int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b);
+int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b);
+int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
 
 /* additional flags for bf_atof */
 /* do not accept hex radix prefix (0x or 0X) if radix = 0 or radix = 16 */
 #define BF_ATOF_NO_HEX       (1 << 16)
 /* accept binary (0b or 0B) or octal (0o or 0O) radix prefix if radix = 0 */
 #define BF_ATOF_BIN_OCT      (1 << 17)
-/* Only accept integers (no decimal point, no exponent, no infinity nor NaN */
-#define BF_ATOF_INT_ONLY     (1 << 18)
-/* Do not accept radix prefix after sign  */
-#define BF_ATOF_NO_PREFIX_AFTER_SIGN (1 << 19)
-/* Do not parse NaN and parse case sensitive 'Infinity' */
-#define BF_ATOF_JS_QUIRKS    (1 << 20)
-/* Do not round integers to the indicated precision */
-#define BF_ATOF_INT_PREC_INF (1 << 21)
-/* Support legacy octal syntax for well formed numbers */
-#define BF_ATOF_LEGACY_OCTAL (1 << 22)
-/* accept _ between digits as a digit separator */
-#define BF_ATOF_UNDERSCORE_SEP (1 << 23)
-/* if a 'n' suffix is present, force integer parsing (XXX: remove) */
-#define BF_ATOF_INT_N_SUFFIX   (1 << 24)
-/* only accept decimal floating point if radix = 0 */
-#define BF_ATOF_ONLY_DEC_FLOAT (1 << 26)
-
-/* additional return flags */
-/* indicate that the parsed number is an integer (only set when the
-   flags BF_ATOF_INT_PREC_INF or BF_ATOF_INT_N_SUFFIX are used) */
-#define BF_ATOF_ST_INTEGER   (1 << 5)
-/* integer parsed as legacy octal */
-#define BF_ATOF_ST_LEGACY_OCTAL (1 << 6)
+/* Do not parse NaN or Inf */
+#define BF_ATOF_NO_NAN_INF   (1 << 18)
+/* return the exponent separately */
+#define BF_ATOF_EXPONENT       (1 << 19)
 
 int bf_atof(bf_t *a, const char *str, const char **pnext, int radix,
             limb_t prec, bf_flags_t flags);
@@ -284,10 +300,18 @@ int bf_atof2(bf_t *r, slimb_t *pexponent,
 int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
                      slimb_t expn, limb_t prec, bf_flags_t flags);
 
+
+/* Conversion of floating point number to string. Return a null
+   terminated string or NULL if memory error. *plen contains its
+   length if plen != NULL.  The exponent letter is "e" for base 10,
+   "p" for bases 2, 8, 16 with the binary exponent and "@" for the
+   other bases. */
+
 #define BF_FTOA_FORMAT_MASK (3 << 16)
+
 /* fixed format: prec significant digits rounded with (flags &
    BF_RND_MASK). Exponential notation is used if too many zeros are
-   needed. */
+   needed.*/
 #define BF_FTOA_FORMAT_FIXED (0 << 16)
 /* fractional format: prec digits after the decimal point rounded with
    (flags & BF_RND_MASK) */
@@ -310,10 +334,12 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
 /* add 0x prefix for base 16, 0o prefix for base 8 or 0b prefix for
    base 2 if non zero value */
 #define BF_FTOA_ADD_PREFIX   (1 << 21)
+/* return "Infinity" instead of "Inf" and add a "+" for positive
+   exponents */
 #define BF_FTOA_JS_QUIRKS    (1 << 22)
 
-size_t bf_ftoa(char **pbuf, const bf_t *a, int radix, limb_t prec,
-               bf_flags_t flags);
+char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
+              bf_flags_t flags);
 
 /* modulo 2^n instead of saturation. NaN and infinity return 0 */
 #define BF_GET_INT_MOD (1 << 0) 
@@ -321,15 +347,23 @@ int bf_get_int32(int *pres, const bf_t *a, int flags);
 int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
 
 /* the following functions are exported for testing only. */
+void mp_print_str(const char *str, const limb_t *tab, limb_t n);
 void bf_print_str(const char *str, const bf_t *a);
-void bf_resize(bf_t *r, limb_t len);
+int bf_resize(bf_t *r, limb_t len);
 int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len);
-void bf_recip(bf_t *r, const bf_t *a, limb_t prec);
-void bf_rsqrt(bf_t *a, const bf_t *x, limb_t prec);
 int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags);
 int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k);
 slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
                           int is_ceil1);
+int mp_mul(bf_context_t *s, limb_t *result, 
+           const limb_t *op1, limb_t op1_size, 
+           const limb_t *op2, limb_t op2_size);
+limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
+              limb_t n, limb_t carry);
+limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n);
+int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n);
+int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n);
+limb_t bf_isqrt(limb_t a);
 
 /* transcendental functions */
 int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags);
@@ -347,4 +381,119 @@ int bf_atan2(bf_t *r, const bf_t *y, const bf_t *x,
 int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
 int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
 
+/* decimal floating point */
+
+static inline void bfdec_init(bf_context_t *s, bfdec_t *r)
+{
+    bf_init(s, (bf_t *)r);
+}
+static inline void bfdec_delete(bfdec_t *r)
+{
+    bf_delete((bf_t *)r);
+}
+
+static inline void bfdec_neg(bfdec_t *r)
+{
+    r->sign ^= 1;
+}
+
+static inline int bfdec_is_finite(const bfdec_t *a)
+{
+    return (a->expn < BF_EXP_INF);
+}
+
+static inline int bfdec_is_nan(const bfdec_t *a)
+{
+    return (a->expn == BF_EXP_NAN);
+}
+
+static inline int bfdec_is_zero(const bfdec_t *a)
+{
+    return (a->expn == BF_EXP_ZERO);
+}
+
+static inline void bfdec_memcpy(bfdec_t *r, const bfdec_t *a)
+{
+    bf_memcpy((bf_t *)r, (const bf_t *)a);
+}
+
+int bfdec_set_ui(bfdec_t *r, uint64_t a);
+int bfdec_set_si(bfdec_t *r, int64_t a);
+
+static inline void bfdec_set_nan(bfdec_t *r)
+{
+    bf_set_nan((bf_t *)r);
+}
+static inline void bfdec_set_zero(bfdec_t *r, int is_neg)
+{
+    bf_set_zero((bf_t *)r, is_neg);
+}
+static inline void bfdec_set_inf(bfdec_t *r, int is_neg)
+{
+    bf_set_inf((bf_t *)r, is_neg);
+}
+static inline int bfdec_set(bfdec_t *r, const bfdec_t *a)
+{
+    return bf_set((bf_t *)r, (bf_t *)a);
+}
+static inline void bfdec_move(bfdec_t *r, bfdec_t *a)
+{
+    bf_move((bf_t *)r, (bf_t *)a);
+}
+static inline int bfdec_cmpu(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmpu((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_full(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp_full((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_eq(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp_eq((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_le(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp_le((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_lt(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp_lt((const bf_t *)a, (const bf_t *)b);
+}
+
+int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags);
+int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags);
+int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
+                 limb_t prec, bf_flags_t flags, int rnd_mode);
+int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+               bf_flags_t flags);
+int bfdec_rint(bfdec_t *r, int rnd_mode);
+int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags);
+int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags);
+int bfdec_get_int32(int *pres, const bfdec_t *a);
+int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b);
+
+char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags);
+int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
+               limb_t prec, bf_flags_t flags);
+
+/* the following functions are exported for testing only. */
+extern limb_t mp_pow_dec[LIMB_DIGITS + 1];
+void bfdec_print_str(const char *str, const bfdec_t *a);
+static inline int bfdec_resize(bfdec_t *r, limb_t len)
+{
+    return bf_resize((bf_t *)r, len);
+}
+int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags);
+
 #endif /* LIBBF_H */
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 233294c6cd..92042d2735 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -170,6 +170,10 @@ DEF(globalThis, "globalThis")
 #ifdef CONFIG_BIGNUM
 DEF(bigint, "bigint")
 DEF(bigfloat, "bigfloat")
+DEF(bigdecimal, "bigdecimal")
+DEF(roundingMode, "roundingMode")
+DEF(maximumSignificantDigits, "maximumSignificantDigits")
+DEF(maximumFractionDigits, "maximumFractionDigits")
 #endif
 #ifdef CONFIG_ATOMICS
 DEF(not_equal, "not-equal")
@@ -214,6 +218,7 @@ DEF(DataView, "DataView")
 DEF(BigInt, "BigInt")
 DEF(BigFloat, "BigFloat")
 DEF(BigFloatEnv, "BigFloatEnv")
+DEF(BigDecimal, "BigDecimal")
 #endif
 DEF(Map, "Map")
 DEF(Set, "Set") /* Map + 1 */
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index aad1692c16..da53fefc18 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -1,8 +1,8 @@
 /*
  * QuickJS C library
  * 
- * Copyright (c) 2017-2019 Fabrice Bellard
- * Copyright (c) 2017-2019 Charlie Gordon
+ * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2020 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 76f68d6053..646af8aacc 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -1,8 +1,8 @@
 /*
  * QuickJS Javascript Engine
  * 
- * Copyright (c) 2017-2019 Fabrice Bellard
- * Copyright (c) 2017-2019 Charlie Gordon
+ * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2020 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -42,6 +42,10 @@
 #include "list.h"
 #include "quickjs.h"
 #include "libregexp.h"
+
+/* enable bignums */
+#define CONFIG_BIGNUM
+
 #ifdef CONFIG_BIGNUM
 #include "libbf.h"
 #endif
@@ -147,6 +151,7 @@ enum {
     JS_CLASS_BIG_INT,           /* u.object_data */
     JS_CLASS_BIG_FLOAT,         /* u.object_data */
     JS_CLASS_FLOAT_ENV,         /* u.float_env */
+    JS_CLASS_BIG_DECIMAL,         /* u.object_data */
 #endif
     JS_CLASS_MAP,               /* u.map_state */
     JS_CLASS_SET,               /* u.map_state */
@@ -205,6 +210,28 @@ typedef enum {
     JS_GC_PHASE_REMOVE_CYCLES,
 } JSGCPhaseEnum;
 
+typedef enum OPCodeEnum OPCodeEnum;
+
+#ifdef CONFIG_BIGNUM
+/* function pointers are used for numeric operations so that it is
+   possible to remove some numeric types */
+typedef struct {
+    JSValue (*to_string)(JSContext *ctx, JSValueConst val);
+    JSValue (*from_string)(JSContext *ctx, const char *buf,
+                           int radix, int flags, slimb_t *pexponent);
+    int (*unary_arith)(JSContext *ctx,
+                       JSValue *pres, OPCodeEnum op, JSValue op1);
+    int (*binary_arith)(JSContext *ctx, OPCodeEnum op,
+                        JSValue *pres, JSValue op1, JSValue op2);
+    int (*compare)(JSContext *ctx, OPCodeEnum op,
+                   JSValue op1, JSValue op2);
+    /* only for bigfloat: */
+    JSValue (*mul_pow10_to_float64)(JSContext *ctx, const bf_t *a,
+                                    int64_t exponent);
+    int (*mul_pow10)(JSContext *ctx, JSValue *sp);
+} JSNumericOperations;
+#endif
+
 struct JSRuntime {
     JSMallocFunctions mf;
     JSMallocState malloc_state;
@@ -255,6 +282,9 @@ struct JSRuntime {
     JSShape **shape_hash;
 #ifdef CONFIG_BIGNUM
     bf_context_t bf_ctx;
+    JSNumericOperations bigint_ops;
+    JSNumericOperations bigfloat_ops;
+    JSNumericOperations bigdecimal_ops;
 #endif
 };
 
@@ -343,6 +373,11 @@ typedef struct JSBigFloat {
     JSRefCountHeader header; /* must come first, 32-bit */
     bf_t num;
 } JSBigFloat;
+
+typedef struct JSBigDecimal {
+    JSRefCountHeader header; /* must come first, 32-bit */
+    bfdec_t num;
+} JSBigDecimal;
 #endif
 
 /* must be large enough to have a negligible runtime cost and small
@@ -384,6 +419,8 @@ struct JSContext {
 #ifdef CONFIG_BIGNUM
     bf_context_t *bf_ctx;   /* points to rt->bf_ctx, shared by all contexts */
     JSFloatEnv fp_env; /* global FP environment */
+    BOOL bignum_ext; /* enable bigint mode, math mode and operator
+                        overloading */
 #endif
     /* when the counter reaches zero, JSRutime.interrupt_handler is called */
     int interrupt_counter;
@@ -846,7 +883,7 @@ typedef enum OPCodeFormat {
 #undef FMT
 } OPCodeFormat;
 
-typedef enum OPCodeEnum {
+enum OPCodeEnum {
 #define FMT(f)
 #define DEF(id, size, n_pop, n_push, f) OP_ ## id,
 #define def(id, size, n_pop, n_push, f)
@@ -866,7 +903,7 @@ typedef enum OPCodeEnum {
 #undef DEF
 #undef FMT
     OP_TEMP_END,
-} OPCodeEnum;
+};
 
 static int JS_InitAtoms(JSRuntime *rt);
 static JSAtom __JS_NewAtomInit(JSRuntime *rt, const char *str, int len,
@@ -985,11 +1022,16 @@ static JSProperty *add_property(JSContext *ctx,
 #ifdef CONFIG_BIGNUM
 static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
 static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a);
+static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a);
 static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint);
 static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a);
 static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
-static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
-                           JSValueConst val);
+static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
+static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
+static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val);
+static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
+                                   BOOL allow_null_or_undefined);
+static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val);
 #endif
 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
 static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx);
@@ -1084,6 +1126,7 @@ static JSClassID js_class_id_alloc = JS_CLASS_INIT_COUNT;
 JS_BOOL JS_IsNumber(JSValueConst v)
 {
 #ifdef CONFIG_BIGNUM
+    /* XXX: check the bignum case. Should use a different function */
     int tag = JS_VALUE_GET_TAG(v);
     return tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
         tag == JS_TAG_BIG_FLOAT || JS_TAG_IS_FLOAT64(tag);
@@ -1289,6 +1332,7 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_BigInt, js_object_data_finalizer, js_object_data_mark },      /* JS_CLASS_BIG_INT */
     { JS_ATOM_BigFloat, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_FLOAT */
     { JS_ATOM_BigFloatEnv, js_float_env_finalizer, NULL },      /* JS_CLASS_FLOAT_ENV */
+    { JS_ATOM_BigDecimal, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_DECIMAL */
 #endif
     { JS_ATOM_Map, js_map_finalizer, js_map_mark },             /* JS_CLASS_MAP */
     { JS_ATOM_Set, js_map_finalizer, js_map_mark },             /* JS_CLASS_SET */
@@ -1319,6 +1363,64 @@ static int init_class_range(JSRuntime *rt, JSClassShortDef const *tab,
     return 0;
 }
 
+#ifdef CONFIG_BIGNUM
+static JSValue JS_ThrowUnsupportedOperation(JSContext *ctx)
+{
+    return JS_ThrowTypeError(ctx, "unsupported operation");
+}
+
+static JSValue invalid_to_string(JSContext *ctx, JSValueConst val)
+{
+    return JS_ThrowUnsupportedOperation(ctx);
+}
+
+static JSValue invalid_from_string(JSContext *ctx, const char *buf,
+                                   int radix, int flags, slimb_t *pexponent)
+{
+    return JS_NAN;
+}
+
+static int invalid_unary_arith(JSContext *ctx,
+                               JSValue *pres, OPCodeEnum op, JSValue op1)
+{
+    JS_FreeValue(ctx, op1);
+    JS_ThrowUnsupportedOperation(ctx);
+    return -1;
+}
+
+static int invalid_binary_arith(JSContext *ctx, OPCodeEnum op,
+                                JSValue *pres, JSValue op1, JSValue op2)
+{
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    JS_ThrowUnsupportedOperation(ctx);
+    return -1;
+}
+
+static JSValue invalid_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
+                                            int64_t exponent)
+{
+    return JS_ThrowUnsupportedOperation(ctx);
+}
+
+static int invalid_mul_pow10(JSContext *ctx, JSValue *sp)
+{
+    JS_ThrowUnsupportedOperation(ctx);
+    return -1;
+}
+
+static void set_dummy_numeric_ops(JSNumericOperations *ops)
+{
+    ops->to_string = invalid_to_string;
+    ops->from_string = invalid_from_string;
+    ops->unary_arith = invalid_unary_arith;
+    ops->binary_arith = invalid_binary_arith;
+    ops->mul_pow10_to_float64 = invalid_mul_pow10_to_float64;
+    ops->mul_pow10 = invalid_mul_pow10;
+}
+
+#endif /* CONFIG_BIGNUM */
+
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
 {
     JSRuntime *rt;
@@ -1342,6 +1444,9 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
 
 #ifdef CONFIG_BIGNUM
     bf_context_init(&rt->bf_ctx, js_bf_realloc, rt);
+    set_dummy_numeric_ops(&rt->bigint_ops);
+    set_dummy_numeric_ops(&rt->bigfloat_ops);
+    set_dummy_numeric_ops(&rt->bigdecimal_ops);
 #endif
 
     init_list_head(&rt->context_list);
@@ -1860,8 +1965,8 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
     ctx->current_exception = JS_NULL;
 #ifdef CONFIG_BIGNUM
     ctx->bf_ctx = &rt->bf_ctx;
-    ctx->fp_env.prec = 53;
-    ctx->fp_env.flags = bf_set_exp_bits(11) | BF_RNDN | BF_FLAG_SUBNORMAL;
+    ctx->fp_env.prec = 113;
+    ctx->fp_env.flags = bf_set_exp_bits(15) | BF_RNDN | BF_FLAG_SUBNORMAL;
 #endif
     for(i = 0; i < rt->class_count; i++)
         ctx->class_proto[i] = JS_NULL;
@@ -1891,7 +1996,9 @@ JSContext *JS_NewContext(JSRuntime *rt)
     JS_AddIntrinsicMapSet(ctx);
     JS_AddIntrinsicTypedArrays(ctx);
     JS_AddIntrinsicPromise(ctx);
-
+#ifdef CONFIG_BIGNUM
+    JS_AddIntrinsicBigInt(ctx);
+#endif
     return ctx;
 }
 
@@ -2029,7 +2136,7 @@ static inline BOOL is_strict_mode(JSContext *ctx)
 }
 
 #ifdef CONFIG_BIGNUM
-static inline BOOL is_bignum_mode(JSContext *ctx)
+static inline BOOL is_bigint_mode(JSContext *ctx)
 {
     JSStackFrame *sf = ctx->current_stack_frame;
     return (sf && (sf->js_mode & JS_MODE_BIGINT));
@@ -2042,7 +2149,7 @@ JSValue JS_NewInt64(JSContext *ctx, int64_t v)
         return JS_NewInt32(ctx, v);
     } else {
 #ifdef CONFIG_BIGNUM
-        if (is_bignum_mode(ctx)) {
+        if (is_bigint_mode(ctx)) {
             bf_t a_s, *a = &a_s;
             bf_init(ctx->bf_ctx, a);
             bf_set_si(a, v);
@@ -4410,6 +4517,7 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
 #ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT:
     case JS_CLASS_BIG_FLOAT:
+    case JS_CLASS_BIG_DECIMAL:
 #endif
         p->u.object_data = JS_UNDEFINED;
         goto set_exotic;
@@ -4472,6 +4580,7 @@ static JSValue JS_GetObjectData(JSContext *ctx, JSValueConst obj)
 #ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:
         case JS_CLASS_BIG_FLOAT:
+        case JS_CLASS_BIG_DECIMAL:
 #endif
             return JS_DupValue(ctx, p->u.object_data);
         }
@@ -4495,6 +4604,7 @@ static int JS_SetObjectData(JSContext *ctx, JSValueConst obj, JSValue val)
 #ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:
         case JS_CLASS_BIG_FLOAT:
+        case JS_CLASS_BIG_DECIMAL:
 #endif
             JS_FreeValue(ctx, p->u.object_data);
             p->u.object_data = val;
@@ -5089,6 +5199,13 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v)
             js_free_rt(rt, bf);
         }
         break;
+    case JS_TAG_BIG_DECIMAL:
+        {
+            JSBigDecimal *bf = JS_VALUE_GET_PTR(v);
+            bfdec_delete(&bf->num);
+            js_free_rt(rt, bf);
+        }
+        break;
 #endif
     case JS_TAG_SYMBOL:
         {
@@ -5473,6 +5590,7 @@ static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp)
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
     case JS_TAG_BIG_FLOAT:
+    case JS_TAG_BIG_DECIMAL:
         /* should track JSBigFloat usage */
         break;
 #endif
@@ -6172,7 +6290,8 @@ static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
 
     /* the backtrace is added later if called from a bytecode function */
     sf = ctx->current_stack_frame;
-    add_backtrace = !sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL);
+    add_backtrace = !ctx->in_out_of_memory &&
+        (!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
     return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
 }
 
@@ -6397,7 +6516,7 @@ JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val)
         val = ctx->class_proto[JS_CLASS_BIG_INT];
         break;
     case JS_TAG_INT:
-        if (is_bignum_mode(ctx)) {
+        if (is_bigint_mode(ctx)) {
             val = ctx->class_proto[JS_CLASS_BIG_INT];
         } else {
             val = ctx->class_proto[JS_CLASS_NUMBER];
@@ -6409,6 +6528,9 @@ JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val)
     case JS_TAG_BIG_FLOAT:
         val = ctx->class_proto[JS_CLASS_BIG_FLOAT];
         break;
+    case JS_TAG_BIG_DECIMAL:
+        val = ctx->class_proto[JS_CLASS_BIG_DECIMAL];
+        break;
 #else
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
@@ -9348,6 +9470,14 @@ static int JS_ToBoolFree(JSContext *ctx, JSValue val)
             JS_FreeValue(ctx, val);
             return ret;
         }
+    case JS_TAG_BIG_DECIMAL:
+        {
+            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+            BOOL ret;
+            ret = p->num.expn != BF_EXP_ZERO && p->num.expn != BF_EXP_NAN;
+            JS_FreeValue(ctx, val);
+            return ret;
+        }
 #endif
     default:
         if (JS_TAG_IS_FLOAT64(tag)) {
@@ -9387,54 +9517,6 @@ static int skip_spaces(const char *pc)
     return p - p_start;
 }
 
-#ifdef CONFIG_BIGNUM
-
-/* force big int type if integer result */
-#define BF_ATOF_BIG_INT     (1 << 30)
-/* return JS_EXCEPTION if invalid syntax. Otherwise return NaN */
-#define BF_ATOF_THROW       (1 << 29)
-#define BF_ATOF_FLOAT64     (1 << 28)
-
-static JSValue js_atof(JSContext *ctx, const char *p, const char **pp,
-                       int radix, int flags)
-{
-    bf_t a_s, *a = &a_s;
-    int res;
-    slimb_t prec;
-    JSValue val;
-
-    bf_init(ctx->bf_ctx, a);
-    if (flags & BF_ATOF_FLOAT64) {
-        prec = 53;
-        flags |= bf_set_exp_bits(11) | BF_RNDN | BF_FLAG_SUBNORMAL;
-    } else {
-        /* use the current precision */
-        prec = ctx->fp_env.prec;
-        flags |= ctx->fp_env.flags;
-    }
-    res = bf_atof(a, p, &p, radix, prec, flags);
-    if ((flags & BF_ATOF_THROW) && bf_is_nan(a)) {
-        bf_delete(a);
-        return JS_EXCEPTION;
-    }
-    if (res & BF_ATOF_ST_INTEGER) {
-        val = JS_NewBigInt2(ctx, a, (flags & BF_ATOF_BIG_INT) != 0);
-    } else if (flags & BF_ATOF_FLOAT64) {
-        double d;
-        bf_get_float64(a, &d, BF_RNDN);
-        bf_delete(a);
-        /* return int or float64 */
-        val = JS_NewFloat64(ctx, d);
-    } else {
-        val = JS_NewBigFloat(ctx, a);
-    }
-    if (pp)
-        *pp = p;
-    return val;
-}
-
-#else
-
 static inline int to_digit(int c)
 {
     if (c >= '0' && c <= '9')
@@ -9447,42 +9529,166 @@ static inline int to_digit(int c)
         return 36;
 }
 
+/* XXX: remove */
+static double js_strtod(const char *p, int radix, BOOL is_float)
+{
+    double d;
+    int c;
+    
+    if (!is_float || radix != 10) {
+        uint64_t n_max, n;
+        int int_exp, is_neg;
+        
+        is_neg = 0;
+        if (*p == '-') {
+            is_neg = 1;
+            p++;
+        }
+
+        /* skip leading zeros */
+        while (*p == '0')
+            p++;
+        n = 0;
+        if (radix == 10)
+            n_max = ((uint64_t)-1 - 9) / 10; /* most common case */
+        else
+            n_max = ((uint64_t)-1 - (radix - 1)) / radix;
+        /* XXX: could be more precise */
+        int_exp = 0;
+        while (*p != '\0') {
+            c = to_digit((uint8_t)*p);
+            if (c >= radix)
+                break;
+            if (n <= n_max) {
+                n = n * radix + c;
+            } else {
+                int_exp++;
+            }
+            p++;
+        }
+        d = n;
+        if (int_exp != 0) {
+            d *= pow(radix, int_exp);
+        }
+        if (is_neg)
+            d = -d;
+    } else {
+        d = strtod(p, NULL);
+    }
+    return d;
+}
+
 #define ATOD_INT_ONLY        (1 << 0)
-/* return JS_EXCEPTION if invalid syntax. Otherwise return NaN */
-#define ATOD_THROW           (1 << 1)
 /* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
 #define ATOD_ACCEPT_BIN_OCT  (1 << 2)
 /* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
 #define ATOD_ACCEPT_LEGACY_OCTAL  (1 << 4)
 /* accept _ between digits as a digit separator */
 #define ATOD_ACCEPT_UNDERSCORES  (1 << 5)
+/* allow a suffix to override the type */
+#define ATOD_ACCEPT_SUFFIX    (1 << 6) 
+/* default type */
+#define ATOD_TYPE_MASK        (3 << 7)
+#define ATOD_TYPE_FLOAT64     (0 << 7)
+#define ATOD_TYPE_BIG_INT     (1 << 7)
+#define ATOD_TYPE_BIG_FLOAT   (2 << 7)
+#define ATOD_TYPE_BIG_DECIMAL (3 << 7)
+/* assume bigint mode: floats are parsed as integers if no decimal
+   point nor exponent */
+#define ATOD_MODE_BIGINT      (1 << 9) 
+/* accept -0x1 */
+#define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
-/* radix = 0 accepts prefixes. radix = 16 also
-   accepts 0x prefix. radix must be 0 or between 2 and 36 */
-static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
-                       int radix, int flags)
+#ifdef CONFIG_BIGNUM
+static JSValue js_string_to_bigint(JSContext *ctx, const char *buf,
+                                   int radix, int flags, slimb_t *pexponent)
 {
-    const char *p;
-    const char *p_start;
-    int is_neg, c, sep;
-    double d;
+    bf_t a_s, *a = &a_s;
+    int ret;
+    bf_init(ctx->bf_ctx, a);
+    ret = bf_atof(a, buf, NULL, radix, BF_PREC_INF, BF_RNDZ);
+    if (ret & BF_ST_MEM_ERROR) {
+        bf_delete(a);
+        return JS_ThrowOutOfMemory(ctx);
+    }
+    return JS_NewBigInt2(ctx, a, !(flags & ATOD_MODE_BIGINT));
+}
+
+static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
+                                     int radix, int flags, slimb_t *pexponent)
+{
+    bf_t a_s, *a = &a_s;
+    int ret;
+
+    bf_init(ctx->bf_ctx, a);
+    if (flags & ATOD_ACCEPT_SUFFIX) {
+        /* return the exponent to get infinite precision */
+        ret = bf_atof2(a, pexponent, buf, NULL, radix, BF_PREC_INF,
+                       BF_RNDZ | BF_ATOF_EXPONENT);
+    } else {
+        ret = bf_atof(a, buf, NULL, radix, ctx->fp_env.prec,
+                      ctx->fp_env.flags);
+    }
+    if (ret & BF_ST_MEM_ERROR) {
+        bf_delete(a);
+        return JS_ThrowOutOfMemory(ctx);
+    }
+    return JS_NewBigFloat(ctx, a);
+}
+
+static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
+                                       int radix, int flags, slimb_t *pexponent)
+{
+    bfdec_t a_s, *a = &a_s;
+    int ret;
+    bfdec_init(ctx->bf_ctx, a);
+    ret = bfdec_atof(a, buf, NULL, BF_PREC_INF,
+                     BF_RNDZ | BF_ATOF_NO_NAN_INF);
+    if (ret & BF_ST_MEM_ERROR) {
+        bfdec_delete(a);
+        return JS_ThrowOutOfMemory(ctx);
+    }
+    return JS_NewBigDecimal(ctx, a);
+}
 
+#endif
+
+/* return an exception in case of memory error. Return JS_NAN if
+   invalid syntax */
+#ifdef CONFIG_BIGNUM
+static JSValue js_atof2(JSContext *ctx, const char *str, const char **pp,
+                        int radix, int flags, slimb_t *pexponent)
+#else
+static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
+                       int radix, int flags)
+#endif
+{
+    const char *p, *p_start;
+    int sep, is_neg;
+    BOOL is_float, has_legacy_octal;
+    int atod_type = flags & ATOD_TYPE_MASK;
+    char buf1[64], *buf;
+    int i, j, len;
+    BOOL buf_allocated = FALSE;
+    JSValue val;
+    
     /* optional separator between digits */
     sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
-
+    has_legacy_octal = FALSE;
+    
     p = str;
     p_start = p;
     is_neg = 0;
     if (p[0] == '+') {
         p++;
         p_start++;
-        if (!(flags & ATOD_INT_ONLY))
+        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
             goto no_radix_prefix;
     } else if (p[0] == '-') {
-        is_neg = 1;
         p++;
         p_start++;
-        if (!(flags & ATOD_INT_ONLY))
+        is_neg = 1;
+        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
             goto no_radix_prefix;
     }
     if (p[0] == '0') {
@@ -9501,6 +9707,7 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
         } else if ((p[1] >= '0' && p[1] <= '9') &&
                    radix == 0 && (flags & ATOD_ACCEPT_LEGACY_OCTAL)) {
             int i;
+            has_legacy_octal = TRUE;
             sep = 256;
             for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
                 continue;
@@ -9517,58 +9724,50 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
     no_prefix: ;
     } else {
  no_radix_prefix:
-        if (!(flags & ATOD_INT_ONLY) && strstart(p, "Infinity", &p)) {
-            d = 1.0 / 0.0;
+        if (!(flags & ATOD_INT_ONLY) &&
+            (atod_type == ATOD_TYPE_FLOAT64 ||
+             atod_type == ATOD_TYPE_BIG_FLOAT) &&
+            strstart(p, "Infinity", &p)) {
+#ifdef CONFIG_BIGNUM
+            if (atod_type == ATOD_TYPE_BIG_FLOAT) {
+                bf_t a_s, *a = &a_s;
+                bf_init(ctx->bf_ctx, a);
+                bf_set_inf(a, is_neg);
+                val = JS_NewBigFloat(ctx, a);
+            } else
+#endif
+            {
+                double d = 1.0 / 0.0;
+                if (is_neg)
+                    d = -d;
+                val = JS_NewFloat64(ctx, d);
+            }
             goto done;
         }
     }
     if (radix == 0)
         radix = 10;
-    if ((flags & ATOD_INT_ONLY) || radix != 10) {
-        uint64_t n_max, n;
-        int int_exp;
-
-        /* skip leading zeros */
-        while (*p == '0')
-            p++;
-        n = 0;
-        if (radix == 10)
-            n_max = ((uint64_t)-1 - 9) / 10; /* most common case */
-        else
-            n_max = ((uint64_t)-1 - (radix - 1)) / radix;
-        /* XXX: could be more precise */
-        int_exp = 0;
-        while (*p != '\0') {
-            if (*p == sep && to_digit(p[1]) < radix)
-                p++;
-            c = to_digit((uint8_t)*p);
-            if (c >= radix)
-                break;
-            if (n <= n_max) {
-                n = n * radix + c;
-            } else {
-                int_exp++;
-            }
-            p++;
-        }
-        d = n;
-        if (int_exp != 0) {
-            d *= pow(radix, int_exp);
-        }
-    } else {
-        p_start = p;
-        while (is_digit((uint8_t)*p)
-           ||  (*p == sep && (p != p_start + 1 || p[-1] != '0') &&
-               is_digit((uint8_t)p[1]))) {
-            p++;
-        }
-        if (*p == '.' && (p > p_start || is_digit((uint8_t)p[1]))) {
+    is_float = FALSE;
+    p_start = p;
+    while (to_digit((uint8_t)*p) < radix
+           ||  (*p == sep && (radix != 10 ||
+                              p != p_start + 1 || p[-1] != '0') &&
+                to_digit((uint8_t)p[1]) < radix)) {
+        p++;
+    }
+    if (!(flags & ATOD_INT_ONLY)) {
+        if (*p == '.' && (p > p_start || to_digit((uint8_t)p[1]) < radix)) {
+            is_float = TRUE;
             p++;
-            while (is_digit((uint8_t)*p) || (*p == sep && is_digit((uint8_t)p[1])))
+            while (to_digit((uint8_t)*p) < radix ||
+                   (*p == sep && to_digit((uint8_t)p[1]) < radix))
                 p++;
         }
-        if (p > p_start && (*p == 'e' || *p == 'E')) {
+        if (p > p_start &&
+            (((*p == 'e' || *p == 'E') && radix == 10) ||
+             ((*p == 'p' || *p == 'P') && (radix == 2 || radix == 8 || radix == 16)))) {
             const char *p1 = p + 1;
+            is_float = TRUE;
             if (*p1 == '+') {
                 p1++;
             } else if (*p1 == '-') {
@@ -9580,48 +9779,123 @@ static JSValue js_atod(JSContext *ctx, const char *str, const char **pp,
                     p++;
             }
         }
-        if (*p == '\0' && sep != '_') {
-            d = strtod(p_start, NULL);
+    }
+    if (p == p_start)
+        goto fail;
+
+    buf = buf1;
+    buf_allocated = FALSE;
+    len = p - p_start;
+    if (unlikely((len + 2) > sizeof(buf1))) {
+        buf = js_malloc_rt(ctx->rt, len + 2); /* no exception raised */
+        if (!buf)
+            goto mem_error;
+        buf_allocated = TRUE;
+    }
+    /* remove the separators and the radix prefixes */
+    j = 0;
+    if (is_neg)
+        buf[j++] = '-';
+    for (i = 0; i < len; i++) {
+        if (p_start[i] != '_')
+            buf[j++] = p_start[i];
+    }
+    buf[j] = '\0';
+
+#ifdef CONFIG_BIGNUM
+    if (flags & ATOD_ACCEPT_SUFFIX) {
+        if (*p == 'n') {
+            p++;
+            atod_type = ATOD_TYPE_BIG_INT;
+        } else if (*p == 'l') {
+            p++;
+            atod_type = ATOD_TYPE_BIG_FLOAT;
+        } else if (*p == 'd') {
+            p++;
+            atod_type = ATOD_TYPE_BIG_DECIMAL;
         } else {
-            char buf1[64], *buf;
-            int i, j, len;
-            BOOL buf_allocated;
-
-            buf = buf1;
-            buf_allocated = FALSE;
-            len = p - p_start;
-            if (len >= sizeof(buf1)) {
-                buf = js_malloc(ctx, len + 1);
-                if (!buf)
-                    return JS_EXCEPTION;
-                buf_allocated = TRUE;
+            if (flags & ATOD_MODE_BIGINT) {
+                if (!is_float)
+                    atod_type = ATOD_TYPE_BIG_INT;
+                if (has_legacy_octal)
+                    goto fail;
+            } else {
+                if (is_float && radix != 10)
+                    goto fail;
             }
-            for (i = j = 0; i < len; i++) {
-                if (p_start[i] != '_')
-                    buf[j++] = p_start[i];
+        }
+    } else {
+        if (atod_type == ATOD_TYPE_FLOAT64) {
+            if (flags & ATOD_MODE_BIGINT) {
+                if (!is_float)
+                    atod_type = ATOD_TYPE_BIG_INT;
+                if (has_legacy_octal)
+                    goto fail;
+            } else {
+                if (is_float && radix != 10)
+                    goto fail;
             }
-            buf[j] = '\0';
-            d = strtod(buf, NULL);
-            if (buf_allocated)
-                js_free(ctx, buf);
         }
     }
-done:
-    if (p == p_start) {
-        d = JS_FLOAT64_NAN;
-    } else if (is_neg) {
-        d = -d;
+
+    switch(atod_type) {
+    case ATOD_TYPE_FLOAT64:
+        {
+            double d;
+            d = js_strtod(buf, radix, is_float);
+            /* return int or float64 */
+            val = JS_NewFloat64(ctx, d);
+        }
+        break;
+    case ATOD_TYPE_BIG_INT:
+        if (has_legacy_octal || is_float)
+            goto fail;
+        val = ctx->rt->bigint_ops.from_string(ctx, buf, radix, flags, NULL);
+        break;
+    case ATOD_TYPE_BIG_FLOAT:
+        if (has_legacy_octal)
+            goto fail;
+        val = ctx->rt->bigfloat_ops.from_string(ctx, buf, radix, flags,
+                                                pexponent);
+        break;
+    case ATOD_TYPE_BIG_DECIMAL:
+        if (radix != 10)
+            goto fail;
+        val = ctx->rt->bigdecimal_ops.from_string(ctx, buf, radix, flags, NULL);
+        break;
+    default:
+        abort();
     }
+#else
+    {
+        double d;
+        (void)has_legacy_octal;
+        if (is_float && radix != 10)
+            goto fail;
+        d = js_strtod(buf, radix, is_float);
+        val = JS_NewFloat64(ctx, d);
+    }
+#endif
+    
+done:
+    if (buf_allocated)
+        js_free_rt(ctx->rt, buf);
     if (pp)
         *pp = p;
-    return JS_NewFloat64(ctx, d);
+    return val;
  fail:
-    if (pp)
-        *pp = p;
-    if (flags & ATOD_THROW)
-        return JS_EXCEPTION;
-    else
-        return JS_NAN;
+    val = JS_NAN;
+    goto done;
+ mem_error:
+    val = JS_ThrowOutOfMemory(ctx);
+    goto done;
+}
+
+#ifdef CONFIG_BIGNUM
+static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
+                       int radix, int flags)
+{
+    return js_atof2(ctx, str, pp, radix, flags, NULL);
 }
 #endif
 
@@ -9642,8 +9916,15 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
 #ifdef CONFIG_BIGNUM
+    case JS_TAG_BIG_DECIMAL:
+        if (flag != TON_FLAG_NUMERIC) {
+            JS_FreeValue(ctx, val);
+            return JS_ThrowTypeError(ctx, "cannot convert bigdecimal to number");
+        }
+        ret = val;
+        break;
     case JS_TAG_BIG_INT:
-        if (flag == TON_FLAG_NUMBER && !is_bignum_mode(ctx)) {
+        if (flag == TON_FLAG_NUMBER && !is_bigint_mode(ctx)) {
             JS_FreeValue(ctx, val);
             return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
         }
@@ -9687,24 +9968,18 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
             if ((p - str) == len) {
                 ret = JS_NewInt32(ctx, 0);
             } else {
+                int flags = ATOD_ACCEPT_BIN_OCT;
 #ifdef CONFIG_BIGNUM
-                {
-                    int flags;
-                    flags = BF_ATOF_BIN_OCT | BF_ATOF_NO_PREFIX_AFTER_SIGN |
-                        BF_ATOF_JS_QUIRKS | BF_ATOF_FLOAT64;
-                    if (is_bignum_mode(ctx))
-                        flags |= BF_ATOF_INT_PREC_INF;
-                    else
-                        flags |= BF_ATOF_ONLY_DEC_FLOAT;
-                    ret = js_atof(ctx, p, &p, 0, flags);
-                }
-#else
-                ret = js_atod(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT);
+                if (is_bigint_mode(ctx))
+                    flags |= ATOD_MODE_BIGINT;
 #endif
-                p += skip_spaces(p);
-                if ((p - str) != len) {
-                    JS_FreeValue(ctx, ret);
-                    ret = JS_NAN;
+                ret = js_atof(ctx, p, &p, 0, flags);
+                if (!JS_IsException(ret)) {
+                    p += skip_spaces(p);
+                    if ((p - str) != len) {
+                        JS_FreeValue(ctx, ret);
+                        ret = JS_NAN;
+                    }
                 }
             }
             JS_FreeCString(ctx, str);
@@ -9832,16 +10107,16 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
         break;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
-        if (!is_bignum_mode(ctx))
+        if (!is_bigint_mode(ctx))
             goto to_number;
         ret = val;
         break;
     case JS_TAG_BIG_FLOAT:
         {
             bf_t a_s, *a, r_s, *r = &r_s;
-            BOOL is_float, is_nan;
+            BOOL is_nan;
 
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
+            a = JS_ToBigFloat(ctx, &a_s, val);
             if (!bf_is_finite(a)) {
                 is_nan = bf_is_nan(a);
                 if (is_nan)
@@ -9851,7 +10126,7 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
             } else {
                 bf_init(ctx->bf_ctx, r);
                 bf_set(r, a);
-                bf_rint(r, BF_PREC_INF, BF_RNDZ);
+                bf_rint(r, BF_RNDZ);
                 ret = JS_NewBigInt(ctx, r);
             }
             if (a == &a_s)
@@ -9915,7 +10190,7 @@ static int JS_ToInt32SatFree(JSContext *ctx, int *pres, JSValue val)
         }
         break;
     case JS_TAG_BIG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             goto to_bf;
         /* fall thru */
 #endif
@@ -9994,7 +10269,7 @@ static int JS_ToInt64SatFree(JSContext *ctx, int64_t *pres, JSValue val)
         }
         return 0;
     case JS_TAG_BIG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             goto to_bf;
         /* fall thru */
 #endif
@@ -10079,7 +10354,7 @@ static int JS_ToInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
         }
         break;
     case JS_TAG_BIG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             goto to_bf;
         /* fall thru */
 #endif
@@ -10151,7 +10426,7 @@ static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
         }
         break;
     case JS_TAG_BIG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             goto to_bf;
         /* fall thru */
 #endif
@@ -10214,7 +10489,7 @@ static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
     case JS_TAG_BIG_INT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            if (!is_bignum_mode(ctx))
+            if (!is_bigint_mode(ctx))
                 goto to_number;
             bf_get_int32(&res, &p->num, 0);
             JS_FreeValue(ctx, val);
@@ -10226,7 +10501,7 @@ static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
             bf_t r_s, *r = &r_s;
             bf_init(ctx->bf_ctx, r);
             bf_set(r, &p->num);
-            bf_rint(r, BF_PREC_INF, BF_RNDN);
+            bf_rint(r, BF_RNDN);
             bf_get_int32(&res, r, 0);
             bf_delete(r);
             JS_FreeValue(ctx, val);
@@ -10376,6 +10651,12 @@ static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
             return p->num.sign;
         }
         break;
+    case JS_TAG_BIG_DECIMAL:
+        {
+            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+            return p->num.sign;
+        }
+        break;
 #endif
     default:
         return FALSE;
@@ -10384,19 +10665,47 @@ static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
 
 #ifdef CONFIG_BIGNUM
 
+static JSValue js_bigint_to_string1(JSContext *ctx, JSValueConst val, int radix)
+{
+    JSValue ret;
+    bf_t a_s, *a;
+    char *str;
+    int saved_sign;
+
+    a = JS_ToBigInt(ctx, &a_s, val);
+    if (!a)
+        return JS_EXCEPTION;
+    saved_sign = a->sign;
+    if (a->expn == BF_EXP_ZERO)
+        a->sign = 0;
+    str = bf_ftoa(NULL, a, radix, 0, BF_RNDZ | BF_FTOA_FORMAT_FRAC |
+                  BF_FTOA_JS_QUIRKS);
+    a->sign = saved_sign;
+    JS_FreeBigInt(ctx, a, &a_s);
+    if (!str)
+        return JS_ThrowOutOfMemory(ctx);
+    ret = JS_NewString(ctx, str);
+    bf_free(ctx->bf_ctx, str);
+    return ret;
+}
+
+static JSValue js_bigint_to_string(JSContext *ctx, JSValueConst val)
+{
+    return js_bigint_to_string1(ctx, val, 10);
+}
+
 static JSValue js_ftoa(JSContext *ctx, JSValueConst val1, int radix,
                        limb_t prec, bf_flags_t flags)
 {
     JSValue val, ret;
     bf_t a_s, *a;
-    BOOL is_float;
     char *str;
     int saved_sign;
 
     val = JS_ToNumeric(ctx, val1);
     if (JS_IsException(val))
         return val;
-    a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
+    a = JS_ToBigFloat(ctx, &a_s, val);
     saved_sign = a->sign;
     if (a->expn == BF_EXP_ZERO)
         a->sign = 0;
@@ -10404,45 +10713,68 @@ static JSValue js_ftoa(JSContext *ctx, JSValueConst val1, int radix,
     if ((flags & BF_FTOA_FORMAT_MASK) == BF_FTOA_FORMAT_FREE_MIN) {
         /* Note: for floating point numbers with a radix which is not
            a power of two, the current precision is used to compute
-           the number of digits. For integers, the full precision is
-           always returned. */
-        if (is_float || (flags & BF_FTOA_FORCE_EXP)) {
-            if ((radix & (radix - 1)) != 0) {
-                bf_t r_s, *r = &r_s;
-                int prec, flags1;
-                /* must round first */
-                if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
-                    prec = ctx->fp_env.prec;
-                    flags1 = ctx->fp_env.flags &
-                        (BF_FLAG_SUBNORMAL | (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT));
-                } else {
-                    prec = 53;
-                    flags1 = bf_set_exp_bits(11) | BF_FLAG_SUBNORMAL;
-                }
-                bf_init(ctx->bf_ctx, r);
-                bf_set(r, a);
-                bf_round(r, prec, flags1 | BF_RNDN);
-                bf_ftoa(&str, r, radix, prec, flags1 | flags);
-                bf_delete(r);
+           the number of digits. */
+        if ((radix & (radix - 1)) != 0) {
+            bf_t r_s, *r = &r_s;
+            int prec, flags1;
+            /* must round first */
+            if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
+                prec = ctx->fp_env.prec;
+                flags1 = ctx->fp_env.flags &
+                    (BF_FLAG_SUBNORMAL | (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT));
             } else {
-                bf_ftoa(&str, a, radix, BF_PREC_INF, flags);
+                prec = 53;
+                flags1 = bf_set_exp_bits(11) | BF_FLAG_SUBNORMAL;
             }
+            bf_init(ctx->bf_ctx, r);
+            bf_set(r, a);
+            bf_round(r, prec, flags1 | BF_RNDN);
+            str = bf_ftoa(NULL, r, radix, prec, flags1 | flags);
+            bf_delete(r);
         } else {
-            bf_ftoa(&str, a, radix, 0, BF_RNDZ | BF_FTOA_FORMAT_FRAC | BF_FTOA_JS_QUIRKS);
+            str = bf_ftoa(NULL, a, radix, BF_PREC_INF, flags);
         }
     } else {
-        bf_ftoa(&str, a, radix, prec, flags);
+        str = bf_ftoa(NULL, a, radix, prec, flags);
     }
     a->sign = saved_sign;
     if (a == &a_s)
         bf_delete(a);
     JS_FreeValue(ctx, val);
+    if (!str)
+        return JS_ThrowOutOfMemory(ctx);
     ret = JS_NewString(ctx, str);
-    bf_realloc(ctx->bf_ctx, str, 0);
+    bf_free(ctx->bf_ctx, str);
     return ret;
 }
 
-#else /* !CONFIG_BIGNUM */
+static JSValue js_bigfloat_to_string(JSContext *ctx, JSValueConst val)
+{
+    return js_ftoa(ctx, val, 10, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
+}
+
+static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+{
+    JSValue ret;
+    bfdec_t *a;
+    char *str;
+    int saved_sign;
+
+    a = JS_ToBigDecimal(ctx, val);
+    saved_sign = a->sign;
+    if (a->expn == BF_EXP_ZERO)
+        a->sign = 0;
+    str = bfdec_ftoa(NULL, a, 0, BF_RNDZ | BF_FTOA_FORMAT_FREE |
+                     BF_FTOA_JS_QUIRKS);
+    a->sign = saved_sign;
+    if (!str)
+        return JS_ThrowOutOfMemory(ctx);
+    ret = JS_NewString(ctx, str);
+    bf_free(ctx->bf_ctx, str);
+    return ret;
+}
+
+#endif /* CONFIG_BIGNUM */
 
 /* 2 <= base <= 36 */
 static char *i64toa(char *buf_end, int64_t n, unsigned int base)
@@ -10610,7 +10942,7 @@ static void js_fcvt(char *buf, int buf_size, double d, int n_digits)
 /* force exponential notation either in fixed or variable format */
 #define JS_DTOA_FORCE_EXP    (1 << 2)
 
-/* XXX: slow and maybe not fully correct
+/* XXX: slow and maybe not fully correct. Use libbf when it is fast enough.
    XXX: radix != 10 is only supported for small integers
 */
 static void js_dtoa1(char *buf, double d, int radix, int n_digits, int flags)
@@ -10710,8 +11042,6 @@ static JSValue js_dtoa(JSContext *ctx,
     return JS_NewString(ctx, buf);
 }
 
-#endif /* !CONFIG_BIGNUM */
-
 JSValue JS_ToStringInternal(JSContext *ctx, JSValueConst val, BOOL is_ToPropertyKey)
 {
     uint32_t tag;
@@ -10755,15 +11085,16 @@ JSValue JS_ToStringInternal(JSContext *ctx, JSValueConst val, BOOL is_ToProperty
         } else {
             return JS_ThrowTypeError(ctx, "cannot convert symbol to string");
         }
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_FLOAT64:
-    case JS_TAG_BIG_FLOAT:
-    case JS_TAG_BIG_INT:
-        return js_ftoa(ctx, val, 10, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
-#else
     case JS_TAG_FLOAT64:
         return js_dtoa(ctx, JS_VALUE_GET_FLOAT64(val), 10, 0,
                        JS_DTOA_VAR_FORMAT);
+#ifdef CONFIG_BIGNUM
+    case JS_TAG_BIG_INT:
+        return ctx->rt->bigint_ops.to_string(ctx, val);
+    case JS_TAG_BIG_FLOAT:
+        return ctx->rt->bigfloat_ops.to_string(ctx, val);
+    case JS_TAG_BIG_DECIMAL:
+        return ctx->rt->bigdecimal_ops.to_string(ctx, val);
 #endif
     default:
         str = "[unsupported type]";
@@ -11038,8 +11369,8 @@ static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             char *str;
-            bf_ftoa(&str, &p->num, 10, 0,
-                    BF_RNDZ | BF_FTOA_FORMAT_FRAC);
+            str = bf_ftoa(NULL, &p->num, 10, 0,
+                          BF_RNDZ | BF_FTOA_FORMAT_FRAC);
             printf("%sn", str);
             bf_realloc(&rt->bf_ctx, str, 0);
         }
@@ -11048,10 +11379,20 @@ static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             char *str;
-            bf_ftoa(&str, &p->num, 16, BF_PREC_INF,
-                    BF_RNDZ | BF_FTOA_FORMAT_FREE | BF_FTOA_ADD_PREFIX);
+            str = bf_ftoa(NULL, &p->num, 16, BF_PREC_INF,
+                          BF_RNDZ | BF_FTOA_FORMAT_FREE | BF_FTOA_ADD_PREFIX);
             printf("%sl", str);
-            bf_realloc(&rt->bf_ctx, str, 0);
+            bf_free(&rt->bf_ctx, str);
+        }
+        break;
+    case JS_TAG_BIG_DECIMAL:
+        {
+            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+            char *str;
+            str = bfdec_ftoa(NULL, &p->num, BF_PREC_INF,
+                             BF_RNDZ | BF_FTOA_FORMAT_FREE);
+            printf("%sm", str);
+            bf_free(&rt->bf_ctx, str);
         }
         break;
 #endif
@@ -11139,7 +11480,7 @@ static double js_pow(double a, double b)
 
 JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
 {
-    BOOL is_bignum = is_bignum_mode(ctx);
+    BOOL is_bignum = is_bigint_mode(ctx);
     if (is_bignum && v == (int32_t)v) {
         return JS_NewInt32(ctx, v);
     } else {
@@ -11152,7 +11493,7 @@ JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
 
 JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
 {
-    BOOL is_bignum = is_bignum_mode(ctx);
+    BOOL is_bignum = is_bigint_mode(ctx);
     if (is_bignum && v == (int32_t)v) {
         return JS_NewInt32(ctx, v);
     } else {
@@ -11164,13 +11505,12 @@ JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
 }
 
 /* if the returned bigfloat is allocated it is equal to
-   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. */
-static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
-                           JSValueConst val)
+   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. Return
+   NULL in case of error. */
+static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val)
 {
     uint32_t tag;
     bf_t *r;
-    BOOL is_float;
     JSBigFloat *p;
 
     tag = JS_VALUE_GET_NORM_TAG(val);
@@ -11180,21 +11520,20 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
     case JS_TAG_NULL:
         r = buf;
         bf_init(ctx->bf_ctx, r);
-        bf_set_si(r, JS_VALUE_GET_INT(val));
-        is_float = FALSE;
+        if (bf_set_si(r, JS_VALUE_GET_INT(val)))
+            goto fail;
         break;
     case JS_TAG_FLOAT64:
         r = buf;
         bf_init(ctx->bf_ctx, r);
-        bf_set_float64(r, JS_VALUE_GET_FLOAT64(val));
-        is_float = TRUE;
+        if (bf_set_float64(r, JS_VALUE_GET_FLOAT64(val))) {
+        fail:
+            bf_delete(r);
+            return NULL;
+        }
         break;
     case JS_TAG_BIG_INT:
-        is_float = FALSE;
-        goto get_ptr;
     case JS_TAG_BIG_FLOAT:
-        is_float = TRUE;
-    get_ptr:
         p = JS_VALUE_GET_PTR(val);
         r = &p->num;
         break;
@@ -11203,10 +11542,29 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, BOOL *pis_float, bf_t *buf,
         r = buf;
         bf_init(ctx->bf_ctx, r);
         bf_set_nan(r);
-        is_float = TRUE;
         break;
     }
-    *pis_float = is_float;
+    return r;
+}
+
+/* return NULL if invalid type */
+static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val)
+{
+    uint32_t tag;
+    JSBigDecimal *p;
+    bfdec_t *r;
+    
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_BIG_DECIMAL:
+        p = JS_VALUE_GET_PTR(val);
+        r = &p->num;
+        break;
+    default:
+        JS_ThrowTypeError(ctx, "bigdecimal expected");
+        r = NULL;
+        break;
+    }
     return r;
 }
 
@@ -11216,28 +11574,29 @@ static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
     const char *str, *p;
     size_t len;
     int flags;
-
+    
     str = JS_ToCStringLen(ctx, &len, val);
     JS_FreeValue(ctx, val);
     if (!str)
         return JS_EXCEPTION;
-    flags = BF_ATOF_BIN_OCT | BF_ATOF_NO_PREFIX_AFTER_SIGN |
-        BF_ATOF_JS_QUIRKS | BF_ATOF_INT_ONLY | BF_ATOF_INT_PREC_INF;
-    if (!is_bignum_mode(ctx))
-        flags |= BF_ATOF_BIG_INT;
     p = str;
     p += skip_spaces(p);
     if ((p - str) == len) {
         bf_t a_s, *a = &a_s;
         bf_init(ctx->bf_ctx, a);
         bf_set_si(a, 0);
-        val = JS_NewBigInt2(ctx, a, (flags & BF_ATOF_BIG_INT) != 0);
+        val = JS_NewBigInt(ctx, a);
     } else {
+        flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
+        if (is_bigint_mode(ctx))
+            flags |= ATOD_MODE_BIGINT;
         val = js_atof(ctx, p, &p, 0, flags);
         p += skip_spaces(p);
-        if ((p - str) != len) {
-            JS_FreeValue(ctx, val);
-            val = JS_NAN;
+        if (!JS_IsException(val)) {
+            if ((p - str) != len) {
+                JS_FreeValue(ctx, val);
+                val = JS_NAN;
+            }
         }
     }
     JS_FreeCString(ctx, str);
@@ -11247,11 +11606,8 @@ static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
 static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
 {
     val = JS_StringToBigInt(ctx, val);
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT &&
-        JS_VALUE_GET_TAG(val) != JS_TAG_INT) {
-        JS_FreeValue(ctx, val);
+    if (JS_VALUE_IS_NAN(val))
         return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
-    }
     return val;
 }
 
@@ -11269,7 +11625,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
     case JS_TAG_INT:
     case JS_TAG_NULL:
     case JS_TAG_UNDEFINED:
-        if (!is_bignum_mode(ctx))
+        if (!is_bigint_mode(ctx))
             goto fail;
         /* fall tru */
     case JS_TAG_BOOL:
@@ -11280,7 +11636,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
     case JS_TAG_FLOAT64:
         {
             double d = JS_VALUE_GET_FLOAT64(val);
-            if (!is_bignum_mode(ctx))
+            if (!is_bigint_mode(ctx))
                 goto fail;
             if (!isfinite(d))
                 goto fail;
@@ -11295,7 +11651,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
         r = &p->num;
         break;
     case JS_TAG_BIG_FLOAT:
-        if (!is_bignum_mode(ctx))
+        if (!is_bigint_mode(ctx))
             goto fail;
         p = JS_VALUE_GET_PTR(val);
         if (!bf_is_finite(&p->num))
@@ -11303,7 +11659,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
         r = buf;
         bf_init(ctx->bf_ctx, r);
         bf_set(r, &p->num);
-        bf_rint(r, BF_PREC_INF, BF_RNDZ);
+        bf_rint(r, BF_RNDZ);
         JS_FreeValue(ctx, val);
         break;
     case JS_TAG_STRING:
@@ -11313,7 +11669,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
         goto redo;
     case JS_TAG_OBJECT:
         val = JS_ToPrimitiveFree(ctx, val,
-                                 is_bignum_mode(ctx) ? HINT_INTEGER : HINT_NUMBER);
+                                 is_bigint_mode(ctx) ? HINT_INTEGER : HINT_NUMBER);
         if (JS_IsException(val))
             return NULL;
         goto redo;
@@ -11336,11 +11692,21 @@ static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
     if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
         return val;
     } else {
-        bf_t a_s, *a;
+        bf_t a_s, *a, b_s, *b;
+        int ret;
+        
         a = JS_ToBigIntFree(ctx, &a_s, val);
         if (!a)
             return JS_EXCEPTION;
-        return JS_NewBigInt2(ctx, a, TRUE);
+        b = &b_s;
+        bf_init(ctx->bf_ctx, b);
+        ret = bf_set(b, a);
+        JS_FreeBigInt(ctx, a, &a_s);
+        if (ret) {
+            bf_delete(b);
+            return JS_ThrowOutOfMemory(ctx);
+        }
+        return JS_NewBigInt2(ctx, b, TRUE);
     }
 }
 
@@ -11394,11 +11760,27 @@ static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a)
     JSBigFloat *p;
 
     p = js_new_bf(ctx);
-    p->num = *a;
+    bf_memcpy(&p->num, a);
     ret = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
     return ret;
 }
 
+/* WARNING: 'a' is freed */
+static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a)
+{
+    JSValue ret;
+    JSBigDecimal *p;
+
+    p = js_mallocz(ctx, sizeof(*p));
+    if (!p)
+        return JS_EXCEPTION;
+    p->header.ref_count = 1;
+    bfdec_init(ctx->bf_ctx, &p->num);
+    bfdec_memcpy(&p->num, a);
+    ret = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
+    return ret;
+}
+
 /* WARNING: 'a' is freed */
 static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint)
 {
@@ -11412,7 +11794,7 @@ static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint)
         bf_delete(a);
     } else {
         p = js_new_bf(ctx);
-        p->num = *a;
+        bf_memcpy(&p->num, a);
         /* normalize the zero representation */
         if (bf_is_zero(&p->num))
             p->num.sign = 0;
@@ -11423,7 +11805,7 @@ static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint)
 
 static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a)
 {
-    return JS_NewBigInt2(ctx, a, FALSE);
+    return JS_NewBigInt2(ctx, a, !is_bigint_mode(ctx));
 }
 
 /* return < 0 if exception, 0 if overloading method, 1 if overloading
@@ -11596,6 +11978,8 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
 static JSValue throw_bf_exception(JSContext *ctx, int status)
 {
     const char *str;
+    if (status & BF_ST_MEM_ERROR)
+        return JS_ThrowOutOfMemory(ctx);
     if (status & BF_ST_DIVIDE_ZERO) {
         str = "division by zero";
     } else if (status & BF_ST_INVALID_OP) {
@@ -11606,22 +11990,150 @@ static JSValue throw_bf_exception(JSContext *ctx, int status)
     return JS_ThrowRangeError(ctx, "%s", str);
 }
 
+static int js_unary_arith_bigint(JSContext *ctx,
+                                 JSValue *pres, OPCodeEnum op, JSValue op1)
+{
+    bf_t a_s, r_s, *r = &r_s, *a;
+    int ret, v;
+    
+    if (op == OP_plus && !is_bigint_mode(ctx)) {
+        JS_ThrowTypeError(ctx, "bigint argument with unary +");
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+    a = JS_ToBigInt(ctx, &a_s, op1);
+    bf_init(ctx->bf_ctx, r);
+    ret = 0;
+    switch(op) {
+    case OP_inc:
+    case OP_dec:
+        v = 2 * (op - OP_dec) - 1;
+        ret = bf_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_plus:
+        ret = bf_set(r, a);
+        break;
+    case OP_neg:
+        ret = bf_set(r, a);
+        bf_neg(r);
+        break;
+    case OP_not:
+        ret = bf_add_si(r, a, 1, BF_PREC_INF, BF_RNDZ);
+        bf_neg(r);
+        break;
+    default:
+        abort();
+    }
+    JS_FreeBigInt(ctx, a, &a_s);
+    JS_FreeValue(ctx, op1);
+    if (unlikely(ret)) {
+        bf_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigInt(ctx, r);
+    return 0;
+}
+
+static int js_unary_arith_bigfloat(JSContext *ctx,
+                                   JSValue *pres, OPCodeEnum op, JSValue op1)
+{
+    bf_t a_s, r_s, *r = &r_s, *a;
+    int ret, v;
+    
+    if (op == OP_plus && !is_bigint_mode(ctx)) {
+        JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    bf_init(ctx->bf_ctx, r);
+    ret = 0;
+    switch(op) {
+    case OP_inc:
+    case OP_dec:
+        v = 2 * (op - OP_dec) - 1;
+        ret = bf_add_si(r, a, v, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_plus:
+        ret = bf_set(r, a);
+        break;
+    case OP_neg:
+        ret = bf_set(r, a);
+        bf_neg(r);
+        break;
+    default:
+        abort();
+    }
+    if (a == &a_s)
+        bf_delete(a);
+    JS_FreeValue(ctx, op1);
+    if (unlikely(ret & BF_ST_MEM_ERROR)) {
+        bf_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigFloat(ctx, r);
+    return 0;
+}
+
+static int js_unary_arith_bigdecimal(JSContext *ctx,
+                                     JSValue *pres, OPCodeEnum op, JSValue op1)
+{
+    bfdec_t r_s, *r = &r_s, *a;
+    int ret, v;
+
+    if (op == OP_plus && !is_bigint_mode(ctx)) {
+        JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+
+    a = JS_ToBigDecimal(ctx, op1);
+    bfdec_init(ctx->bf_ctx, r);
+    ret = 0;
+    switch(op) {
+    case OP_inc:
+    case OP_dec:
+        v = 2 * (op - OP_dec) - 1;
+        ret = bfdec_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_plus:
+        ret = bfdec_set(r, a);
+        break;
+    case OP_neg:
+        ret = bfdec_set(r, a);
+        bfdec_neg(r);
+        break;
+    default:
+        abort();
+    }
+    JS_FreeValue(ctx, op1);
+    if (unlikely(ret)) {
+        bfdec_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigDecimal(ctx, r);
+    return 0;
+}
+
 static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
                                                      JSValue *sp,
                                                      OPCodeEnum op)
 {
     JSValue op1, val, method;
-    bf_t a_s, r_s, *r = &r_s, *a;
-    BOOL is_float, is_legacy;
+    BOOL is_legacy;
     JSAtom op_name;
-    int ret, v;
+    int v;
     uint32_t tag;
 
     op1 = sp[-1];
     /* fast path for float64 */
     if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(op1)))
         goto handle_float64;
-    if (JS_IsObject(op1)) {
+    if (JS_IsObject(op1) && ctx->bignum_ext) {
         switch(op) {
         case OP_plus:
             op_name = JS_ATOM_Symbol_operatorPlus;
@@ -11653,7 +12165,7 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
         op1 = JS_ToNumericFree(ctx, op1);
         if (JS_IsException(op1))
             goto exception;
-        is_legacy = is_bignum_mode(ctx) ^ 1;
+        is_legacy = is_bigint_mode(ctx) ^ 1;
         tag = JS_VALUE_GET_TAG(op1);
         switch(tag) {
         case JS_TAG_INT:
@@ -11683,69 +12195,16 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
             }
             break;
         case JS_TAG_BIG_INT:
-            if (is_legacy && op == OP_plus) {
-                JS_ThrowTypeError(ctx, "bigint argument with unary +");
-                JS_FreeValue(ctx, op1);
+            if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
                 goto exception;
-            }
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-            bf_init(ctx->bf_ctx, r);
-            ret = 0;
-            switch(op) {
-            case OP_inc:
-            case OP_dec:
-                v = 2 * (op - OP_dec) - 1;
-                ret = bf_add_si(r, a, v, BF_PREC_INF, BF_RNDZ) & BF_ST_OVERFLOW;
-                break;
-            case OP_plus:
-                bf_set(r, a);
-                break;
-            case OP_neg:
-                bf_set(r, a);
-                bf_neg(r);
-                break;
-            default:
-                abort();
-            }
-            if (a == &a_s)
-                bf_delete(a);
-            JS_FreeValue(ctx, op1);
-            if (unlikely(ret)) {
-                bf_delete(r);
-                throw_bf_exception(ctx, ret);
-                goto exception;
-            }
-            sp[-1] = JS_NewBigInt2(ctx, r, is_legacy);
             break;
         case JS_TAG_BIG_FLOAT:
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-            bf_init(ctx->bf_ctx, r);
-            ret = 0;
-            switch(op) {
-            case OP_inc:
-            case OP_dec:
-                v = 2 * (op - OP_dec) - 1;
-                bf_add_si(r, a, v, ctx->fp_env.prec, ctx->fp_env.flags);
-                break;
-            case OP_plus:
-                bf_set(r, a);
-                break;
-            case OP_neg:
-                bf_set(r, a);
-                bf_neg(r);
-                break;
-            default:
-                abort();
-            }
-            if (a == &a_s)
-                bf_delete(a);
-            JS_FreeValue(ctx, op1);
-            if (unlikely(ret)) {
-                bf_delete(r);
-                throw_bf_exception(ctx, ret);
+            if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
+                goto exception;
+            break;
+        case JS_TAG_BIG_DECIMAL:
+            if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
                 goto exception;
-            }
-            sp[-1] = JS_NewBigFloat(ctx, r);
             break;
         default:
         handle_float64:
@@ -11797,12 +12256,11 @@ static __exception int js_post_inc_slow(JSContext *ctx,
 static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 {
     JSValue op1, method, val;
-    bf_t a_s, r_s, *r = &r_s, *a;
-    int ret;
-    BOOL is_legacy;
 
     op1 = sp[-1];
     if (JS_IsObject(op1)) {
+        if (!ctx->bignum_ext)
+            goto to_number;
         method = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorNot);
         if (JS_IsException(method))
             return -1;
@@ -11820,19 +12278,9 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
             if (JS_IsException(op1))
                 goto exception;
         }
-        is_legacy = is_bignum_mode(ctx) ^ 1;
-        if (!is_legacy || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
-            a = JS_ToBigIntFree(ctx, &a_s, op1);
-            bf_init(ctx->bf_ctx, r);
-            ret = bf_add_si(r, a, 1, BF_PREC_INF, BF_RNDZ) & BF_ST_OVERFLOW;
-            bf_neg(r);
-            JS_FreeBigInt(ctx, a, &a_s);
-            if (unlikely(ret)) {
-                bf_delete(r);
-                throw_bf_exception(ctx, ret);
+        if (is_bigint_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
+            if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
                 goto exception;
-            }
-            sp[-1] = JS_NewBigInt2(ctx, r, is_legacy);
         } else {
             int32_t v1;
             if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
@@ -11846,13 +12294,317 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
+static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
+                                    JSValue *pres, JSValue op1, JSValue op2)
+{
+    bf_t a_s, b_s, r_s, *r, *a, *b;
+    int ret, rnd_mode;
+    
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    b = JS_ToBigFloat(ctx, &b_s, op2);
+    r = &r_s;
+    bf_init(ctx->bf_ctx, r);
+    switch(op) {
+    case OP_add:
+        ret = bf_add(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_sub:
+        ret = bf_sub(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_mul:
+        ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_math_div:
+    case OP_div:
+        ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_math_mod:
+        /* Euclidian remainder */
+        rnd_mode = BF_DIVREM_EUCLIDIAN;
+        goto do_mod;
+    case OP_mod:
+        rnd_mode = BF_RNDZ;
+    do_mod:
+        {
+            bf_t q_s, *q = &q_s;
+            bf_init(ctx->bf_ctx, q);
+            ret = bf_divrem(q, r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+                            rnd_mode);
+            bf_delete(q);
+        }
+        break;
+    case OP_pow:
+    case OP_math_pow:
+        ret = bf_pow(r, a, b, ctx->fp_env.prec,
+                     ctx->fp_env.flags | BF_POW_JS_QUICKS);
+        break;
+    default:
+        abort();
+    }
+    if (a == &a_s)
+        bf_delete(a);
+    if (b == &b_s)
+        bf_delete(b);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    if (unlikely(ret & BF_ST_MEM_ERROR)) {
+        bf_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigFloat(ctx, r);
+    return 0;
+}
+
+static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
+                                  JSValue *pres, JSValue op1, JSValue op2)
+{
+    bf_t a_s, b_s, r_s, *r, *a, *b;
+    int ret, rnd_mode;
+    JSValue res;
+    
+    a = JS_ToBigInt(ctx, &a_s, op1);
+    if (!a)
+        goto fail;
+    b = JS_ToBigInt(ctx, &b_s, op2);
+    if (!b) {
+        JS_FreeBigInt(ctx, a, &a_s);
+        goto fail;
+    }
+    r = &r_s;
+    bf_init(ctx->bf_ctx, r);
+    ret = 0;
+    switch(op) {
+    case OP_add:
+        ret = bf_add(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_sub:
+        ret = bf_sub(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_mul:
+        ret = bf_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_math_div:
+        goto op_fallback;
+    case OP_div:
+        if (!is_bigint_mode(ctx)) {
+            bf_t rem_s, *rem = &rem_s;
+            bf_init(ctx->bf_ctx, rem);
+            ret = bf_divrem(r, rem, a, b, BF_PREC_INF, BF_RNDZ,
+                            BF_RNDZ);
+            bf_delete(rem);
+        } else {
+            bf_div(r, a, b, 53, bf_set_exp_bits(11) |
+                   BF_RNDN | BF_FLAG_SUBNORMAL);
+            goto float64_result;
+        }
+        break;
+    case OP_math_mod:
+        /* Euclidian remainder */
+        rnd_mode = BF_DIVREM_EUCLIDIAN;
+        goto do_int_mod;
+    case OP_mod:
+        rnd_mode = BF_RNDZ;
+    do_int_mod:
+        {
+            bf_t q_s, *q = &q_s;
+            bf_init(ctx->bf_ctx, q);
+            ret = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ,
+                            rnd_mode) & BF_ST_INVALID_OP;
+            bf_delete(q);
+        }
+        break;
+    case OP_pow:
+    case OP_math_pow:
+        if (b->sign) {
+            if (!is_bigint_mode(ctx)) {
+                ret = BF_ST_INVALID_OP;
+            } else if (op == OP_math_pow) {
+            op_fallback:
+                bf_delete(r);
+                JS_FreeBigInt(ctx, a, &a_s);
+                JS_FreeBigInt(ctx, b, &b_s);
+                ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+                JS_FreeValue(ctx, op1);
+                JS_FreeValue(ctx, op2);
+                if (ret < 0) {
+                    return -1;
+                } else if (ret == 0) {
+                    JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
+                    return -1;
+                }
+                *pres = res;
+                return 0;
+            } else {
+                double dr;
+                bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
+                       BF_RNDN | BF_FLAG_SUBNORMAL);
+            float64_result:
+                bf_get_float64(r, &dr, BF_RNDN);
+                bf_delete(r);
+                JS_FreeBigInt(ctx, a, &a_s);
+                JS_FreeBigInt(ctx, b, &b_s);
+                JS_FreeValue(ctx, op1);
+                JS_FreeValue(ctx, op2);
+                *pres = __JS_NewFloat64(ctx, dr);
+                return 0;
+            }
+        } else {
+            ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUICKS);
+        }
+        break;
+
+        /* logical operations */
+    case OP_shl:
+    case OP_sar:
+        {
+            slimb_t v2;
+#if LIMB_BITS == 32
+            bf_get_int32(&v2, b, 0);
+            if (v2 == INT32_MIN)
+                v2 = INT32_MIN + 1;
+#else
+            bf_get_int64(&v2, b, 0);
+            if (v2 == INT64_MIN)
+                v2 = INT64_MIN + 1;
+#endif
+            if (op == OP_sar)
+                v2 = -v2;
+            ret = bf_set(r, a);
+            ret |= bf_mul_2exp(r, v2, BF_PREC_INF, BF_RNDZ);
+            if (v2 < 0) {
+                ret |= bf_rint(r, BF_RNDD) & (BF_ST_OVERFLOW | BF_ST_MEM_ERROR);
+            }
+        }
+        break;
+    case OP_and:
+        ret = bf_logic_and(r, a, b);
+        break;
+    case OP_or:
+        ret = bf_logic_or(r, a, b);
+        break;
+    case OP_xor:
+        ret = bf_logic_xor(r, a, b);
+        break;
+    default:
+        abort();
+    }
+    JS_FreeBigInt(ctx, a, &a_s);
+    JS_FreeBigInt(ctx, b, &b_s);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    if (unlikely(ret)) {
+        bf_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigInt(ctx, r);
+    return 0;
+ fail:
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return -1;
+}
+
+/* b must be a positive integer */
+static int js_bfdec_pow(bfdec_t *r, const bfdec_t *a, const bfdec_t *b)
+{
+    bfdec_t b1;
+    int32_t b2;
+    int ret;
+
+    bfdec_init(b->ctx, &b1);
+    ret = bfdec_set(&b1, b);
+    if (ret) {
+        bfdec_delete(&b1);
+        return ret;
+    }
+    ret = bfdec_rint(&b1, BF_RNDZ);
+    if (ret) {
+        bfdec_delete(&b1);
+        return BF_ST_INVALID_OP; /* must be an integer */
+    }
+    ret = bfdec_get_int32(&b2, &b1);
+    bfdec_delete(&b1);
+    if (ret)
+        return ret; /* overflow */
+    if (b2 < 0)
+        return BF_ST_INVALID_OP; /* must be positive */
+    return bfdec_pow_ui(r, a, b2);
+}
+
+static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
+                                      JSValue *pres, JSValue op1, JSValue op2)
+{
+    bfdec_t r_s, *r, *a, *b;
+    int ret, rnd_mode;
+ 
+    /* big decimal result */
+    a = JS_ToBigDecimal(ctx, op1);
+    if (!a)
+        goto fail;
+    b = JS_ToBigDecimal(ctx, op2);
+    if (!b)
+        goto fail;
+    r = &r_s;
+    bfdec_init(ctx->bf_ctx, r);
+    switch(op) {
+    case OP_add:
+        ret = bfdec_add(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_sub:
+        ret = bfdec_sub(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_mul:
+        ret = bfdec_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_math_div:
+    case OP_div:
+        ret = bfdec_div(r, a, b, BF_PREC_INF, BF_RNDZ);
+        break;
+    case OP_math_mod:
+        /* Euclidian remainder */
+        rnd_mode = BF_DIVREM_EUCLIDIAN;
+        goto do_mod_dec;
+    case OP_mod:
+        rnd_mode = BF_RNDZ;
+    do_mod_dec:
+        {
+            bfdec_t q_s, *q = &q_s;
+            bfdec_init(ctx->bf_ctx, q);
+            ret = bfdec_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, rnd_mode);
+            bfdec_delete(q);
+        }
+        break;
+    case OP_pow:
+    case OP_math_pow:
+        ret = js_bfdec_pow(r, a, b);
+        break;
+    default:
+        abort();
+    }
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    if (unlikely(ret)) {
+        bfdec_delete(r);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = JS_NewBigDecimal(ctx, r);
+    return 0;
+ fail:
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return -1;
+}
+
 static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *sp,
                                                       OPCodeEnum op)
 {
     JSValue op1, op2, res;
-    BOOL is_float, is_legacy;
+    BOOL is_legacy;
     uint32_t tag1, tag2;
-    int ret, rnd_mode;
+    int ret;
     double d1, d2;
 
     op1 = sp[-2];
@@ -11867,10 +12619,11 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     }
 
     /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+    if (((tag1 == JS_TAG_OBJECT &&
+          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+         (tag2 == JS_TAG_OBJECT &&
+          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
+        ctx->bignum_ext) {
         ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
@@ -11897,20 +12650,12 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
-    is_legacy = is_bignum_mode(ctx) ^ 1;
-    if (is_legacy && (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
-        tag1 != tag2) {
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        JS_ThrowTypeError(ctx, "both operands must be bigint");
-        goto exception;
-    }
-
     if (tag1 == JS_TAG_INT && tag2 == JS_TAG_INT) {
         int32_t v1, v2;
         int64_t v;
         v1 = JS_VALUE_GET_INT(op1);
         v2 = JS_VALUE_GET_INT(op2);
+        is_legacy = is_bigint_mode(ctx) ^ 1;
         switch(op) {
         case OP_sub:
             v = (int64_t)v1 - (int64_t)v2;
@@ -11923,7 +12668,9 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             }
             break;
         case OP_math_div:
-            goto op_fallback2;
+            if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+                goto exception;
+            return 0;
         case OP_div:
             sp[-2] = __JS_NewFloat64(ctx, (double)v1 / (double)v2);
             return 0;
@@ -11958,130 +12705,30 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                 sp[-2] = JS_NewFloat64(ctx, js_pow(v1, v2));
                 return 0;
             } else {
-                goto handle_bigint;
+                if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+                    goto exception;
+                return 0;
             }
             break;
         default:
             abort();
         }
         sp[-2] = JS_NewInt64(ctx, v);
-    } else if ((tag1 == JS_TAG_BIG_INT && (tag2 == JS_TAG_INT ||
-                                           tag2 == JS_TAG_BIG_INT)) ||
-               (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_INT)) {
-        /* big int result */
-        bf_t a_s, b_s, r_s, *r, *a, *b;
-    handle_bigint:
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-        b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-        r = &r_s;
-        bf_init(ctx->bf_ctx, r);
-        ret = 0;
-        switch(op) {
-        case OP_sub:
-            ret = bf_sub(r, a, b, BF_PREC_INF, BF_RNDZ) & BF_ST_OVERFLOW;
-            break;
-        case OP_mul:
-            ret = bf_mul(r, a, b, BF_PREC_INF, BF_RNDZ) & BF_ST_OVERFLOW;
-            break;
-        case OP_math_div:
-            goto op_fallback;
-        case OP_div:
-            if (is_legacy) {
-                bf_t rem_s, *rem = &rem_s;
-                bf_init(ctx->bf_ctx, rem);
-                ret = bf_divrem(r, rem, a, b, BF_PREC_INF, BF_RNDZ,
-                                BF_RNDZ) & BF_ST_INVALID_OP;
-                bf_delete(rem);
-            } else {
-                bf_div(r, a, b, 53, bf_set_exp_bits(11) |
-                       BF_RNDN | BF_FLAG_SUBNORMAL);
-                goto float64_result;
-            }
-            break;
-        case OP_math_mod:
-            /* Euclidian remainder */
-            rnd_mode = BF_DIVREM_EUCLIDIAN;
-            goto do_int_mod;
-        case OP_mod:
-            rnd_mode = BF_RNDZ;
-        do_int_mod:
-            {
-                bf_t q_s, *q = &q_s;
-                bf_init(ctx->bf_ctx, q);
-                ret = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ,
-                                rnd_mode) & BF_ST_INVALID_OP;
-                bf_delete(q);
-            }
-            break;
-        case OP_pow:
-        case OP_math_pow:
-            if (b->sign) {
-                if (is_legacy) {
-                    ret = BF_ST_INVALID_OP;
-                } else if (op == OP_math_pow) {
-                op_fallback:
-                    bf_delete(r);
-                    if (a == &a_s)
-                        bf_delete(a);
-                    if (b == &b_s)
-                        bf_delete(b);
-                op_fallback2:
-                    ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
-                    JS_FreeValue(ctx, op1);
-                    JS_FreeValue(ctx, op2);
-                    if (ret < 0) {
-                        goto exception;
-                    } else if (ret == 0) {
-                        JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
-                        goto exception;
-                    }
-                    sp[-2] = res;
-                    return 0;
-                } else {
-                    double dr;
-                    bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
-                           BF_RNDN | BF_FLAG_SUBNORMAL);
-                float64_result:
-                    bf_get_float64(r, &dr, BF_RNDN);
-                    bf_delete(r);
-                    if (a == &a_s)
-                        bf_delete(a);
-                    if (b == &b_s)
-                        bf_delete(b);
-                    JS_FreeValue(ctx, op1);
-                    JS_FreeValue(ctx, op2);
-                    sp[-2] = __JS_NewFloat64(ctx, dr);
-                    return 0;
-                }
-            } else {
-                ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUICKS) &
-                    BF_ST_OVERFLOW;
-            }
-            break;
-        default:
-            abort();
-        }
-        if (a == &a_s)
-            bf_delete(a);
-        if (b == &b_s)
-            bf_delete(b);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        if (unlikely(ret)) {
-            bf_delete(r);
-            throw_bf_exception(ctx, ret);
+    } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+        if (ctx->rt->bigdecimal_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
-        }
-        sp[-2] = JS_NewBigInt2(ctx, r, is_legacy);
-    } else if ((tag1 == JS_TAG_FLOAT64 && (tag2 == JS_TAG_FLOAT64 ||
-                                           tag2 == JS_TAG_INT ||
-                                           tag2 == JS_TAG_BIG_INT)) ||
-               (tag2 == JS_TAG_FLOAT64 && (tag1 == JS_TAG_INT ||
-                                           tag1 == JS_TAG_BIG_INT))) {
+    } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
+        if (ctx->rt->bigfloat_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+            goto exception;
+    } else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
         double dr;
         /* float64 result */
-        JS_ToFloat64Free(ctx, &d1, op1);
-        JS_ToFloat64Free(ctx, &d2, op2);
+        if (JS_ToFloat64Free(ctx, &d1, op1)) {
+            JS_FreeValue(ctx, op2);
+            goto exception;
+        }
+        if (JS_ToFloat64Free(ctx, &d2, op2))
+            goto exception;
     handle_float64:
         switch(op) {
         case OP_sub:
@@ -12098,25 +12745,11 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             dr = fmod(d1, d2);
             break;
         case OP_math_mod:
-            if (d1 >= 0 && d2 >= 0) {
-                dr = fmod(d1, d2);
-            } else {
-                /* XXX: slow */
-                bf_t a, b, r, q;
-                bf_init(ctx->bf_ctx, &a);
-                bf_init(ctx->bf_ctx, &b);
-                bf_init(ctx->bf_ctx, &r);
-                bf_set_float64(&a, d1);
-                bf_set_float64(&b, d2);
-                bf_divrem(&q, &r, &a, &b,
-                          53, bf_set_exp_bits(11) | BF_RNDN | BF_FLAG_SUBNORMAL,
-                          BF_DIVREM_EUCLIDIAN);
-                bf_get_float64(&q, &dr, BF_RNDN);
-                bf_delete(&a);
-                bf_delete(&b);
-                bf_delete(&q);
-                bf_delete(&r);
-            }
+            d2 = fabs(d2);
+            dr = fmod(d1, d2);
+            /* XXX: loss of accuracy if dr < 0 */
+            if (dr < 0)
+                dr += d2;
             break;
         case OP_pow:
         case OP_math_pow:
@@ -12127,59 +12760,8 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         }
         sp[-2] = __JS_NewFloat64(ctx, dr);
     } else {
-        bf_t a_s, b_s, r_s, *r, *a, *b;
-        /* big float result */
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-        b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-        r = &r_s;
-        bf_init(ctx->bf_ctx, r);
-        ret = 0;
-        switch(op) {
-        case OP_sub:
-            bf_sub(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-            break;
-        case OP_mul:
-            bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-            break;
-        case OP_math_div:
-        case OP_div:
-            bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-            break;
-        case OP_math_mod:
-            /* Euclidian remainder */
-            rnd_mode = BF_DIVREM_EUCLIDIAN;
-            goto do_mod;
-        case OP_mod:
-            rnd_mode = BF_RNDZ;
-        do_mod:
-            {
-                bf_t q_s, *q = &q_s;
-                bf_init(ctx->bf_ctx, q);
-                bf_divrem(q, r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                          rnd_mode);
-                bf_delete(q);
-            }
-            break;
-        case OP_pow:
-        case OP_math_pow:
-            bf_pow(r, a, b, ctx->fp_env.prec,
-                   ctx->fp_env.flags | BF_POW_JS_QUICKS);
-            break;
-        default:
-            abort();
-        }
-        if (a == &a_s)
-            bf_delete(a);
-        if (b == &b_s)
-            bf_delete(b);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        if (unlikely(ret)) {
-            bf_delete(r);
-            throw_bf_exception(ctx, ret);
+        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
-        }
-        sp[-2] = JS_NewBigFloat(ctx, r);
     }
     return 0;
  exception:
@@ -12192,7 +12774,6 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
 {
     JSValue op1, op2, res;
     uint32_t tag1, tag2;
-    BOOL is_float, is_legacy;
     int ret;
 
     op1 = sp[-2];
@@ -12211,10 +12792,11 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
 
     if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
         /* try to call an overloaded operator */
-        if ((tag1 == JS_TAG_OBJECT &&
-             (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-            (tag2 == JS_TAG_OBJECT &&
-             (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+        if (((tag1 == JS_TAG_OBJECT &&
+              (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+             (tag2 == JS_TAG_OBJECT &&
+              (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
+            ctx->bignum_ext) {
             ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add);
             if (ret != 0) {
                 JS_FreeValue(ctx, op1);
@@ -12263,15 +12845,6 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
-    is_legacy = is_bignum_mode(ctx) ^ 1;
-    if (is_legacy && (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
-        tag1 != tag2) {
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        JS_ThrowTypeError(ctx, "both operands must be bigint");
-        goto exception;
-    }
-
     if (tag1 == JS_TAG_INT && tag2 == JS_TAG_INT) {
         int32_t v1, v2;
         int64_t v;
@@ -12279,54 +12852,25 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         v2 = JS_VALUE_GET_INT(op2);
         v = (int64_t)v1 + (int64_t)v2;
         sp[-2] = JS_NewInt64(ctx, v);
-    } else if ((tag1 == JS_TAG_BIG_INT && (tag2 == JS_TAG_INT ||
-                                           tag2 == JS_TAG_BIG_INT)) ||
-               (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_INT)) {
-        bf_t a_s, b_s, r_s, *r, *a, *b;
-        /* big int result */
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-        b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-        r = &r_s;
-        bf_init(ctx->bf_ctx, r);
-        ret = bf_add(r, a, b, BF_PREC_INF, BF_RNDZ) & BF_ST_OVERFLOW;
-        if (a == &a_s)
-            bf_delete(a);
-        if (b == &b_s)
-            bf_delete(b);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        if (unlikely(ret)) {
-            bf_delete(r);
-            throw_bf_exception(ctx, ret);
+    } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+        if (ctx->rt->bigdecimal_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
             goto exception;
-        }
-        sp[-2] = JS_NewBigInt2(ctx, r, is_legacy);
-    } else if ((tag1 == JS_TAG_FLOAT64 && (tag2 == JS_TAG_FLOAT64 ||
-                                           tag2 == JS_TAG_INT ||
-                                           tag2 == JS_TAG_BIG_INT)) ||
-               (tag2 == JS_TAG_FLOAT64 && (tag1 == JS_TAG_INT ||
-                                           tag1 == JS_TAG_BIG_INT))) {
+    } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
+        if (ctx->rt->bigfloat_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
+            goto exception;
+    } else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
         double d1, d2;
         /* float64 result */
-        JS_ToFloat64Free(ctx, &d1, op1);
-        JS_ToFloat64Free(ctx, &d2, op2);
+        if (JS_ToFloat64Free(ctx, &d1, op1)) {
+            JS_FreeValue(ctx, op2);
+            goto exception;
+        }
+        if (JS_ToFloat64Free(ctx, &d2, op2))
+            goto exception;
         sp[-2] = __JS_NewFloat64(ctx, d1 + d2);
     } else {
-        bf_t a_s, b_s, r_s, *r, *a, *b;
-        /* big float result */
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-        b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-
-        r = &r_s;
-        bf_init(ctx->bf_ctx, r);
-        bf_add(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        if (a == &a_s)
-            bf_delete(a);
-        if (b == &b_s)
-            bf_delete(b);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        sp[-2] = JS_NewBigFloat(ctx, r);
+        if (ctx->rt->bigint_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
+            goto exception;
     }
     return 0;
  exception:
@@ -12340,10 +12884,8 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
                                                       OPCodeEnum op)
 {
     JSValue op1, op2, res;
-    bf_t a_s, b_s, r_s, *r, *a, *b;
     int ret;
     uint32_t tag1, tag2;
-    BOOL is_legacy;
 
     op1 = sp[-2];
     op2 = sp[-1];
@@ -12351,10 +12893,11 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
     /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+    if (((tag1 == JS_TAG_OBJECT &&
+          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+         (tag2 == JS_TAG_OBJECT &&
+          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
+        ctx->bignum_ext) {
         ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
@@ -12379,8 +12922,7 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
         goto exception;
     }
 
-    is_legacy = is_bignum_mode(ctx) ^ 1;
-    if (is_legacy) {
+    if (!is_bigint_mode(ctx)) {
         uint32_t v1, v2, r;
 
         tag1 = JS_VALUE_GET_TAG(op1);
@@ -12391,6 +12933,8 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
                 JS_FreeValue(ctx, op2);
                 JS_ThrowTypeError(ctx, "both operands must be bigint");
                 goto exception;
+            } else {
+                goto bigint_op;
             }
         } else {
             if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
@@ -12419,65 +12963,110 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
                 abort();
             }
             sp[-2] = JS_NewInt32(ctx, r);
-            return 0;
         }
+    } else {
+    bigint_op:
+        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+            goto exception;
     }
+    return 0;
+ exception:
+    sp[-2] = JS_UNDEFINED;
+    sp[-1] = JS_UNDEFINED;
+    return -1;
+}
 
-    a = JS_ToBigIntFree(ctx, &a_s, op1);
-    b = JS_ToBigIntFree(ctx, &b_s, op2);
-
-    r = &r_s;
-    bf_init(ctx->bf_ctx, r);
-    ret = 0;
+/* Note: also used for bigint */
+static int js_compare_bigfloat(JSContext *ctx, OPCodeEnum op,
+                               JSValue op1, JSValue op2)
+{
+    bf_t a_s, b_s, *a, *b;
+    int res;
+    
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    if (!a) {
+        JS_FreeValue(ctx, op2);
+        return -1;
+    }
+    b = JS_ToBigFloat(ctx, &b_s, op2);
+    if (!b) {
+        if (a == &a_s)
+            bf_delete(a);
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
     switch(op) {
-    case OP_shl:
-    case OP_sar:
-        {
-            slimb_t v2;
-#if LIMB_BITS == 32
-            bf_get_int32(&v2, b, 0);
-            if (v2 == INT32_MIN)
-                v2 = INT32_MIN + 1;
-#else
-            bf_get_int64(&v2, b, 0);
-            if (v2 == INT64_MIN)
-                v2 = INT64_MIN + 1;
-#endif
-            if (op == OP_sar)
-                v2 = -v2;
-            bf_set(r, a);
-            ret = bf_mul_2exp(r, v2, BF_PREC_INF, BF_RNDZ);
-            if (v2 < 0) {
-                ret |= bf_rint(r, BF_PREC_INF, BF_RNDD);
-            }
-            ret &= BF_ST_OVERFLOW;
-        }
+    case OP_lt:
+        res = bf_cmp_lt(a, b); /* if NaN return false */
         break;
-    case OP_and:
-        bf_logic_and(r, a, b);
+    case OP_lte:
+        res = bf_cmp_le(a, b); /* if NaN return false */
         break;
-    case OP_or:
-        bf_logic_or(r, a, b);
+    case OP_gt:
+        res = bf_cmp_lt(b, a); /* if NaN return false */
         break;
-    case OP_xor:
-        bf_logic_xor(r, a, b);
+    case OP_gte:
+        res = bf_cmp_le(b, a); /* if NaN return false */
+        break;
+    case OP_eq:
+        res = bf_cmp_eq(a, b); /* if NaN return false */
         break;
     default:
         abort();
     }
-    JS_FreeBigInt(ctx, a, &a_s);
-    JS_FreeBigInt(ctx, b, &b_s);
-    if (unlikely(ret)) {
-        bf_delete(r);
-        throw_bf_exception(ctx, ret);
-        goto exception;
+    if (a == &a_s)
+        bf_delete(a);
+    if (b == &b_s)
+        bf_delete(b);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return res;
+}
+
+static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
+                                 JSValue op1, JSValue op2)
+{
+    bfdec_t *a, *b;
+    int res;
+
+    /* Note: binary floats are converted to bigdecimal with
+       toString(). It is not mathematically correct but is consistent
+       with the BigDecimal() constructor behavior */
+    op1 = JS_ToBigDecimalFree(ctx, op1, TRUE);
+    if (JS_IsException(op1)) {
+        JS_FreeValue(ctx, op2);
+        return -1;
     }
-    sp[-2] = JS_NewBigInt2(ctx, r, is_legacy);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
+    op2 = JS_ToBigDecimalFree(ctx, op2, TRUE);
+    if (JS_IsException(op2)) {
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+    a = JS_ToBigDecimal(ctx, op1);
+    b = JS_ToBigDecimal(ctx, op2);
+    
+    switch(op) {
+    case OP_lt:
+        res = bfdec_cmp_lt(a, b); /* if NaN return false */
+        break;
+    case OP_lte:
+        res = bfdec_cmp_le(a, b); /* if NaN return false */
+        break;
+    case OP_gt:
+        res = bfdec_cmp_lt(b, a); /* if NaN return false */
+        break;
+    case OP_gte:
+        res = bfdec_cmp_le(b, a); /* if NaN return false */
+        break;
+    case OP_eq:
+        res = bfdec_cmp_eq(a, b); /* if NaN return false */
+        break;
+    default:
+        abort();
+    }
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return res;
 }
 
 static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
@@ -12492,10 +13081,11 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
     /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+    if (((tag1 == JS_TAG_OBJECT &&
+          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+         (tag2 == JS_TAG_OBJECT &&
+          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
+        ctx->bignum_ext) {
         res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op);
         if (res != 0) {
             JS_FreeValue(ctx, op1);
@@ -12573,12 +13163,9 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
             break;
         }
     } else {
-        bf_t a_s, b_s, *a, *b;
-        BOOL is_float;
-
         if (((tag1 == JS_TAG_BIG_INT && tag2 == JS_TAG_STRING) ||
              (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_STRING)) &&
-            !is_bignum_mode(ctx)) {
+            !is_bigint_mode(ctx)) {
             if (tag1 == JS_TAG_STRING) {
                 op1 = JS_StringToBigInt(ctx, op1);
                 if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
@@ -12607,30 +13194,21 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
             }
         }
 
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-        b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-
-        switch(op) {
-        case OP_lt:
-            res = bf_cmp_lt(a, b); /* if NaN return false */
-            break;
-        case OP_lte:
-            res = bf_cmp_le(a, b); /* if NaN return false */
-            break;
-        case OP_gt:
-            res = bf_cmp_lt(b, a); /* if NaN return false */
-            break;
-        default:
-        case OP_gte:
-            res = bf_cmp_le(b, a); /* if NaN return false */
-            break;
+        if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_DECIMAL ||
+            JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_DECIMAL) {
+            res = ctx->rt->bigdecimal_ops.compare(ctx, op, op1, op2);
+            if (res < 0)
+                goto exception;
+        } else if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_FLOAT ||
+                   JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_FLOAT) {
+            res = ctx->rt->bigfloat_ops.compare(ctx, op, op1, op2);
+            if (res < 0)
+                goto exception;
+        } else {
+            res = ctx->rt->bigint_ops.compare(ctx, op, op1, op2);
+            if (res < 0)
+                goto exception;
         }
-        if (a == &a_s)
-            bf_delete(a);
-        if (b == &b_s)
-            bf_delete(b);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
     }
  done:
     sp[-2] = JS_NewBool(ctx, res);
@@ -12644,7 +13222,8 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
 static BOOL tag_is_number(uint32_t tag)
 {
     return (tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
-            tag == JS_TAG_FLOAT64 || tag == JS_TAG_BIG_FLOAT);
+            tag == JS_TAG_FLOAT64 || tag == JS_TAG_BIG_FLOAT ||
+            tag == JS_TAG_BIG_DECIMAL);
 }
 
 static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
@@ -12678,21 +13257,21 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 d2 = JS_VALUE_GET_INT(op2);
             }
             res = (d1 == d2);
+        } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+            res = ctx->rt->bigdecimal_ops.compare(ctx, OP_eq, op1, op2);
+            if (res < 0)
+                goto exception;
+        } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
+            res = ctx->rt->bigfloat_ops.compare(ctx, OP_eq, op1, op2);
+            if (res < 0)
+                goto exception;
         } else {
-            bf_t a_s, b_s, *a, *b;
-            BOOL is_float;
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-            b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
-            res = bf_cmp_eq(a, b);
-            if (a == &a_s)
-                bf_delete(a);
-            if (b == &b_s)
-                bf_delete(b);
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
+            res = ctx->rt->bigint_ops.compare(ctx, OP_eq, op1, op2);
+            if (res < 0)
+                goto exception;
         }
     } else if (tag1 == tag2) {
-        if (tag1 == JS_TAG_OBJECT) {
+        if (tag1 == JS_TAG_OBJECT && ctx->bignum_ext) {
             /* try the fallback operator */
             res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
                                               is_neq ? OP_neq : OP_eq);
@@ -12715,7 +13294,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                (tag2 == JS_TAG_STRING && tag_is_number(tag1))) {
 
         if ((tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
-            !is_bignum_mode(ctx)) {
+            !is_bigint_mode(ctx)) {
             if (tag1 == JS_TAG_STRING) {
                 op1 = JS_StringToBigInt(ctx, op1);
                 if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
@@ -12812,7 +13391,7 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
         goto exception;
     }
     /* XXX: could forbid >>> in bignum mode */
-    if (!is_bignum_mode(ctx) &&
+    if (!is_bigint_mode(ctx) &&
         (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
          JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT)) {
         JS_ThrowTypeError(ctx, "bigint operands are forbidden for >>>");
@@ -12832,31 +13411,36 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
-static double bf_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
-                                      int64_t exponent)
+static JSValue js_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
+                                       int64_t exponent)
 {
     bf_t r_s, *r = &r_s;
     double d;
+    int ret;
+    
     /* always convert to Float64 */
     bf_init(ctx->bf_ctx, r);
-    bf_mul_pow_radix(r, a, 10, exponent,
-                     53, bf_set_exp_bits(11) | BF_RNDN | BF_FLAG_SUBNORMAL);
+    ret = bf_mul_pow_radix(r, a, 10, exponent,
+                           53, bf_set_exp_bits(11) | BF_RNDN |
+                           BF_FLAG_SUBNORMAL);
     bf_get_float64(r, &d, BF_RNDN);
     bf_delete(r);
-    return d;
+    if (ret & BF_ST_MEM_ERROR)
+        return JS_ThrowOutOfMemory(ctx);
+    else
+        return __JS_NewFloat64(ctx, d);
 }
 
 static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
 {
     bf_t a_s, *a, r_s, *r = &r_s;
-    BOOL is_float;
     JSValue op1, op2;
     slimb_t e;
     int ret;
 
     op1 = sp[-2];
     op2 = sp[-1];
-    a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
+    a = JS_ToBigFloat(ctx, &a_s, op1);
     if (!a)
         return -1;
 #if LIMB_BITS == 32
@@ -13299,7 +13883,7 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             goto number_test;
         } else if (tag2 == JS_TAG_FLOAT64) {
 #ifdef CONFIG_BIGNUM
-            if (is_bignum_mode(ctx)) {
+            if (is_bigint_mode(ctx)) {
                 res = FALSE;
             } else
 #endif
@@ -13309,7 +13893,7 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             }
         } else
 #ifdef CONFIG_BIGNUM
-        if (tag2 == JS_TAG_BIG_INT && is_bignum_mode(ctx)) {
+        if (tag2 == JS_TAG_BIG_INT && is_bigint_mode(ctx)) {
             goto bigint_test;
         } else
 #endif
@@ -13323,7 +13907,7 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             d2 = JS_VALUE_GET_FLOAT64(op2);
         } else if (tag2 == JS_TAG_INT
 #ifdef CONFIG_BIGNUM
-                   && !is_bignum_mode(ctx)
+                   && !is_bigint_mode(ctx)
 #endif
                    ) {
             d2 = JS_VALUE_GET_INT(op2);
@@ -13352,23 +13936,22 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
     case JS_TAG_BIG_INT:
         {
             bf_t a_s, *a, b_s, *b;
-            BOOL is_float;
             if (tag1 == tag2) {
                 /* OK */
-            } else if (tag2 == JS_TAG_INT && is_bignum_mode(ctx)) {
+            } else if (tag2 == JS_TAG_INT && is_bigint_mode(ctx)) {
                 /* OK */
             } else {
                 res = FALSE;
                 break;
             }
         bigint_test:
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-            b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
+            a = JS_ToBigFloat(ctx, &a_s, op1);
+            b = JS_ToBigFloat(ctx, &b_s, op2);
             res = bf_cmp_eq(a, b);
             if (a == &a_s)
                 bf_delete(a);
             if (b == &b_s)
-                bf_delete(a);
+                bf_delete(b);
         }
         break;
     case JS_TAG_BIG_FLOAT:
@@ -13395,6 +13978,21 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             }
         }
         break;
+    case JS_TAG_BIG_DECIMAL:
+        {
+            JSBigDecimal *p1, *p2;
+            const bfdec_t *a, *b;
+            if (tag1 != tag2) {
+                res = FALSE;
+                break;
+            }
+            p1 = JS_VALUE_GET_PTR(op1);
+            p2 = JS_VALUE_GET_PTR(op2);
+            a = &p1->num;
+            b = &p2->num;
+            res = bfdec_cmp_eq(a, b);
+        }
+        break;
 #endif
     default:
         res = FALSE;
@@ -13503,7 +14101,7 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
     switch(tag) {
 #ifdef CONFIG_BIGNUM
     case JS_TAG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             atom = JS_ATOM_bigint;
         else
             atom = JS_ATOM_number;
@@ -13517,6 +14115,9 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
     case JS_TAG_BIG_FLOAT:
         atom = JS_ATOM_bigfloat;
         break;
+    case JS_TAG_BIG_DECIMAL:
+        atom = JS_ATOM_bigdecimal;
+        break;
 #else
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
@@ -16715,7 +17316,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     v2 = JS_VALUE_GET_INT(op2);
                     r = (int64_t)v1 * v2;
 #ifdef CONFIG_BIGNUM
-                    if (unlikely((int)r != r) || (r == 0 && !is_bignum_mode(ctx)))
+                    if (unlikely((int)r != r) || (r == 0 && !is_bigint_mode(ctx)))
                         goto binary_arith_slow;
 #else
                     if (unlikely((int)r != r)) {
@@ -16823,7 +17424,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     val = JS_VALUE_GET_INT(op1);
 #ifdef CONFIG_BIGNUM
                     if (unlikely(val == INT32_MIN) ||
-                        (val == 0 && !is_bignum_mode(ctx)))
+                        (val == 0 && !is_bigint_mode(ctx)))
                         goto slow_neg;
 #else
                     /* Note: -0 cannot be expressed as integer */
@@ -16959,7 +17560,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 #ifdef CONFIG_BIGNUM
                     {
                         int64_t r;
-                        if (is_bignum_mode(ctx)) {
+                        if (is_bigint_mode(ctx)) {
                             if (v2 > 0x1f)
                                 goto shl_slow;
                             r = (int64_t)v1 << v2;
@@ -17015,7 +17616,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     v2 = JS_VALUE_GET_INT(op2);
 #ifdef CONFIG_BIGNUM
                     if (unlikely(v2 > 0x1f)) {
-                        if (is_bignum_mode(ctx))
+                        if (is_bigint_mode(ctx))
                             goto sar_slow;
                         else
                             v2 &= 0x1f;
@@ -17117,7 +17718,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
 #ifdef CONFIG_BIGNUM
         CASE(OP_mul_pow10):
-            if (js_mul_pow10(ctx, sp))
+            if (ctx->rt->bigfloat_ops.mul_pow10(ctx, sp))
                 goto exception;
             sp--;
             BREAK;
@@ -19569,112 +20170,46 @@ static __exception int next_token(JSParseState *s)
     case '1' ... '9':
         /* number */
     parse_number:
-#ifdef CONFIG_BIGNUM
-        {
-            const uint8_t *p1;
-            int flags;
-            slimb_t exponent;
-            JSValue val;
-
-            s->token.val = TOK_NUMBER;
-            s->token.u.num.val = JS_UNDEFINED;
-            s->token.u.num.exponent = 0;
-            if (!s->cur_func) {
-                /* JSON: use current float precision */
-                flags = BF_ATOF_THROW;
-                if (is_bignum_mode(s->ctx))
-                    flags |= BF_ATOF_INT_PREC_INF;
-                else
-                    flags |= BF_ATOF_FLOAT64;
-                val = js_atof(s->ctx, (const char *)p, (const char **)&p,
-                              10, flags);
-                if (JS_IsException(val))
-                    goto bad_number;
-            } else {
-                bf_t r_s, *r = &r_s;
-                BOOL bigint_mode, is_bigint, is_bigfloat;
-                int res;
-
-                bigint_mode = (s->cur_func->js_mode & JS_MODE_BIGINT) != 0;
-                flags = BF_ATOF_BIN_OCT | BF_ATOF_LEGACY_OCTAL |
-                    BF_ATOF_UNDERSCORE_SEP | BF_ATOF_INT_PREC_INF | BF_RNDZ;
-                if (!bigint_mode)
-                    flags |= BF_ATOF_ONLY_DEC_FLOAT;
-                p += skip_spaces((char *)p);
-                bf_init(s->ctx->bf_ctx, r);
-                res = bf_atof2(r, &exponent, (const char *)p,
-                               (const char **)&p, 0, BF_PREC_INF, flags);
-                if (bf_is_nan(r)) {
-                    bf_delete(r);
-                    goto bad_number;
-                }
-                is_bigint = FALSE;
-                is_bigfloat = FALSE;
-                if (*p == 'n') {
-                    if (!(res & BF_ATOF_ST_INTEGER) ||
-                        (res & BF_ATOF_ST_LEGACY_OCTAL)) {
-                        bf_delete(r);
-                        goto bad_number;
-                    }
-                    p++;
-                    is_bigint = TRUE;
-                } else if (*p == 'l') {
-                    p++;
-                    is_bigfloat = TRUE;
-                }
-                if ((res & BF_ATOF_ST_INTEGER) && !is_bigfloat &&
-                    (bigint_mode || is_bigint)) {
-                    /* in bigint mode: small integer or bigint
-                       in legacy mode: always a bigint */
-                    val = JS_NewBigInt2(s->ctx, r, bigint_mode ^ 1);
-                } else {
-                    /* `n` suffix is implied in math mode */
-                    if (s->cur_func->js_mode & JS_MODE_MATH)
-                        is_bigfloat = TRUE;
-                    if (is_bigfloat) {
-                        /* infinite precision */
-                        val = JS_NewBigFloat(s->ctx, r);
-                        s->token.u.num.exponent = exponent;
-                    } else {
-                        double d;
-                        d = bf_mul_pow10_to_float64(s->ctx, r, exponent);
-                        bf_delete(r);
-                        val = JS_NewFloat64(s->ctx, d);
-                    }
-                }
-            }
-            s->token.u.num.val = val;
-            if (lre_js_is_ident_next(unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1))) {
-            bad_number:
-                js_parse_error(s, "invalid number literal");
-                goto fail;
-            }
-        }
-#else
         {
             JSValue ret;
             const uint8_t *p1;
             int flags, radix;
             if (!s->cur_func) {
-                flags = ATOD_THROW;
+                flags = 0;
                 radix = 10;
             } else {
-                flags = ATOD_ACCEPT_BIN_OCT | ATOD_THROW | ATOD_ACCEPT_LEGACY_OCTAL |
+                flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL |
                     ATOD_ACCEPT_UNDERSCORES;
+#ifdef CONFIG_BIGNUM
+                flags |= ATOD_ACCEPT_SUFFIX;
+                if (s->cur_func->js_mode & JS_MODE_BIGINT) {
+                    flags |= ATOD_MODE_BIGINT;
+                    if (s->cur_func->js_mode & JS_MODE_MATH)
+                        flags |= ATOD_TYPE_BIG_FLOAT;
+                }
+#endif
                 radix = 0;
             }
-            ret = js_atod(s->ctx, (const char *)p, (const char **)&p, radix,
+#ifdef CONFIG_BIGNUM
+            s->token.u.num.exponent = 0;
+            ret = js_atof2(s->ctx, (const char *)p, (const char **)&p, radix,
+                           flags, &s->token.u.num.exponent);
+#else
+            ret = js_atof(s->ctx, (const char *)p, (const char **)&p, radix,
                           flags);
+#endif
+            if (JS_IsException(ret))
+                goto fail;
             /* reject `10instanceof Number` */
-            if (JS_IsException(ret) ||
+            if (JS_VALUE_IS_NAN(ret) ||
                 lre_js_is_ident_next(unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1))) {
+                JS_FreeValue(s->ctx, ret);
                 js_parse_error(s, "invalid number literal");
                 goto fail;
             }
             s->token.val = TOK_NUMBER;
             s->token.u.num.val = ret;
         }
-#endif
         break;
     case '*':
         if (p[1] == '=') {
@@ -20887,10 +21422,11 @@ static int __exception js_parse_property_name(JSParseState *s,
 #ifdef CONFIG_BIGNUM
         if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            double d;
-            d = bf_mul_pow10_to_float64(s->ctx, &p->num,
-                                        s->token.u.num.exponent);
-            val = __JS_NewFloat64(s->ctx, d);
+            val = s->ctx->rt->bigfloat_ops.
+                mul_pow10_to_float64(s->ctx, &p->num,
+                                     s->token.u.num.exponent);
+            if (JS_IsException(val))
+                goto fail;
             name = JS_ValueToAtom(s->ctx, val);
             JS_FreeValue(s->ctx, val);
         } else
@@ -30972,10 +31508,10 @@ static __exception int js_parse_directives(JSParseState *s)
         }
 #endif
 #ifdef CONFIG_BIGNUM
-        else if (!strcmp(str, "use bigint")) {
+        else if (s->ctx->bignum_ext && !strcmp(str, "use bigint")) {
             s->cur_func->js_mode |= JS_MODE_BIGINT;
         }
-        else if (!strcmp(str, "use math")) {
+        else if (s->ctx->bignum_ext && !strcmp(str, "use math")) {
             s->cur_func->js_mode |= JS_MODE_BIGINT | JS_MODE_MATH;
         }
 #endif
@@ -31864,6 +32400,7 @@ typedef enum BCTagEnum {
     BC_TAG_ARRAY,
     BC_TAG_BIG_INT,
     BC_TAG_BIG_FLOAT,
+    BC_TAG_BIG_DECIMAL,
     BC_TAG_TEMPLATE_OBJECT,
     BC_TAG_FUNCTION_BYTECODE,
     BC_TAG_MODULE,
@@ -31906,8 +32443,9 @@ static const char * const bc_tag_str[] = {
     "string",
     "object",
     "array",
-    "big_int",
-    "big_float",
+    "bigint",
+    "bigfloat",
+    "bigdecimal",
     "template",
     "function",
     "module",
@@ -32145,6 +32683,143 @@ static void JS_WriteString(BCWriterState *s, JSString *p)
     }
 }
 
+#ifdef CONFIG_BIGNUM
+static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
+{
+    uint32_t tag, tag1;
+    int64_t e;
+    JSBigFloat *bf = JS_VALUE_GET_PTR(obj);
+    bf_t *a = &bf->num;
+    size_t len, i, n1, j;
+    limb_t v;
+
+    tag = JS_VALUE_GET_TAG(obj);
+    switch(tag) {
+    case JS_TAG_BIG_INT:
+        tag1 = BC_TAG_BIG_INT;
+        break;
+    case JS_TAG_BIG_FLOAT:
+        tag1 = BC_TAG_BIG_FLOAT;
+        break;
+    case JS_TAG_BIG_DECIMAL:
+        tag1 = BC_TAG_BIG_DECIMAL;
+        break;
+    default:
+        abort();
+    }
+    bc_put_u8(s, tag1);
+
+    /* sign + exponent */
+    if (a->expn == BF_EXP_ZERO)
+        e = 0;
+    else if (a->expn == BF_EXP_INF)
+        e = 1;
+    else if (a->expn == BF_EXP_NAN)
+        e = 2;
+    else if (a->expn >= 0)
+        e = a->expn + 3;
+    else
+        e = a->expn;
+    e = (e << 1) | a->sign;
+    if (e < INT32_MIN || e > INT32_MAX) {
+        JS_ThrowInternalError(s->ctx, "bignum exponent is too large");
+        return -1;
+    }
+    bc_put_sleb128(s, e);
+
+    /* mantissa */
+    if (a->len != 0) {
+        if (tag != JS_TAG_BIG_DECIMAL) {
+            i = 0;
+            while (i < a->len && a->tab[i] == 0)
+                i++;
+            assert(i < a->len);
+            v = a->tab[i];
+            n1 = sizeof(limb_t);
+            while ((v & 0xff) == 0) {
+                n1--;
+                v >>= 8;
+            }
+            i++;
+            len = (a->len - i) * sizeof(limb_t) + n1;
+            if (len > INT32_MAX) {
+                JS_ThrowInternalError(s->ctx, "bignum is too large");
+                return -1;
+            }
+            bc_put_leb128(s, len);
+            /* always saved in byte based little endian representation */
+            for(j = 0; j < n1; j++) {
+                dbuf_putc(&s->dbuf, v >> (j * 8));
+            }
+            for(; i < a->len; i++) {
+                limb_t v = a->tab[i];
+#if LIMB_BITS == 32
+#ifdef WORDS_BIGENDIAN
+                v = bswap32(v);
+#endif
+                dbuf_put_u32(&s->dbuf, v);
+#else
+#ifdef WORDS_BIGENDIAN
+                v = bswap64(v);
+#endif
+                dbuf_put_u64(&s->dbuf, v);
+#endif
+            }
+        } else {
+            int bpos, d;
+            uint8_t v8;
+            size_t i0;
+            
+            /* little endian BCD */
+            i = 0;
+            while (i < a->len && a->tab[i] == 0)
+                i++;
+            assert(i < a->len);
+            len = a->len * LIMB_DIGITS;
+            v = a->tab[i];
+            j = 0;
+            while ((v % 10) == 0) {
+                j++;
+                v /= 10;
+            }
+            len -= j;
+            assert(len > 0);
+            if (len > INT32_MAX) {
+                JS_ThrowInternalError(s->ctx, "bignum is too large");
+                return -1;
+            }
+            bc_put_leb128(s, len);
+            
+            bpos = 0;
+            v8 = 0;
+            i0 = i;
+            for(; i < a->len; i++) {
+                if (i != i0) {
+                    v = a->tab[i];
+                    j = 0;
+                }
+                for(; j < LIMB_DIGITS; j++) {
+                    d = v % 10;
+                    v /= 10;
+                    if (bpos == 0) {
+                        v8 = d;
+                        bpos = 1;
+                    } else {
+                        dbuf_putc(&s->dbuf, v8 | (d << 4));
+                        bpos = 0;
+                    }
+                }
+            }
+            /* flush the last digit */
+            if (bpos) {
+                dbuf_putc(&s->dbuf, v8);
+            }
+        }
+    }
+    return 0;
+}
+#endif /* CONFIG_BIGNUM */
+
 static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
 {
     uint32_t tag = JS_VALUE_GET_NORM_TAG(obj);
@@ -32396,75 +33071,9 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
     case JS_TAG_BIG_FLOAT:
-        {
-            int32_t e;
-            JSBigFloat *bf = JS_VALUE_GET_PTR(obj);
-            bf_t *a = &bf->num;
-            size_t len, i, n1, j;
-            limb_t v;
-
-            bc_put_u8(s, tag == JS_TAG_BIG_INT ? BC_TAG_BIG_INT :
-                      BC_TAG_BIG_FLOAT);
-            if (a->len != 0) {
-                i = 0;
-                while (i < a->len && a->tab[i] == 0)
-                    i++;
-                assert(i < a->len);
-                v = a->tab[i];
-                n1 = sizeof(limb_t);
-                while ((v & 0xff) == 0) {
-                    n1--;
-                    v >>= 8;
-                }
-                i++;
-                len = (a->len - i) * sizeof(limb_t) + n1;
-                if (len > INT32_MAX) {
-                    JS_ThrowInternalError(s->ctx, "bignum is too large");
-                    goto fail;
-                }
-                /* XXX: it would be slightly more efficient to put the
-                   sign in the MSB of the mantissa */
-                bc_put_leb128(s, len * 2 + a->sign);
-                /* always saved in byte based little endian representation */
-                for(j = 0; j < n1; j++) {
-                    dbuf_putc(&s->dbuf, v >> (j * 8));
-                }
-                for(; i < a->len; i++) {
-                    limb_t v = a->tab[i];
-#if LIMB_BITS == 32
-#ifdef WORDS_BIGENDIAN
-                    v = bswap32(v);
-#endif
-                    dbuf_put_u32(&s->dbuf, v);
-#else
-#ifdef WORDS_BIGENDIAN
-                    v = bswap64(v);
-#endif
-                    dbuf_put_u64(&s->dbuf, v);
-#endif
-                }
-#if LIMB_BITS != 32
-                if (a->expn <= INT32_MIN || a->expn >= (INT32_MAX - 1)) {
-                    JS_ThrowInternalError(s->ctx, "bignum exponent is too large");
-                    goto fail;
-                }
-#endif
-                bc_put_sleb128(s, a->expn);
-            } else {
-                bc_put_leb128(s, a->sign); /* length + sign */
-                if (tag == JS_TAG_BIG_FLOAT) {
-                    /* special numbers */
-                    if (a->expn == BF_EXP_ZERO) {
-                        e = 0;
-                    } else if (a->expn == BF_EXP_INF) {
-                        e = 1;
-                    } else {
-                        e = 2;
-                    }
-                    bc_put_u8(s, e);
-                }
-            }
-        }
+    case JS_TAG_BIG_DECIMAL:
+        if (JS_WriteBigNum(s, obj))
+            goto fail;
         break;
 #endif
     default:
@@ -32832,6 +33441,142 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     return 0;
 }
 
+#ifdef CONFIG_BIGNUM
+static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
+{
+    JSValue obj = JS_UNDEFINED;
+    uint8_t v8;
+    int32_t e;
+    uint32_t len;
+    limb_t l, i, n, j;
+    JSBigFloat *p;
+    limb_t v;
+    bf_t *a;
+    int bpos, d;
+    
+    bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
+    
+    p = js_new_bf(s->ctx);
+    if (!p)
+        goto fail;
+    switch(tag) {
+    case BC_TAG_BIG_INT:
+        obj = JS_MKPTR(JS_TAG_BIG_INT, p);
+        break;
+    case BC_TAG_BIG_FLOAT:
+        obj = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
+        break;
+    case BC_TAG_BIG_DECIMAL:
+        obj = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
+        break;
+    default:
+        abort();
+    }
+
+    /* sign + exponent */
+    if (bc_get_sleb128(s, &e))
+        goto fail;
+
+    a = &p->num;
+    a->sign = e & 1;
+    e >>= 1;
+    if (e == 0)
+        a->expn = BF_EXP_ZERO;
+    else if (e == 1)
+        a->expn = BF_EXP_INF;
+    else if (e == 2)
+        a->expn = BF_EXP_NAN;
+    else if (e >= 3)
+        a->expn = e - 3;
+    else
+        a->expn = e;
+
+    /* mantissa */
+    if (a->expn != BF_EXP_ZERO &&
+        a->expn != BF_EXP_INF &&
+        a->expn != BF_EXP_NAN) {
+        if (bc_get_leb128(s, &len))
+            goto fail;
+        bc_read_trace(s, "len=%" PRId64 "\n", (int64_t)len);
+        if (len == 0) {
+            JS_ThrowInternalError(s->ctx, "invalid bignum length");
+            goto fail;
+        }
+        if (tag != BC_TAG_BIG_DECIMAL)
+            l = (len + sizeof(limb_t) - 1) / sizeof(limb_t);
+        else
+            l = (len + LIMB_DIGITS - 1) / LIMB_DIGITS;
+        if (bf_resize(a, l)) {
+            JS_ThrowOutOfMemory(s->ctx);
+            goto fail;
+        }
+        if (tag != BC_TAG_BIG_DECIMAL) {
+            n = len & (sizeof(limb_t) - 1);
+            if (n != 0) {
+                v = 0;
+                for(i = 0; i < n; i++) {
+                    if (bc_get_u8(s, &v8))
+                        goto fail;
+                    v |= (limb_t)v8 << ((sizeof(limb_t) - n + i) * 8);
+                }
+                a->tab[0] = v;
+                i = 1;
+            } else {
+                i = 0;
+            }
+            for(; i < l; i++) {
+#if LIMB_BITS == 32
+                if (bc_get_u32(s, &v))
+                    goto fail;
+#ifdef WORDS_BIGENDIAN
+                v = bswap32(v);
+#endif
+#else
+                if (bc_get_u64(s, &v))
+                    goto fail;
+#ifdef WORDS_BIGENDIAN
+                v = bswap64(v);
+#endif
+#endif
+                a->tab[i] = v;
+            }
+        } else {
+            bpos = 0;
+            for(i = 0; i < l; i++) {
+                if (i == 0 && (n = len % LIMB_DIGITS) != 0) {
+                    j = LIMB_DIGITS - n;
+                } else {
+                    j = 0;
+                }
+                v = 0;
+                for(; j < LIMB_DIGITS; j++) {
+                    if (bpos == 0) {
+                        if (bc_get_u8(s, &v8))
+                            goto fail;
+                        d = v8 & 0xf;
+                        bpos = 1;
+                    } else {
+                        d = v8 >> 4;
+                        bpos = 0;
+                    }
+                    if (d >= 10) {
+                        JS_ThrowInternalError(s->ctx, "invalid digit");
+                        goto fail;
+                    }
+                    v += mp_pow_dec[j] * d;
+                }
+                a->tab[i] = v;
+            }
+        }
+    }
+    bc_read_trace(s, "}\n");
+    return obj;
+ fail:
+    JS_FreeValue(s->ctx, obj);
+    return JS_EXCEPTION;
+}
+#endif /* CONFIG_BIGNUM */
+
 static JSValue JS_ReadObjectRec(BCReaderState *s)
 {
     JSContext *ctx = s->ctx;
@@ -33236,88 +33981,10 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
 #ifdef CONFIG_BIGNUM
     case BC_TAG_BIG_INT:
     case BC_TAG_BIG_FLOAT:
-        {
-            uint8_t sign, v8;
-            int32_t e;
-            uint32_t len;
-            limb_t l, i, n;
-            JSBigFloat *p;
-            bf_t *a;
-
-            bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-
-            if (bc_get_leb128(s, &len))
-                goto fail;
-            sign = len & 1;
-            len >>= 1;
-            p = js_new_bf(s->ctx);
-            if (!p)
-                goto fail;
-            if (tag == BC_TAG_BIG_INT)
-                obj = JS_MKPTR(JS_TAG_BIG_INT, p);
-            else
-                obj = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
-            l = (len + sizeof(limb_t) - 1) / sizeof(limb_t);
-            a = &p->num;
-            bf_resize(a, l);
-            a->sign = sign;
-            if (len == 0) {
-                if (tag == BC_TAG_BIG_INT) {
-                    a->expn = BF_EXP_ZERO;
-                } else {
-                    if (bc_get_u8(s, &v8))
-                        goto fail;
-                    switch(v8) {
-                    case 0:
-                        a->expn = BF_EXP_ZERO;
-                        break;
-                    case 1:
-                        a->expn = BF_EXP_INF;
-                        break;
-                    default:
-                    case 2:
-                        a->expn = BF_EXP_NAN;
-                        break;
-                    }
-                }
-            } else {
-                n = len & (sizeof(limb_t) - 1);
-                if (n != 0) {
-                    limb_t v;
-                    v = 0;
-                    for(i = 0; i < n; i++) {
-                        if (bc_get_u8(s, &v8))
-                            goto fail;
-                        v |= (limb_t)v8 << ((sizeof(limb_t) - n + i) * 8);
-                    }
-                    a->tab[0] = v;
-                    i = 1;
-                } else {
-                    i = 0;
-                }
-                for(; i < l; i++) {
-                    limb_t v;
-#if LIMB_BITS == 32
-                    if (bc_get_u32(s, &v))
-                        goto fail;
-#ifdef WORDS_BIGENDIAN
-                    v = bswap32(v);
-#endif
-#else
-                    if (bc_get_u64(s, &v))
-                        goto fail;
-#ifdef WORDS_BIGENDIAN
-                    v = bswap64(v);
-#endif
-#endif
-                    a->tab[i] = v;
-                }
-                if (bc_get_sleb128(s, &e))
-                    goto fail;
-                a->expn = e;
-            }
-            bc_read_trace(s, "}\n");
-        }
+    case BC_TAG_BIG_DECIMAL:
+        obj = JS_ReadBigNum(s, tag);
+        if (JS_IsException(obj))
+            goto fail;
         break;
 #endif
     default:
@@ -33705,49 +34372,14 @@ static JSValue js_global_isNaN(JSContext *ctx, JSValueConst this_val,
     return JS_NewBool(ctx, isnan(d));
 }
 
-#ifdef CONFIG_BIGNUM
-static BOOL js_number_is_finite(JSContext *ctx, JSValueConst val)
-{
-    BOOL res;
-    uint32_t tag;
-
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_FLOAT64:
-        res = isfinite(JS_VALUE_GET_FLOAT64(val));
-        break;
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            res = bf_is_finite(&p->num);
-        }
-        break;
-    default:
-        res = TRUE;
-        break;
-    }
-    return res;
-}
-#endif
-
 static JSValue js_global_isFinite(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv)
 {
     BOOL res;
-#ifdef CONFIG_BIGNUM
-    JSValue val;
-
-    val = JS_ToNumber(ctx, argv[0]);
-    if (JS_IsException(val))
-        return val;
-    res = js_number_is_finite(ctx, val);
-    JS_FreeValue(ctx, val);
-#else
     double d;
     if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
         return JS_EXCEPTION;
     res = isfinite(d);
-#endif
     return JS_NewBool(ctx, res);
 }
 
@@ -33768,7 +34400,7 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val)
         return JS_DupValue(ctx, val);
 #ifdef CONFIG_BIGNUM
     case JS_TAG_INT:
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
         else
             obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
@@ -33782,6 +34414,9 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val)
     case JS_TAG_BIG_FLOAT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_FLOAT);
         goto set_value;
+    case JS_TAG_BIG_DECIMAL:
+        obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_DECIMAL);
+        goto set_value;
 #else
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
@@ -34499,6 +35134,13 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
     if (!JS_IsObject(obj))
         return JS_DupValue(ctx, obj);
 
+    res = JS_PreventExtensions(ctx, obj);
+    if (res < 0)
+        return JS_EXCEPTION;
+    if (!res) {
+        return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
+    }
+    
     p = JS_VALUE_GET_OBJ(obj);
     flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
     if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
@@ -34524,7 +35166,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
             goto exception;
     }
     js_free_prop_enum(ctx, props, len);
-    return js_object_preventExtensions(ctx, JS_UNDEFINED, 1, argv, 0);
+    return JS_TRUE;
 
  exception:
     js_free_prop_enum(ctx, props, len);
@@ -35374,6 +36016,8 @@ static JSValue js_error_toString(JSContext *ctx, JSValueConst this_val,
 {
     JSValue name, msg;
 
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
     name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
     if (JS_IsUndefined(name))
         name = JS_AtomToString(ctx, JS_ATOM_Error);
@@ -37048,7 +37692,7 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
     JSValue val, obj;
 #ifdef CONFIG_BIGNUM
     if (argc == 0) {
-        if (is_bignum_mode(ctx))
+        if (is_bigint_mode(ctx))
             val = __JS_NewFloat64(ctx, 0);
         else
             val = JS_NewInt32(ctx, 0);
@@ -37068,7 +37712,7 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
             }
             break;
         case JS_TAG_INT:
-            if (is_bignum_mode(ctx)) {
+            if (is_bigint_mode(ctx)) {
                 /* always return a number in bignum mode */
                 val = __JS_NewFloat64(ctx, JS_VALUE_GET_INT(val));
             }
@@ -37199,6 +37843,7 @@ static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
 {
     JSValue val;
     int base;
+    double d;
 
     val = js_thisNumberValue(ctx, this_val);
     if (JS_IsException(val))
@@ -37213,191 +37858,14 @@ static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
             goto fail;
         }
     }
-#ifdef CONFIG_BIGNUM
-    {
-        JSValue ret = js_ftoa(ctx, val, base, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
-        JS_FreeValue(ctx, val);
-        return ret;
-    }
-#else
-    {
-        double d;
-        if (JS_ToFloat64Free(ctx, &d, val))
-            return JS_EXCEPTION;
-        return js_dtoa(ctx, d, base, 0, JS_DTOA_VAR_FORMAT);
-    }
-#endif
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
-
-#ifdef CONFIG_BIGNUM
-
-static JSValue js_thisBigFloatValue(JSContext *ctx, JSValueConst this_val);
-
-static int64_t js_number_get_prec_max(JSContext *ctx, int magic)
-{
-    if (magic)
-        return BF_PREC_MAX;
-    else
-        return 100;
-}
-
-static int get_rnd_mode(JSContext *ctx, JSValueConst val)
-{
-    int rnd_mode;
-    if (JS_ToInt32Sat(ctx, &rnd_mode, val))
-        return -1;
-    if (rnd_mode < BF_RNDN || rnd_mode > BF_RNDF) {
-        JS_ThrowRangeError(ctx, "invalid rounding mode");
-        return -1;
-    }
-    return rnd_mode;
-}
-
-static JSValue js_number_toFixed(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv, int magic)
-{
-    JSValue val, ret;
-    int64_t f;
-    int res, rnd_mode;
-    bf_t a_s, *a, b;
-    BOOL is_float;
-
-    if (magic)
-        val = js_thisBigFloatValue(ctx, this_val);
-    else
-        val = js_thisNumberValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (f < 0 || f > js_number_get_prec_max(ctx, magic)) {
-        JS_ThrowRangeError(ctx, "invalid number of digits");
-        goto fail;
-    }
-    rnd_mode = BF_RNDNA;
-    if (magic && argc > 1) {
-        rnd_mode = get_rnd_mode(ctx, argv[1]);
-        if (rnd_mode < 0)
-            goto fail;
-    }
-
-    a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
-    if (!a)
-        goto fail;
-    bf_init(ctx->bf_ctx, &b);
-    bf_set_float64(&b, 1e21);
-    res = bf_cmpu(a, &b);
-    bf_delete(&b);
-    if (a == &a_s)
-        bf_delete(a);
-    if (res >= 0) {
-        ret = JS_ToString(ctx, val);
-    } else {
-        ret = js_ftoa(ctx, val, 10, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
-    }
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
-
-static JSValue js_number_toExponential(JSContext *ctx, JSValueConst this_val,
-                                       int argc, JSValueConst *argv, int magic)
-{
-    JSValue val, ret;
-    int64_t f;
-    int rnd_mode;
-
-    if (magic)
-        val = js_thisBigFloatValue(ctx, this_val);
-    else
-        val = js_thisNumberValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (!js_number_is_finite(ctx, val)) {
-        ret = JS_ToString(ctx, val);
-    } else if (JS_IsUndefined(argv[0])) {
-        ret = js_ftoa(ctx, val, 10, 0,
-                      BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
-    } else {
-        if (f < 0 || f > js_number_get_prec_max(ctx, magic)) {
-            JS_ThrowRangeError(ctx, "invalid number of digits");
-            goto fail;
-        }
-        rnd_mode = BF_RNDNA;
-        if (magic && argc > 1) {
-            rnd_mode = get_rnd_mode(ctx, argv[1]);
-            if (rnd_mode < 0)
-                goto fail;
-        }
-        ret = js_ftoa(ctx, val, 10, f + 1,
-                      rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
-    }
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
-
-static JSValue js_number_toPrecision(JSContext *ctx, JSValueConst this_val,
-                                     int argc, JSValueConst *argv, int magic)
-{
-    JSValue val, ret;
-    int64_t p;
-    int rnd_mode;
-
-    if (magic)
-        val = js_thisBigFloatValue(ctx, this_val);
-    else
-        val = js_thisNumberValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_IsUndefined(argv[0]))
-        goto to_string;
-    if (JS_ToInt64Sat(ctx, &p, argv[0]))
-        goto fail;
-    if (!js_number_is_finite(ctx, val)) {
-    to_string:
-        ret = JS_ToString(ctx, this_val);
-    } else {
-        if (p < 1 || p > js_number_get_prec_max(ctx, magic)) {
-            JS_ThrowRangeError(ctx, "invalid number of digits");
-            goto fail;
-        }
-        rnd_mode = BF_RNDNA;
-        if (magic && argc > 1) {
-            rnd_mode = get_rnd_mode(ctx, argv[1]);
-            if (rnd_mode < 0)
-                goto fail;
-        }
-        ret = js_ftoa(ctx, val, 10, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
-    }
-    JS_FreeValue(ctx, val);
-    return ret;
+    if (JS_ToFloat64Free(ctx, &d, val))
+        return JS_EXCEPTION;
+    return js_dtoa(ctx, d, base, 0, JS_DTOA_VAR_FORMAT);
  fail:
     JS_FreeValue(ctx, val);
     return JS_EXCEPTION;
-
 }
 
-static const JSCFunctionListEntry js_number_proto_funcs[] = {
-    JS_CFUNC_MAGIC_DEF("toExponential", 1, js_number_toExponential, 0 ),
-    JS_CFUNC_MAGIC_DEF("toFixed", 1, js_number_toFixed, 0 ),
-    JS_CFUNC_MAGIC_DEF("toPrecision", 1, js_number_toPrecision, 0 ),
-    JS_CFUNC_MAGIC_DEF("toString", 1, js_number_toString, 0 ),
-    JS_CFUNC_MAGIC_DEF("toLocaleString", 0, js_number_toString, 1 ),
-    JS_CFUNC_DEF("valueOf", 0, js_number_valueOf ),
-};
-
-#else /* !CONFIG_BIGNUM */
-
 static JSValue js_number_toFixed(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
@@ -37484,14 +37952,11 @@ static const JSCFunctionListEntry js_number_proto_funcs[] = {
     JS_CFUNC_DEF("valueOf", 0, js_number_valueOf ),
 };
 
-#endif /* !CONFIG_BIGNUM */
-
-
 static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
     const char *str, *p;
-    int radix;
+    int radix, flags;
     JSValue ret;
 
     str = JS_ToCString(ctx, argv[0]);
@@ -37506,15 +37971,12 @@ static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
     } else {
         p = str;
         p += skip_spaces(p);
+        flags = ATOD_INT_ONLY | ATOD_ACCEPT_PREFIX_AFTER_SIGN;
 #ifdef CONFIG_BIGNUM
-        int flags;
-        flags = BF_ATOF_INT_ONLY | BF_ATOF_FLOAT64;
-        if (is_bignum_mode(ctx))
-            flags |= BF_ATOF_INT_PREC_INF;
-        ret = js_atof(ctx, p, NULL, radix, flags);
-#else
-        ret = js_atod(ctx, p, NULL, radix, ATOD_INT_ONLY);
+        if (is_bigint_mode(ctx))
+            flags |= ATOD_MODE_BIGINT;
 #endif
+        ret = js_atof(ctx, p, NULL, radix, flags);
     }
     JS_FreeCString(ctx, str);
     return ret;
@@ -37531,12 +37993,7 @@ static JSValue js_parseFloat(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     p = str;
     p += skip_spaces(p);
-#ifdef CONFIG_BIGNUM
-    ret = js_atof(ctx, p, NULL, 10,
-                  BF_ATOF_JS_QUIRKS | BF_ATOF_FLOAT64);
-#else
-    ret = js_atod(ctx, p, NULL, 10, 0);
-#endif
+    ret = js_atof(ctx, p, NULL, 10, 0);
     JS_FreeCString(ctx, str);
     return ret;
 }
@@ -38169,6 +38626,35 @@ static JSValue js_string_includes(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+static int check_regexp_g_flag(JSContext *ctx, JSValueConst regexp)
+{
+    int ret;
+    JSValue flags;
+    
+    ret = js_is_regexp(ctx, regexp);
+    if (ret < 0)
+        return -1;
+    if (ret) {
+        flags = JS_GetProperty(ctx, regexp, JS_ATOM_flags);
+        if (JS_IsException(flags))
+            return -1;
+        if (JS_IsUndefined(flags) || JS_IsNull(flags)) {
+            JS_ThrowTypeError(ctx, "cannot convert to object");
+            return -1;
+        }
+        flags = JS_ToStringFree(ctx, flags);
+        if (JS_IsException(flags))
+            return -1;
+        ret = string_indexof_char(JS_VALUE_GET_STRING(flags), 'g', 0);
+        JS_FreeValue(ctx, flags);
+        if (ret < 0) {
+            JS_ThrowTypeError(ctx, "regexp must have the 'g' flag");
+            return -1;
+        }
+    }
+    return 0;
+}
+
 static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv, int atom)
 {
@@ -38186,31 +38672,9 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(matcher))
             return JS_EXCEPTION;
         if (atom == JS_ATOM_Symbol_matchAll) {
-            int ret;
-            JSValue flags;
-
-            ret = js_is_regexp(ctx, regexp);
-            if (ret < 0)
-                goto fail1;
-            if (ret) {
-                flags = JS_GetProperty(ctx, regexp, JS_ATOM_flags);
-                if (JS_IsException(flags))
-                    goto fail1;
-                if (JS_IsUndefined(flags) || JS_IsNull(flags)) {
-                    JS_ThrowTypeError(ctx, "cannot convert to object");
-                    goto fail1;
-                }
-                flags = JS_ToStringFree(ctx, flags);
-                if (JS_IsException(flags))
-                    goto fail1;
-                ret = string_indexof_char(JS_VALUE_GET_STRING(flags), 'g', 0);
-                JS_FreeValue(ctx, flags);
-                if (ret < 0) {
-                    JS_ThrowTypeError(ctx, "regexp must have the 'g' flag");
-                fail1:
-                    JS_FreeValue(ctx, matcher);
-                    return JS_EXCEPTION;
-                }
+            if (check_regexp_g_flag(ctx, regexp) < 0) {
+                JS_FreeValue(ctx, matcher);
+                return JS_EXCEPTION;
             }
         }
         if (!JS_IsUndefined(matcher) && !JS_IsNull(matcher)) {
@@ -38348,7 +38812,8 @@ static JSValue js_string___GetSubstitution(JSContext *ctx, JSValueConst this_val
 }
 
 static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
+                                 int argc, JSValueConst *argv,
+                                 int is_replaceAll)
 {
     // replace(rx, rep)
     JSValueConst O = this_val, searchValue = argv[0], replaceValue = argv[1];
@@ -38356,7 +38821,8 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
     JSValue str, search_str, replaceValue_str, repl_str;
     JSString *sp, *searchp;
     StringBuffer b_s, *b = &b_s;
-    int pos, functionalReplace;
+    int pos, functionalReplace, endOfLastMatch;
+    BOOL is_first;
 
     if (JS_IsUndefined(O) || JS_IsNull(O))
         return JS_ThrowTypeError(ctx, "cannot convert to object");
@@ -38367,6 +38833,10 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
 
     if (!JS_IsUndefined(searchValue) && !JS_IsNull(searchValue)) {
         JSValue replacer;
+        if (is_replaceAll) {
+            if (check_regexp_g_flag(ctx, searchValue) < 0)
+                return JS_EXCEPTION;
+        }
         replacer = JS_GetProperty(ctx, searchValue, JS_ATOM_Symbol_replace);
         if (JS_IsException(replacer))
             return JS_EXCEPTION;
@@ -38393,34 +38863,54 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
 
     sp = JS_VALUE_GET_STRING(str);
     searchp = JS_VALUE_GET_STRING(search_str);
-
-    pos = string_indexof(sp, searchp, 0);
-    if (pos < 0) {
-        string_buffer_free(b);
-        JS_FreeValue(ctx, search_str);
-        JS_FreeValue(ctx, replaceValue_str);
-        return str;
+    endOfLastMatch = 0;
+    is_first = TRUE;
+    for(;;) {
+        if (unlikely(searchp->len == 0)) {
+            if (is_first)
+                pos = 0;
+            else if (endOfLastMatch >= sp->len)
+                pos = -1;
+            else
+                pos = endOfLastMatch + 1;
+        } else {
+            pos = string_indexof(sp, searchp, endOfLastMatch);
+        }
+        if (pos < 0) {
+            if (is_first) {
+                string_buffer_free(b);
+                JS_FreeValue(ctx, search_str);
+                JS_FreeValue(ctx, replaceValue_str);
+                return str;
+            } else {
+                break;
+            }
+        }
+        if (functionalReplace) {
+            args[0] = search_str;
+            args[1] = JS_NewInt32(ctx, pos);
+            args[2] = str;
+            repl_str = JS_ToStringFree(ctx, JS_Call(ctx, replaceValue, JS_UNDEFINED, 3, args));
+        } else {
+            args[0] = search_str;
+            args[1] = str;
+            args[2] = JS_NewInt32(ctx, pos);
+            args[3] = JS_UNDEFINED;
+            args[4] = JS_UNDEFINED;
+            args[5] = replaceValue_str;
+            repl_str = js_string___GetSubstitution(ctx, JS_UNDEFINED, 6, args);
+        }
+        if (JS_IsException(repl_str))
+            goto exception;
+        
+        string_buffer_concat(b, sp, endOfLastMatch, pos);
+        string_buffer_concat_value_free(b, repl_str);
+        endOfLastMatch = pos + searchp->len;
+        is_first = FALSE;
+        if (!is_replaceAll)
+            break;
     }
-    if (functionalReplace) {
-        args[0] = search_str;
-        args[1] = JS_NewInt32(ctx, pos);
-        args[2] = str;
-        repl_str = JS_ToStringFree(ctx, JS_Call(ctx, replaceValue, JS_UNDEFINED, 3, args));
-    } else {
-        args[0] = search_str;
-        args[1] = str;
-        args[2] = JS_NewInt32(ctx, pos);
-        args[3] = JS_UNDEFINED;
-        args[4] = JS_UNDEFINED;
-        args[5] = replaceValue_str;
-        repl_str = js_string___GetSubstitution(ctx, JS_UNDEFINED, 6, args);
-    }
-    if (JS_IsException(repl_str))
-        goto exception;
-
-    string_buffer_concat(b, sp, 0, pos);
-    string_buffer_concat_value_free(b, repl_str);
-    string_buffer_concat(b, sp, pos + searchp->len, sp->len);
+    string_buffer_concat(b, sp, endOfLastMatch, sp->len);
     JS_FreeValue(ctx, search_str);
     JS_FreeValue(ctx, replaceValue_str);
     JS_FreeValue(ctx, str);
@@ -39165,7 +39655,8 @@ static const JSCFunctionListEntry js_string_proto_funcs[] = {
     JS_CFUNC_DEF("substr", 2, js_string_substr ),
     JS_CFUNC_DEF("slice", 2, js_string_slice ),
     JS_CFUNC_DEF("repeat", 1, js_string_repeat ),
-    JS_CFUNC_DEF("replace", 2, js_string_replace ),
+    JS_CFUNC_MAGIC_DEF("replace", 2, js_string_replace, 0 ),
+    JS_CFUNC_MAGIC_DEF("replaceAll", 2, js_string_replace, 1 ),
     JS_CFUNC_MAGIC_DEF("padEnd", 1, js_string_pad, 1 ),
     JS_CFUNC_MAGIC_DEF("padStart", 1, js_string_pad, 0 ),
     JS_CFUNC_MAGIC_DEF("trim", 0, js_string_trim, 3 ),
@@ -39277,11 +39768,10 @@ enum {
     MATH_OP_DIV,
 };
 
-static JSValue js_math_fop(JSContext *ctx, JSValueConst this_val,
+static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv, int magic)
 {
     bf_t a_s, *a, r_s, *r = &r_s;
-    BOOL is_float;
     JSFloatEnv *fe;
     int rnd_mode;
     JSValue op1;
@@ -39289,7 +39779,7 @@ static JSValue js_math_fop(JSContext *ctx, JSValueConst this_val,
     op1 = JS_ToNumber(ctx, argv[0]);
     if (JS_IsException(op1))
         return op1;
-    a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
+    a = JS_ToBigFloat(ctx, &a_s, op1);
     fe = &ctx->fp_env;
     if (argc > 1) {
         fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
@@ -39320,8 +39810,7 @@ static JSValue js_math_fop(JSContext *ctx, JSValueConst this_val,
         rnd_mode = BF_RNDZ;
     rint:
         bf_set(r, a);
-        fe->status |= bf_rint(r, fe->prec,
-                              (fe->flags & ~BF_RND_MASK) | rnd_mode);
+        fe->status |= bf_rint(r, rnd_mode);
         break;
     case MATH_OP_SQRT:
         fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
@@ -39370,11 +39859,10 @@ static JSValue js_math_fop(JSContext *ctx, JSValueConst this_val,
     return JS_NewBigFloat(ctx, r);
 }
 
-static JSValue js_math_fop2(JSContext *ctx, JSValueConst this_val,
+static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
                             int argc, JSValueConst *argv, int magic)
 {
     bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
-    BOOL is_float;
     JSFloatEnv *fe;
     JSValue op1, op2;
 
@@ -39386,8 +39874,8 @@ static JSValue js_math_fop2(JSContext *ctx, JSValueConst this_val,
         JS_FreeValue(ctx, op1);
         return op2;
     }
-    a = JS_ToBigFloat(ctx, &is_float, &a_s, op1);
-    b = JS_ToBigFloat(ctx, &is_float, &b_s, op2);
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    b = JS_ToBigFloat(ctx, &b_s, op2);
     fe = &ctx->fp_env;
     if (argc > 2) {
         fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
@@ -39498,12 +39986,11 @@ static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
                 }
             } else {
                 bf_t a_s, *a, r_s, *r;
-                BOOL is_float;
                 int res;
 
-                r = JS_ToBigFloat(ctx, &is_float, &r_s, ret);
+                r = JS_ToBigFloat(ctx, &r_s, ret);
                 if (!bf_is_nan(r)) {
-                    a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
+                    a = JS_ToBigFloat(ctx, &a_s, val);
                     res = bf_cmp_full(a, r);
                     if (is_max)
                         res = -res;
@@ -39516,6 +40003,7 @@ static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
                 }
                 if (r == &r_s)
                     bf_delete(r);
+                JS_FreeValue(ctx, val);
             }
         }
     }
@@ -41495,7 +41983,7 @@ static JSValue json_parse_value(JSParseState *s)
                 {
                     int v;
                     v = JS_VALUE_GET_INT(val);
-                    if (v == 0 && !is_bignum_mode(s->ctx))
+                    if (v == 0 && !is_bigint_mode(s->ctx))
                         val = __JS_NewFloat64(ctx, -0.0);
                     else
                         val = JS_NewInt64(ctx, -(int64_t)v);
@@ -46592,13 +47080,15 @@ void JS_AddIntrinsicEval(JSContext *ctx)
 
 #ifdef CONFIG_BIGNUM
 
+/* BigInt */
+
 static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag;
     BOOL is_legacy;
     int ret;
 
-    is_legacy = is_bignum_mode(ctx) ^ 1;
+    is_legacy = is_bigint_mode(ctx) ^ 1;
  redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
@@ -46619,15 +47109,14 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
     case JS_TAG_BIG_FLOAT:
         {
             bf_t *a, a_s, r_s, *r = &r_s;
-            BOOL is_float;
-            a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
+            a = JS_ToBigFloat(ctx, &a_s, val);
             bf_init(ctx->bf_ctx, r);
             if (!bf_is_finite(a)) {
                 JS_FreeValue(ctx, val);
                 val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to bigint");
             } else {
                 bf_set(r, a);
-                ret = bf_rint(r, BF_PREC_INF, BF_RNDZ);
+                ret = bf_rint(r, BF_RNDZ);
                 JS_FreeValue(ctx, val);
                 if (is_legacy && (ret & BF_ST_INEXACT)) {
                     bf_delete(r);
@@ -46642,9 +47131,7 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
         break;
     case JS_TAG_STRING:
         val = JS_StringToBigIntErr(ctx, val);
-        if (JS_IsException(val))
-            break;
-        goto redo;
+        break;
     case JS_TAG_OBJECT:
         val = JS_ToPrimitiveFree(ctx, val,
                                  is_legacy ? HINT_NUMBER : HINT_INTEGER);
@@ -46672,7 +47159,7 @@ static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
     int tag = JS_VALUE_GET_TAG(v);
     if (tag == JS_TAG_BIG_INT)
         return TRUE;
-    if (is_bignum_mode(ctx))
+    if (is_bigint_mode(ctx))
         return tag == JS_TAG_INT;
     else
         return FALSE;
@@ -46715,7 +47202,7 @@ static JSValue js_bigint_toString(JSContext *ctx, JSValueConst this_val,
             goto fail;
         }
     }
-    ret = js_ftoa(ctx, val, base, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
+    ret = js_bigint_to_string1(ctx, val, base);
     JS_FreeValue(ctx, val);
     return ret;
  fail:
@@ -46729,7 +47216,7 @@ static JSValue js_bigint_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisBigIntValue(ctx, this_val);
 }
 
-static JSValue js_integer_div(JSContext *ctx,
+static JSValue js_bigint_div(JSContext *ctx,
                               JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
 {
@@ -46769,7 +47256,7 @@ static JSValue js_integer_div(JSContext *ctx,
     }
 }
 
-static JSValue js_integer_sqrt(JSContext *ctx,
+static JSValue js_bigint_sqrt(JSContext *ctx,
                                JSValueConst this_val,
                                int argc, JSValueConst *argv, int magic)
 {
@@ -46801,7 +47288,7 @@ static JSValue js_integer_sqrt(JSContext *ctx,
     }
 }
 
-static JSValue js_integer_op1(JSContext *ctx,
+static JSValue js_bigint_op1(JSContext *ctx,
                               JSValueConst this_val,
                               int argc, JSValueConst *argv,
                               int magic)
@@ -46831,16 +47318,15 @@ static JSValue js_integer_op1(JSContext *ctx,
         abort();
     }
     JS_FreeBigInt(ctx, a, &a_s);
-    return JS_NewInt64(ctx, res);
+    return JS_NewBigInt64(ctx, res);
 }
 
-static JSValue js_integer_asUintN(JSContext *ctx,
+static JSValue js_bigint_asUintN(JSContext *ctx,
                                   JSValueConst this_val,
                                   int argc, JSValueConst *argv, int asIntN)
 {
     uint64_t bits;
     bf_t a_s, *a = &a_s, r_s, *r = &r_s, mask_s, *mask = &mask_s;
-    BOOL is_legacy;
 
     if (JS_ToIndex(ctx, &bits, argv[0]))
         return JS_EXCEPTION;
@@ -46865,25 +47351,25 @@ static JSValue js_integer_asUintN(JSContext *ctx,
     }
     bf_delete(mask);
     JS_FreeBigInt(ctx, a, &a_s);
-    is_legacy = is_bignum_mode(ctx) ^ 1;
-    return JS_NewBigInt2(ctx, r, is_legacy);
-}
-
-static const JSCFunctionListEntry js_integer_funcs[] = {
-    JS_CFUNC_MAGIC_DEF("tdiv", 2, js_integer_div, BF_RNDZ ),
-    JS_CFUNC_MAGIC_DEF("fdiv", 2, js_integer_div, BF_RNDD ),
-    JS_CFUNC_MAGIC_DEF("cdiv", 2, js_integer_div, BF_RNDU ),
-    JS_CFUNC_MAGIC_DEF("ediv", 2, js_integer_div, BF_DIVREM_EUCLIDIAN ),
-    JS_CFUNC_MAGIC_DEF("tdivrem", 2, js_integer_div, BF_RNDZ | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("fdivrem", 2, js_integer_div, BF_RNDD | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("cdivrem", 2, js_integer_div, BF_RNDU | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("edivrem", 2, js_integer_div, BF_DIVREM_EUCLIDIAN | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_integer_sqrt, 0 ),
-    JS_CFUNC_MAGIC_DEF("sqrtrem", 1, js_integer_sqrt, 1 ),
-    JS_CFUNC_MAGIC_DEF("floorLog2", 1, js_integer_op1, 0 ),
-    JS_CFUNC_MAGIC_DEF("ctz", 1, js_integer_op1, 1 ),
-    JS_CFUNC_MAGIC_DEF("asUintN", 2, js_integer_asUintN, 0 ),
-    JS_CFUNC_MAGIC_DEF("asIntN", 2, js_integer_asUintN, 1 ),
+    return JS_NewBigInt(ctx, r);
+}
+
+static const JSCFunctionListEntry js_bigint_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("asUintN", 2, js_bigint_asUintN, 0 ),
+    JS_CFUNC_MAGIC_DEF("asIntN", 2, js_bigint_asUintN, 1 ),
+    /* QuickJS extensions */
+    JS_CFUNC_MAGIC_DEF("tdiv", 2, js_bigint_div, BF_RNDZ ),
+    JS_CFUNC_MAGIC_DEF("fdiv", 2, js_bigint_div, BF_RNDD ),
+    JS_CFUNC_MAGIC_DEF("cdiv", 2, js_bigint_div, BF_RNDU ),
+    JS_CFUNC_MAGIC_DEF("ediv", 2, js_bigint_div, BF_DIVREM_EUCLIDIAN ),
+    JS_CFUNC_MAGIC_DEF("tdivrem", 2, js_bigint_div, BF_RNDZ | 0x10 ),
+    JS_CFUNC_MAGIC_DEF("fdivrem", 2, js_bigint_div, BF_RNDD | 0x10 ),
+    JS_CFUNC_MAGIC_DEF("cdivrem", 2, js_bigint_div, BF_RNDU | 0x10 ),
+    JS_CFUNC_MAGIC_DEF("edivrem", 2, js_bigint_div, BF_DIVREM_EUCLIDIAN | 0x10 ),
+    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigint_sqrt, 0 ),
+    JS_CFUNC_MAGIC_DEF("sqrtrem", 1, js_bigint_sqrt, 1 ),
+    JS_CFUNC_MAGIC_DEF("floorLog2", 1, js_bigint_op1, 0 ),
+    JS_CFUNC_MAGIC_DEF("ctz", 1, js_bigint_op1, 1 ),
 };
 
 static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
@@ -46892,6 +47378,30 @@ static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "BigInt", JS_PROP_CONFIGURABLE ),
 };
 
+void JS_AddIntrinsicBigInt(JSContext *ctx)
+{
+    JSRuntime *rt = ctx->rt;
+    JSValue obj1;
+
+    rt->bigint_ops.to_string = js_bigint_to_string;
+    rt->bigint_ops.from_string = js_string_to_bigint;
+    rt->bigint_ops.unary_arith = js_unary_arith_bigint;
+    rt->bigint_ops.binary_arith = js_binary_arith_bigint;
+    rt->bigint_ops.compare = js_compare_bigfloat;
+    
+    ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
+                               js_bigint_proto_funcs,
+                               countof(js_bigint_proto_funcs));
+    obj1 = JS_NewCFunction(ctx, js_bigint_constructor, "BigInt", 1);
+    JS_NewGlobalCConstructor2(ctx, obj1, "BigInt",
+                              ctx->class_proto[JS_CLASS_BIG_INT]);
+    JS_SetPropertyFunctionList(ctx, obj1, js_bigint_funcs,
+                               countof(js_bigint_funcs));
+}
+
+/* BigFloat */
+
 static JSValue js_thisBigFloatValue(JSContext *ctx, JSValueConst this_val)
 {
     if (JS_IsBigFloat(this_val))
@@ -46941,12 +47451,164 @@ static JSValue js_bigfloat_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisBigFloatValue(ctx, this_val);
 }
 
+static int get_rnd_mode(JSContext *ctx, JSValueConst val)
+{
+    int rnd_mode;
+    if (JS_ToInt32Sat(ctx, &rnd_mode, val))
+        return -1;
+    if (rnd_mode < BF_RNDN || rnd_mode > BF_RNDF) {
+        JS_ThrowRangeError(ctx, "invalid rounding mode");
+        return -1;
+    }
+    return rnd_mode;
+}
+
+static JSValue js_bigfloat_toFixed(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t f;
+    int res, rnd_mode;
+    bf_t a_s, *a, b;
+
+    val = js_thisBigFloatValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_ToInt64Sat(ctx, &f, argv[0]))
+        goto fail;
+    if (f < 0 || f > BF_PREC_MAX) {
+        JS_ThrowRangeError(ctx, "invalid number of digits");
+        goto fail;
+    }
+    rnd_mode = BF_RNDNA;
+    if (argc > 1) {
+        rnd_mode = get_rnd_mode(ctx, argv[1]);
+        if (rnd_mode < 0)
+            goto fail;
+    }
+
+    a = JS_ToBigFloat(ctx, &a_s, val);
+    if (!a)
+        goto fail;
+    bf_init(ctx->bf_ctx, &b);
+    bf_set_float64(&b, 1e21);
+    res = bf_cmpu(a, &b);
+    bf_delete(&b);
+    if (a == &a_s)
+        bf_delete(a);
+    if (res >= 0) {
+        ret = JS_ToString(ctx, val);
+    } else {
+        ret = js_ftoa(ctx, val, 10, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+    }
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
+}
+
+static BOOL js_bigfloat_is_finite(JSContext *ctx, JSValueConst val)
+{
+    BOOL res;
+    uint32_t tag;
+
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_BIG_FLOAT:
+        {
+            JSBigFloat *p = JS_VALUE_GET_PTR(val);
+            res = bf_is_finite(&p->num);
+        }
+        break;
+    default:
+        res = FALSE;
+        break;
+    }
+    return res;
+}
+
+static JSValue js_bigfloat_toExponential(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t f;
+    int rnd_mode;
+
+    val = js_thisBigFloatValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_ToInt64Sat(ctx, &f, argv[0]))
+        goto fail;
+    if (!js_bigfloat_is_finite(ctx, val)) {
+        ret = JS_ToString(ctx, val);
+    } else if (JS_IsUndefined(argv[0])) {
+        ret = js_ftoa(ctx, val, 10, 0,
+                      BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
+    } else {
+        if (f < 0 || f > BF_PREC_MAX) {
+            JS_ThrowRangeError(ctx, "invalid number of digits");
+            goto fail;
+        }
+        rnd_mode = BF_RNDNA;
+        if (argc > 1) {
+            rnd_mode = get_rnd_mode(ctx, argv[1]);
+            if (rnd_mode < 0)
+                goto fail;
+        }
+        ret = js_ftoa(ctx, val, 10, f + 1,
+                      rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
+    }
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_bigfloat_toPrecision(JSContext *ctx, JSValueConst this_val,
+                                     int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t p;
+    int rnd_mode;
+
+    val = js_thisBigFloatValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_IsUndefined(argv[0]))
+        goto to_string;
+    if (JS_ToInt64Sat(ctx, &p, argv[0]))
+        goto fail;
+    if (!js_bigfloat_is_finite(ctx, val)) {
+    to_string:
+        ret = JS_ToString(ctx, this_val);
+    } else {
+        if (p < 1 || p > BF_PREC_MAX) {
+            JS_ThrowRangeError(ctx, "invalid number of digits");
+            goto fail;
+        }
+        rnd_mode = BF_RNDNA;
+        if (argc > 1) {
+            rnd_mode = get_rnd_mode(ctx, argv[1]);
+            if (rnd_mode < 0)
+                goto fail;
+        }
+        ret = js_ftoa(ctx, val, 10, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
+    }
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
+}
+
 static const JSCFunctionListEntry js_bigfloat_proto_funcs[] = {
     JS_CFUNC_DEF("toString", 0, js_bigfloat_toString ),
     JS_CFUNC_DEF("valueOf", 0, js_bigfloat_valueOf ),
-    JS_CFUNC_MAGIC_DEF("toPrecision", 1, js_number_toPrecision, 1 ),
-    JS_CFUNC_MAGIC_DEF("toFixed", 1, js_number_toFixed, 1 ),
-    JS_CFUNC_MAGIC_DEF("toExponential", 1, js_number_toExponential, 1 ),
+    JS_CFUNC_DEF("toPrecision", 1, js_bigfloat_toPrecision ),
+    JS_CFUNC_DEF("toFixed", 1, js_bigfloat_toFixed ),
+    JS_CFUNC_DEF("toExponential", 1, js_bigfloat_toExponential ),
 };
 
 static JSValue js_bigfloat_constructor(JSContext *ctx,
@@ -47007,9 +47669,13 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
                     val = JS_NewBigFloat(ctx, r);
                     err = 0;
                 } else {
-                    val = js_atof(ctx, p, &p, 0, BF_ATOF_BIN_OCT |
-                                  BF_ATOF_NO_PREFIX_AFTER_SIGN |
-                                  BF_ATOF_JS_QUIRKS);
+                    val = js_atof(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT |
+                                  ATOD_TYPE_BIG_FLOAT |
+                                  ATOD_ACCEPT_PREFIX_AFTER_SIGN);
+                    if (JS_IsException(val)) {
+                        JS_FreeCString(ctx, str);
+                        return JS_EXCEPTION;
+                    }
                     p += skip_spaces(p);
                     err = ((p - str) != len);
                 }
@@ -47035,7 +47701,7 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
     return val;
 }
 
-static JSValue js_float_get_const(JSContext *ctx,
+static JSValue js_bigfloat_get_const(JSContext *ctx,
                                   JSValueConst this_val, int magic)
 {
     bf_t r_s, *r = &r_s;
@@ -47078,8 +47744,8 @@ static JSValue js_float_get_const(JSContext *ctx,
     return JS_NewBigFloat(ctx, r);
 }
 
-static JSValue js_float_parseFloat(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv)
+static JSValue js_bigfloat_parseFloat(JSContext *ctx, JSValueConst this_val,
+                                      int argc, JSValueConst *argv)
 {
     bf_t a_s, *a = &a_s;
     const char *str;
@@ -47106,43 +47772,70 @@ static JSValue js_float_parseFloat(JSContext *ctx, JSValueConst this_val,
             goto fail;
     }
     bf_init(ctx->bf_ctx, a);
-    bf_atof(a, str, NULL, radix, fe->prec, BF_ATOF_JS_QUIRKS | fe->flags);
+    /* XXX: use js_atof() */
+    bf_atof(a, str, NULL, radix, fe->prec, fe->flags);
     ret = JS_NewBigFloat(ctx, a);
     JS_FreeCString(ctx, str);
     return ret;
 }
 
+static JSValue js_bigfloat_isFinite(JSContext *ctx, JSValueConst this_val,
+                                    int argc, JSValueConst *argv)
+{
+    JSValueConst val = argv[0];
+    JSBigFloat *p;
+    
+    if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
+        return JS_FALSE;
+    p = JS_VALUE_GET_PTR(val);
+    return JS_NewBool(ctx, bf_is_finite(&p->num));
+}
+
+static JSValue js_bigfloat_isNaN(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    JSValueConst val = argv[0];
+    JSBigFloat *p;
+    
+    if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
+        return JS_FALSE;
+    p = JS_VALUE_GET_PTR(val);
+    return JS_NewBool(ctx, bf_is_finite(&p->num));
+}
+
 static const JSCFunctionListEntry js_bigfloat_funcs[] = {
-    JS_CGETSET_MAGIC_DEF("PI", js_float_get_const, NULL, 0 ),
-    JS_CGETSET_MAGIC_DEF("LN2", js_float_get_const, NULL, 1 ),
-    JS_CGETSET_MAGIC_DEF("MIN_VALUE", js_float_get_const, NULL, 2 ),
-    JS_CGETSET_MAGIC_DEF("MAX_VALUE", js_float_get_const, NULL, 3 ),
-    JS_CGETSET_MAGIC_DEF("EPSILON", js_float_get_const, NULL, 4 ),
-    JS_CFUNC_DEF("parseFloat", 1, js_float_parseFloat ),
-    JS_CFUNC_MAGIC_DEF("abs", 1, js_math_fop, MATH_OP_ABS ),
-    JS_CFUNC_MAGIC_DEF("fpRound", 1, js_math_fop, MATH_OP_FPROUND ),
-    JS_CFUNC_MAGIC_DEF("floor", 1, js_math_fop, MATH_OP_FLOOR ),
-    JS_CFUNC_MAGIC_DEF("ceil", 1, js_math_fop, MATH_OP_CEIL ),
-    JS_CFUNC_MAGIC_DEF("round", 1, js_math_fop, MATH_OP_ROUND ),
-    JS_CFUNC_MAGIC_DEF("trunc", 1, js_math_fop, MATH_OP_TRUNC ),
-    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_math_fop, MATH_OP_SQRT ),
-    JS_CFUNC_MAGIC_DEF("acos", 1, js_math_fop, MATH_OP_ACOS ),
-    JS_CFUNC_MAGIC_DEF("asin", 1, js_math_fop, MATH_OP_ASIN ),
-    JS_CFUNC_MAGIC_DEF("atan", 1, js_math_fop, MATH_OP_ATAN ),
-    JS_CFUNC_MAGIC_DEF("atan2", 2, js_math_fop2, MATH_OP_ATAN2 ),
-    JS_CFUNC_MAGIC_DEF("cos", 1, js_math_fop, MATH_OP_COS ),
-    JS_CFUNC_MAGIC_DEF("exp", 1, js_math_fop, MATH_OP_EXP ),
-    JS_CFUNC_MAGIC_DEF("log", 1, js_math_fop, MATH_OP_LOG ),
-    JS_CFUNC_MAGIC_DEF("pow", 2, js_math_fop2, MATH_OP_POW ),
-    JS_CFUNC_MAGIC_DEF("sin", 1, js_math_fop, MATH_OP_SIN ),
-    JS_CFUNC_MAGIC_DEF("tan", 1, js_math_fop, MATH_OP_TAN ),
-    JS_CFUNC_MAGIC_DEF("sign", 1, js_math_fop, MATH_OP_SIGN ),
-    JS_CFUNC_MAGIC_DEF("add", 2, js_math_fop2, MATH_OP_ADD ),
-    JS_CFUNC_MAGIC_DEF("sub", 2, js_math_fop2, MATH_OP_SUB ),
-    JS_CFUNC_MAGIC_DEF("mul", 2, js_math_fop2, MATH_OP_MUL ),
-    JS_CFUNC_MAGIC_DEF("div", 2, js_math_fop2, MATH_OP_DIV ),
-    JS_CFUNC_MAGIC_DEF("fmod", 2, js_math_fop2, MATH_OP_FMOD ),
-    JS_CFUNC_MAGIC_DEF("remainder", 2, js_math_fop2, MATH_OP_REM ),
+    JS_CGETSET_MAGIC_DEF("PI", js_bigfloat_get_const, NULL, 0 ),
+    JS_CGETSET_MAGIC_DEF("LN2", js_bigfloat_get_const, NULL, 1 ),
+    JS_CGETSET_MAGIC_DEF("MIN_VALUE", js_bigfloat_get_const, NULL, 2 ),
+    JS_CGETSET_MAGIC_DEF("MAX_VALUE", js_bigfloat_get_const, NULL, 3 ),
+    JS_CGETSET_MAGIC_DEF("EPSILON", js_bigfloat_get_const, NULL, 4 ),
+    JS_CFUNC_DEF("parseFloat", 1, js_bigfloat_parseFloat ),
+    JS_CFUNC_DEF("isFinite", 1, js_bigfloat_isFinite ),
+    JS_CFUNC_DEF("isNaN", 1, js_bigfloat_isNaN ),
+    JS_CFUNC_MAGIC_DEF("abs", 1, js_bigfloat_fop, MATH_OP_ABS ),
+    JS_CFUNC_MAGIC_DEF("fpRound", 1, js_bigfloat_fop, MATH_OP_FPROUND ),
+    JS_CFUNC_MAGIC_DEF("floor", 1, js_bigfloat_fop, MATH_OP_FLOOR ),
+    JS_CFUNC_MAGIC_DEF("ceil", 1, js_bigfloat_fop, MATH_OP_CEIL ),
+    JS_CFUNC_MAGIC_DEF("round", 1, js_bigfloat_fop, MATH_OP_ROUND ),
+    JS_CFUNC_MAGIC_DEF("trunc", 1, js_bigfloat_fop, MATH_OP_TRUNC ),
+    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigfloat_fop, MATH_OP_SQRT ),
+    JS_CFUNC_MAGIC_DEF("acos", 1, js_bigfloat_fop, MATH_OP_ACOS ),
+    JS_CFUNC_MAGIC_DEF("asin", 1, js_bigfloat_fop, MATH_OP_ASIN ),
+    JS_CFUNC_MAGIC_DEF("atan", 1, js_bigfloat_fop, MATH_OP_ATAN ),
+    JS_CFUNC_MAGIC_DEF("atan2", 2, js_bigfloat_fop2, MATH_OP_ATAN2 ),
+    JS_CFUNC_MAGIC_DEF("cos", 1, js_bigfloat_fop, MATH_OP_COS ),
+    JS_CFUNC_MAGIC_DEF("exp", 1, js_bigfloat_fop, MATH_OP_EXP ),
+    JS_CFUNC_MAGIC_DEF("log", 1, js_bigfloat_fop, MATH_OP_LOG ),
+    JS_CFUNC_MAGIC_DEF("pow", 2, js_bigfloat_fop2, MATH_OP_POW ),
+    JS_CFUNC_MAGIC_DEF("sin", 1, js_bigfloat_fop, MATH_OP_SIN ),
+    JS_CFUNC_MAGIC_DEF("tan", 1, js_bigfloat_fop, MATH_OP_TAN ),
+    JS_CFUNC_MAGIC_DEF("sign", 1, js_bigfloat_fop, MATH_OP_SIGN ),
+    JS_CFUNC_MAGIC_DEF("add", 2, js_bigfloat_fop2, MATH_OP_ADD ),
+    JS_CFUNC_MAGIC_DEF("sub", 2, js_bigfloat_fop2, MATH_OP_SUB ),
+    JS_CFUNC_MAGIC_DEF("mul", 2, js_bigfloat_fop2, MATH_OP_MUL ),
+    JS_CFUNC_MAGIC_DEF("div", 2, js_bigfloat_fop2, MATH_OP_DIV ),
+    JS_CFUNC_MAGIC_DEF("fmod", 2, js_bigfloat_fop2, MATH_OP_FMOD ),
+    JS_CFUNC_MAGIC_DEF("remainder", 2, js_bigfloat_fop2, MATH_OP_REM ),
 };
 
 /* FloatEnv */
@@ -47271,7 +47964,7 @@ static JSValue js_float_env_proto_get_status(JSContext *ctx, JSValueConst this_v
     }
 }
 
-static JSValue js_float_env_proto_set_status(JSContext *ctx, JSValueConst this_val, JSValue val, int magic)
+static JSValue js_float_env_proto_set_status(JSContext *ctx, JSValueConst this_val, JSValueConst val, int magic)
 {
     JSFloatEnv *fe;
     int b;
@@ -47368,6 +48061,391 @@ static const JSCFunctionListEntry js_float_env_proto_funcs[] = {
     JS_CFUNC_DEF("clearStatus", 0, js_float_env_clearStatus ),
 };
 
+void JS_AddIntrinsicBigFloat(JSContext *ctx)
+{
+    JSRuntime *rt = ctx->rt;
+    JSValue obj1;
+    JSValueConst obj2;
+    
+    rt->bigfloat_ops.to_string = js_bigfloat_to_string;
+    rt->bigfloat_ops.from_string = js_string_to_bigfloat;
+    rt->bigfloat_ops.unary_arith = js_unary_arith_bigfloat;
+    rt->bigfloat_ops.binary_arith = js_binary_arith_bigfloat;
+    rt->bigfloat_ops.compare = js_compare_bigfloat;
+    rt->bigfloat_ops.mul_pow10_to_float64 = js_mul_pow10_to_float64;
+    rt->bigfloat_ops.mul_pow10 = js_mul_pow10;
+    
+    ctx->class_proto[JS_CLASS_BIG_FLOAT] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT],
+                               js_bigfloat_proto_funcs,
+                               countof(js_bigfloat_proto_funcs));
+    obj1 = JS_NewCFunction(ctx, js_bigfloat_constructor, "BigFloat", 1);
+    JS_NewGlobalCConstructor2(ctx, obj1, "BigFloat",
+                              ctx->class_proto[JS_CLASS_BIG_FLOAT]);
+    JS_SetPropertyFunctionList(ctx, obj1, js_bigfloat_funcs,
+                               countof(js_bigfloat_funcs));
+
+    ctx->class_proto[JS_CLASS_FLOAT_ENV] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FLOAT_ENV],
+                               js_float_env_proto_funcs,
+                               countof(js_float_env_proto_funcs));
+    obj2 = JS_NewGlobalCConstructorOnly(ctx, "BigFloatEnv",
+                                        js_float_env_constructor, 1,
+                                        ctx->class_proto[JS_CLASS_FLOAT_ENV]);
+    JS_SetPropertyFunctionList(ctx, obj2, js_float_env_funcs,
+                               countof(js_float_env_funcs));
+}
+
+/* BigDecimal */
+
+static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
+                                   BOOL allow_null_or_undefined)
+{
+ redo:
+    switch(JS_VALUE_GET_NORM_TAG(val)) {
+    case JS_TAG_BIG_DECIMAL:
+        break;
+    case JS_TAG_NULL:
+        if (!allow_null_or_undefined)
+            goto fail;
+        /* fall thru */
+    case JS_TAG_BOOL:
+    case JS_TAG_INT:
+        {
+            bfdec_t r_s, *r = &r_s;
+            bfdec_init(ctx->bf_ctx, r);
+            bfdec_set_si(r, JS_VALUE_GET_INT(val));
+            val = JS_NewBigDecimal(ctx, r);
+        }
+        break;
+    case JS_TAG_FLOAT64:
+    case JS_TAG_BIG_INT:
+    case JS_TAG_BIG_FLOAT:
+        val = JS_ToStringFree(ctx, val);
+        if (JS_IsException(val))
+            break;
+        goto redo;
+    case JS_TAG_STRING:
+        {
+            const char *str, *p;
+            size_t len;
+            int err;
+
+            str = JS_ToCStringLen(ctx, &len, val);
+            JS_FreeValue(ctx, val);
+            if (!str)
+                return JS_EXCEPTION;
+            p = str;
+            p += skip_spaces(p);
+            if ((p - str) == len) {
+                bfdec_t r_s, *r = &r_s;
+                bfdec_init(ctx->bf_ctx, r);
+                bfdec_set_zero(r, 0);
+                val = JS_NewBigDecimal(ctx, r);
+                err = 0;
+            } else {
+                val = js_atof(ctx, p, &p, 0, ATOD_TYPE_BIG_DECIMAL);
+                if (JS_IsException(val)) {
+                    JS_FreeCString(ctx, str);
+                    return JS_EXCEPTION;
+                }
+                p += skip_spaces(p);
+                err = ((p - str) != len);
+            }
+            JS_FreeCString(ctx, str);
+            if (err) {
+                JS_FreeValue(ctx, val);
+                return JS_ThrowSyntaxError(ctx, "invalid bigdecimal literal");
+            }
+        }
+        break;
+    case JS_TAG_OBJECT:
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+        if (JS_IsException(val))
+            break;
+        goto redo;
+    case JS_TAG_UNDEFINED:
+        {
+            bfdec_t r_s, *r = &r_s;
+            if (!allow_null_or_undefined)
+                goto fail;
+            bfdec_init(ctx->bf_ctx, r);
+            bfdec_set_nan(r);
+            val = JS_NewBigDecimal(ctx, r);
+        }
+        break;
+    default:
+    fail:
+        JS_FreeValue(ctx, val);
+        return JS_ThrowTypeError(ctx, "cannot convert to bigdecimal");
+    }
+    return val;
+}
+
+static JSValue js_bigdecimal_constructor(JSContext *ctx,
+                                         JSValueConst this_val,
+                                         int argc, JSValueConst *argv)
+{
+    JSValue val;
+    if (argc == 0) {
+        bfdec_t r_s, *r = &r_s;
+        bfdec_init(ctx->bf_ctx, r);
+        bfdec_set_zero(r, 0);
+        val = JS_NewBigDecimal(ctx, r);
+    } else {
+        val = JS_ToBigDecimalFree(ctx, JS_DupValue(ctx, argv[0]), FALSE);
+    }
+    return val;
+}
+
+static JSValue js_thisBigDecimalValue(JSContext *ctx, JSValueConst this_val)
+{
+    if (JS_IsBigDecimal(this_val))
+        return JS_DupValue(ctx, this_val);
+
+    if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(this_val);
+        if (p->class_id == JS_CLASS_BIG_DECIMAL) {
+            if (JS_IsBigDecimal(p->u.object_data))
+                return JS_DupValue(ctx, p->u.object_data);
+        }
+    }
+    return JS_ThrowTypeError(ctx, "not a bigdecimal");
+}
+
+static JSValue js_bigdecimal_toString(JSContext *ctx, JSValueConst this_val,
+                                      int argc, JSValueConst *argv)
+{
+    JSValue val;
+
+    val = js_thisBigDecimalValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    return JS_ToStringFree(ctx, val);
+}
+
+static JSValue js_bigdecimal_valueOf(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
+{
+    return js_thisBigDecimalValue(ctx, this_val);
+}
+
+typedef struct {
+    int64_t prec;
+    bf_flags_t flags;
+} BigDecimalEnv;
+
+static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
+                                 JSValueConst obj)
+{
+    JSValue prop;
+    const char *str;
+    size_t size;
+    int64_t val;
+    BOOL has_prec;
+    
+    if (!JS_IsObject(obj)) {
+        JS_ThrowTypeErrorNotAnObject(ctx);
+        return -1;
+    }
+    prop = JS_GetProperty(ctx, obj, JS_ATOM_roundingMode);
+    if (JS_IsException(prop))
+        return -1;
+    str = JS_ToCStringLen(ctx, &size, prop);
+    JS_FreeValue(ctx, prop);
+    if (!str)
+        return -1;
+    if (strlen(str) != size)
+        goto invalid_rounding_mode;
+    if (!strcmp(str, "floor")) {
+        fe->flags = BF_RNDD;
+    } else if (!strcmp(str, "ceiling")) {
+        fe->flags = BF_RNDU;
+    } else if (!strcmp(str, "down")) {
+        fe->flags = BF_RNDZ;
+    } else if (!strcmp(str, "half-even")) {
+        fe->flags = BF_RNDN;
+    } else if (!strcmp(str, "half-up")) {
+        fe->flags = BF_RNDNA;
+    } else {
+    invalid_rounding_mode:
+        JS_FreeCString(ctx, str);
+        JS_ThrowTypeError(ctx, "invalid rounding mode");
+        return -1;
+    }
+    JS_FreeCString(ctx, str);
+    
+    prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
+    if (JS_IsException(prop))
+        return -1;
+    has_prec = FALSE;
+    if (!JS_IsUndefined(prop)) {
+        if (JS_ToInt64SatFree(ctx, &val, prop))
+            return -1;
+        if (val < 0 || val > BF_PREC_MAX)
+            goto invalid_precision;
+        fe->prec = val;
+        has_prec = TRUE;
+    }
+
+    prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumFractionDigits);
+    if (JS_IsException(prop))
+        return -1;
+    if (!JS_IsUndefined(prop)) {
+        if (has_prec) {
+            JS_FreeValue(ctx, prop);
+            JS_ThrowTypeError(ctx, "cannot provide both maximumSignificantDigits and maximumFractionDigits");
+            return -1;
+        }
+        if (JS_ToInt64SatFree(ctx, &val, prop))
+            return -1;
+        if (val < 0 || val > BF_PREC_MAX) {
+        invalid_precision:
+            JS_ThrowTypeError(ctx, "invalid precision");
+            return -1;
+        }
+        fe->prec = val;
+        fe->flags |= BF_FLAG_RADPNT_PREC;
+        has_prec = TRUE;
+    }
+    if (!has_prec) {
+        JS_ThrowTypeError(ctx, "precision must be present");
+        return -1;
+    }
+    return 0;
+}
+
+
+static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv, int magic)
+{
+    bfdec_t *a, *b, r_s, *r = &r_s;
+    JSValue op1, op2;
+    BigDecimalEnv fe_s, *fe = &fe_s;
+    int op_count, ret;
+
+    if (magic == MATH_OP_SQRT ||
+        magic == MATH_OP_ROUND)
+        op_count = 1;
+    else
+        op_count = 2;
+    
+    op1 = JS_ToNumeric(ctx, argv[0]);
+    if (JS_IsException(op1))
+        return op1;
+    a = JS_ToBigDecimal(ctx, op1);
+    if (!a) {
+        JS_FreeValue(ctx, op1);
+        return JS_EXCEPTION;
+    }
+    if (op_count >= 2) {
+        op2 = JS_ToNumeric(ctx, argv[1]);
+        if (JS_IsException(op2)) {
+            JS_FreeValue(ctx, op1);
+            return op2;
+        }
+        b = JS_ToBigDecimal(ctx, op2);
+        if (!b)
+            goto fail;
+    } else {
+        op2 = JS_UNDEFINED;
+        b = NULL;
+    }
+    fe->flags = BF_RNDZ;
+    fe->prec = BF_PREC_INF;
+    if (op_count < argc) {
+        if (js_bigdecimal_get_env(ctx, fe, argv[op_count])) {
+        fail:
+            JS_FreeValue(ctx, op1);
+            JS_FreeValue(ctx, op2);
+            return JS_EXCEPTION;
+        }
+        if ((fe->flags & BF_FLAG_RADPNT_PREC) &&
+            magic != MATH_OP_DIV &&
+            magic != MATH_OP_ROUND) {
+            JS_ThrowTypeError(ctx, "maximumFractionDigits is not supported for this operation");
+            goto fail;
+        }
+    }
+
+    bfdec_init(ctx->bf_ctx, r);
+    switch (magic) {
+    case MATH_OP_ADD:
+        ret = bfdec_add(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_SUB:
+        ret = bfdec_sub(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_MUL:
+        ret = bfdec_mul(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_DIV:
+        ret = bfdec_div(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_SQRT:
+        ret = bfdec_sqrt(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_ROUND:
+        ret = bfdec_set(r, a);
+        if (!(ret & BF_ST_MEM_ERROR))
+            ret = bfdec_round(r, fe->prec, fe->flags);
+        break;
+    default:
+        abort();
+    }
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    ret &= BF_ST_MEM_ERROR | BF_ST_DIVIDE_ZERO | BF_ST_INVALID_OP |
+        BF_ST_OVERFLOW;
+    if (ret != 0) {
+        bfdec_delete(r);
+        return throw_bf_exception(ctx, ret);
+    } else {
+        return JS_NewBigDecimal(ctx, r);
+    }
+}
+
+static const JSCFunctionListEntry js_bigdecimal_proto_funcs[] = {
+    JS_CFUNC_DEF("toString", 0, js_bigdecimal_toString ),
+    JS_CFUNC_DEF("valueOf", 0, js_bigdecimal_valueOf ),
+};
+
+static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("add", 2, js_bigdecimal_fop, MATH_OP_ADD ),
+    JS_CFUNC_MAGIC_DEF("sub", 2, js_bigdecimal_fop, MATH_OP_SUB ),
+    JS_CFUNC_MAGIC_DEF("mul", 2, js_bigdecimal_fop, MATH_OP_MUL ),
+    JS_CFUNC_MAGIC_DEF("div", 2, js_bigdecimal_fop, MATH_OP_DIV ),
+    JS_CFUNC_MAGIC_DEF("round", 1, js_bigdecimal_fop, MATH_OP_ROUND ),
+    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigdecimal_fop, MATH_OP_SQRT ),
+};
+
+void JS_AddIntrinsicBigDecimal(JSContext *ctx)
+{
+    JSRuntime *rt = ctx->rt;
+    JSValue obj1;
+
+    rt->bigdecimal_ops.to_string = js_bigdecimal_to_string;
+    rt->bigdecimal_ops.from_string = js_string_to_bigdecimal;
+    rt->bigdecimal_ops.unary_arith = js_unary_arith_bigdecimal;
+    rt->bigdecimal_ops.binary_arith = js_binary_arith_bigdecimal;
+    rt->bigdecimal_ops.compare = js_compare_bigdecimal;
+
+    ctx->class_proto[JS_CLASS_BIG_DECIMAL] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL],
+                               js_bigdecimal_proto_funcs,
+                               countof(js_bigdecimal_proto_funcs));
+    obj1 = JS_NewCFunction(ctx, js_bigdecimal_constructor, "BigDecimal", 1);
+    JS_NewGlobalCConstructor2(ctx, obj1, "BigDecimal",
+                              ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
+    JS_SetPropertyFunctionList(ctx, obj1, js_bigdecimal_funcs,
+                               countof(js_bigdecimal_funcs));
+}
+
+void JS_EnableBignumExt(JSContext *ctx, BOOL enable)
+{
+    ctx->bignum_ext = enable;
+}
+
 #endif /* CONFIG_BIGNUM */
 
 static const char * const native_error_name[JS_NATIVE_ERROR_COUNT] = {
@@ -47608,37 +48686,6 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                        0, JS_PROP_CONFIGURABLE);
     JS_FreeValue(ctx, obj1);
 
-#ifdef CONFIG_BIGNUM
-    ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
-                               js_bigint_proto_funcs,
-                               countof(js_bigint_proto_funcs));
-    obj1 = JS_NewCFunction(ctx, js_bigint_constructor, "BigInt", 1);
-    JS_NewGlobalCConstructor2(ctx, obj1, "BigInt",
-                              ctx->class_proto[JS_CLASS_BIG_INT]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_integer_funcs,
-                               countof(js_integer_funcs));
-
-    ctx->class_proto[JS_CLASS_BIG_FLOAT] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT],
-                               js_bigfloat_proto_funcs,
-                               countof(js_bigfloat_proto_funcs));
-    obj1 = JS_NewCFunction(ctx, js_bigfloat_constructor, "BigFloat", 1);
-    JS_NewGlobalCConstructor2(ctx, obj1, "BigFloat",
-                              ctx->class_proto[JS_CLASS_BIG_FLOAT]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_bigfloat_funcs,
-                               countof(js_bigfloat_funcs));
-
-    ctx->class_proto[JS_CLASS_FLOAT_ENV] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FLOAT_ENV],
-                               js_float_env_proto_funcs,
-                               countof(js_float_env_proto_funcs));
-    obj1 = JS_NewGlobalCConstructorOnly(ctx, "BigFloatEnv",
-                                        js_float_env_constructor, 1,
-                                        ctx->class_proto[JS_CLASS_FLOAT_ENV]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_float_env_funcs,
-                               countof(js_float_env_funcs));
-#endif
     /* global properties */
     ctx->eval_obj = JS_NewCFunction(ctx, js_global_eval, "eval", 1);
     JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_eval,
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 5a06acef48..8fcd7e5c7f 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -1,8 +1,8 @@
 /*
  * QuickJS Javascript Engine
  *
- * Copyright (c) 2017-2019 Fabrice Bellard
- * Copyright (c) 2017-2019 Charlie Gordon
+ * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2020 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -66,7 +66,8 @@ typedef uint32_t JSAtom;
 
 enum {
     /* all tags with a reference count are negative */
-    JS_TAG_FIRST       = -10, /* first negative tag */
+    JS_TAG_FIRST       = -11, /* first negative tag */
+    JS_TAG_BIG_DECIMAL = -11,
     JS_TAG_BIG_INT     = -10,
     JS_TAG_BIG_FLOAT   = -9,
     JS_TAG_SYMBOL      = -8,
@@ -121,6 +122,11 @@ static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
     return JS_MKVAL(JS_TAG_FLOAT64, (int)d);
 }
 
+static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
+{
+    return 0;
+}
+    
 #elif defined(JS_NAN_BOXING)
 
 typedef uint64_t JSValue;
@@ -179,6 +185,13 @@ static inline int JS_VALUE_GET_NORM_TAG(JSValue v)
         return tag;
 }
 
+static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
+{
+    uint32_t tag;
+    tag = JS_VALUE_GET_TAG(v);
+    return tag == (JS_NAN >> 32);
+}
+    
 #else /* !JS_NAN_BOXING */
 
 typedef union JSValueUnion {
@@ -217,6 +230,18 @@ static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
     return v;
 }
 
+static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
+{
+    union {
+        double d;
+        uint64_t u64;
+    } u;
+    if (v.tag != JS_TAG_FLOAT64)
+        return 0;
+    u.d = v.u.float64;
+    return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;
+}
+
 #endif /* !JS_NAN_BOXING */
 
 #define JS_VALUE_IS_BOTH_INT(v1, v2) ((JS_VALUE_GET_TAG(v1) | JS_VALUE_GET_TAG(v2)) == 0)
@@ -338,6 +363,12 @@ void JS_AddIntrinsicProxy(JSContext *ctx);
 void JS_AddIntrinsicMapSet(JSContext *ctx);
 void JS_AddIntrinsicTypedArrays(JSContext *ctx);
 void JS_AddIntrinsicPromise(JSContext *ctx);
+void JS_AddIntrinsicBigInt(JSContext *ctx);
+void JS_AddIntrinsicBigFloat(JSContext *ctx);
+void JS_AddIntrinsicBigDecimal(JSContext *ctx);
+/* enable "use bigint", "use math" and operator overloading */
+void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
+
 JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv);
 
@@ -514,6 +545,12 @@ static inline JS_BOOL JS_IsBigFloat(JSValueConst v)
     return tag == JS_TAG_BIG_FLOAT;
 }
 
+static inline JS_BOOL JS_IsBigDecimal(JSValueConst v)
+{
+    int tag = JS_VALUE_GET_TAG(v);
+    return tag == JS_TAG_BIG_DECIMAL;
+}
+
 static inline JS_BOOL JS_IsBool(JSValueConst v)
 {
     return JS_VALUE_GET_TAG(v) == JS_TAG_BOOL;

From 42a2a1b6bee8a207ac69b3b2b90cae944d8fae41 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 30 Jan 2020 12:19:12 +0300
Subject: [PATCH 044/185] Reregister class in new runtime. hopefully fixes #8

---
 quickjspp.hpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 398b640abe..ca4fc0889e 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -460,6 +460,11 @@ struct js_traits<std::shared_ptr<T>>
     static void register_class(JSContext * ctx, const char * name, JSValue proto = JS_NULL)
     {
         if(QJSClassId == 0)
+        {
+            JS_NewClassID(&QJSClassId);
+        }
+        auto rt = JS_GetRuntime(ctx);
+        if(!JS_IsRegisteredClass(rt, QJSClassId))
         {
             JSClassDef def{
                     name,
@@ -474,7 +479,7 @@ struct js_traits<std::shared_ptr<T>>
                         atraits::deallocate(alloc, pptr, 1);
                     }
             };
-            int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+            int e = JS_NewClass(rt, QJSClassId, &def);
             if(e < 0)
             {
                 JS_ThrowInternalError(ctx, "Cant register class %s", name);
@@ -595,7 +600,12 @@ struct js_traits<detail::function>
     // TODO: replace ctx with rt
     static void register_class(JSContext * ctx, const char * name)
     {
-        if(QJSClassId)
+        if(QJSClassId == 0)
+        {
+            JS_NewClassID(&QJSClassId);
+        }
+        auto rt = JS_GetRuntime(ctx);
+        if(JS_IsRegisteredClass(rt, QJSClassId))
             return;
         JSClassDef def{
                 name,
@@ -617,7 +627,7 @@ struct js_traits<detail::function>
                     return ptr->invoker(ptr, ctx, this_val, argc, argv);
                 }
         };
-        int e = JS_NewClass(JS_GetRuntime(ctx), JS_NewClassID(&QJSClassId), &def);
+        int e = JS_NewClass(rt, QJSClassId, &def);
         if(e < 0)
             throw std::runtime_error{"Cannot register C++ function class"};
     }

From e854e2ecf21a2314ba33bb990400ad559ee132b0 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 30 Jan 2020 12:26:08 +0300
Subject: [PATCH 045/185] update quickjs to 2020-01-19

---
 quickjs/CMakeLists.txt   |    2 +-
 quickjs/VERSION          |    2 +-
 quickjs/libbf.c          | 1116 +++++++------
 quickjs/libbf.h          |  119 +-
 quickjs/quickjs-atom.h   |   26 +-
 quickjs/quickjs-libc.c   |   15 +
 quickjs/quickjs-opcode.h |    3 -
 quickjs/quickjs.c        | 3206 +++++++++++++++++++++-----------------
 quickjs/quickjs.h        |   16 +-
 9 files changed, 2574 insertions(+), 1931 deletions(-)

diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index b6733b7e3f..e794a03ef5 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -4,7 +4,7 @@ project(quickjs LANGUAGES C)
 file(STRINGS VERSION version)
 
 set(quickjs_src quickjs.c libbf.c libunicode.c libregexp.c cutils.c quickjs-libc.c)
-set(quickjs_def CONFIG_VERSION="${version}" _GNU_SOURCE)
+set(quickjs_def CONFIG_VERSION="${version}" _GNU_SOURCE CONFIG_BIGNUM)
 
 
 add_library(quickjs ${quickjs_src})
diff --git a/quickjs/VERSION b/quickjs/VERSION
index 242aa927f4..ceac556894 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-01-05
+2020-01-19
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 25e856d222..829d8031c1 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -86,7 +86,6 @@ static no_inline int fft_mul(bf_context_t *s,
 static void fft_clear_cache(bf_context_t *s);
 #endif
 #ifdef USE_BF_DEC
-static void mp_pow_init(void);
 static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos);
 #endif
 
@@ -154,6 +153,17 @@ static inline limb_t smod(slimb_t a, slimb_t b)
     return a;
 }
 
+/* signed addition with saturation */
+static inline slimb_t sat_add(slimb_t a, slimb_t b)
+{
+    slimb_t r;
+    r = a + b;
+    /* overflow ? */
+    if (((a ^ r) & (b ^ r)) < 0)
+        r = (a >> (LIMB_BITS - 1)) ^ (((limb_t)1 << (LIMB_BITS - 1)) - 1);
+    return r;
+}
+
 #define malloc(s) malloc_is_forbidden(s)
 #define free(p) free_is_forbidden(p)
 #define realloc(p, s) realloc_is_forbidden(p, s)
@@ -164,9 +174,6 @@ void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
     memset(s, 0, sizeof(*s));
     s->realloc_func = realloc_func;
     s->realloc_opaque = realloc_opaque;
-#ifdef USE_BF_DEC
-    mp_pow_init();
-#endif
 }
 
 void bf_context_end(bf_context_t *s)
@@ -422,18 +429,13 @@ static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
         if (r->sign == (rnd_mode == BF_RNDD))
             add_one = inexact;
         break;
+    case BF_RNDA:
+        add_one = inexact;
+        break;
     case BF_RNDNA:
     case BF_RNDF:
         add_one = bit1;
         break;
-    case BF_RNDNU:
-        if (bit1) {
-            if (r->sign)
-                add_one = bit0;
-            else
-                add_one = 1;
-        }
-        break;
     default:
         abort();
     }
@@ -452,7 +454,7 @@ static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
     if (prec == BF_PREC_INF ||
         rnd_mode == BF_RNDN ||
         rnd_mode == BF_RNDNA ||
-        rnd_mode == BF_RNDNU ||
+        rnd_mode == BF_RNDA ||
         (rnd_mode == BF_RNDD && sign == 1) ||
         (rnd_mode == BF_RNDU && sign == 0)) {
         bf_set_inf(r, sign);
@@ -476,12 +478,14 @@ static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
 
 /* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
    assumed to have length 'l' (1 <= l <= r->len). Note: 'prec1' can be
-   infinite (BF_PREC_INF). Can fail with BF_ST_MEM_ERROR in case of
+   infinite (BF_PREC_INF). 'ret' is 0 or BF_ST_INEXACT if the result
+   is known to be inexact. Can fail with BF_ST_MEM_ERROR in case of
    overflow not returning infinity. */
-static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
+static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
+                      int ret)
 {
     limb_t v, a;
-    int shift, add_one, ret, rnd_mode;
+    int shift, add_one, rnd_mode;
     slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
 
     /* e_min and e_max are computed to match the IEEE 754 conventions */
@@ -506,7 +510,6 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
 
     /* round to prec bits */
     rnd_mode = flags & BF_RND_MASK;
-    ret = 0;
     add_one = bf_get_rnd_add(&ret, r, l, prec, rnd_mode);
     
     if (prec <= 0) {
@@ -615,7 +618,7 @@ int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
             }
             r->expn -= shift;
         }
-        ret = __bf_round(r, prec1, flags, l);
+        ret = __bf_round(r, prec1, flags, l, 0);
     }
     //    bf_print_str("r_final", r);
     return ret;
@@ -638,8 +641,7 @@ int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
     }
     if (a->expn == BF_EXP_ZERO)
         return FALSE;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
-               rnd_mode == BF_RNDNU);
+    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
     if (k < (prec + 2))
         return FALSE;
     bit_pos = a->len * LIMB_BITS - 1 - prec;
@@ -666,7 +668,7 @@ int bf_round(bf_t *r, limb_t prec, bf_flags_t flags)
 {
     if (r->len == 0)
         return 0;
-    return __bf_round(r, prec, flags, r->len);
+    return __bf_round(r, prec, flags, r->len, 0);
 }
 
 /* for debugging */
@@ -780,51 +782,26 @@ int bf_cmp_full(const bf_t *a, const bf_t *b)
     return res;
 }
 
-#define BF_CMP_EQ 1
-#define BF_CMP_LT 2
-#define BF_CMP_LE 3
-
-static int bf_cmp(const bf_t *a, const bf_t *b, int op)
+/* Standard floating point comparison: return 2 if one of the operands
+   is NaN (unordered) or -1, 0, 1 depending on the ordering assuming
+   -0 == +0 */
+int bf_cmp(const bf_t *a, const bf_t *b)
 {
-    BOOL is_both_zero;
     int res;
     
-    if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN)
-        return 0;
-    if (a->sign != b->sign) {
-        is_both_zero = (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO);
-        if (is_both_zero) {
-            return op & BF_CMP_EQ;
-        } else if (op & BF_CMP_LT) {
-            return a->sign;
-        } else {
-            return FALSE;
-        }
+    if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
+        res = 2;
+    } else if (a->sign != b->sign) {
+        if (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO)
+            res = 0;
+        else
+            res = 1 - 2 * a->sign;
     } else {
         res = bf_cmpu(a, b);
-        if (res == 0) {
-            return op & BF_CMP_EQ;
-        } else if (op & BF_CMP_LT) {
-            return (res < 0) ^ a->sign;
-        } else {
-            return FALSE;
-        }
+        if (a->sign)
+            res = -res;
     }
-}
-
-int bf_cmp_eq(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b, BF_CMP_EQ);
-}
-
-int bf_cmp_le(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b, BF_CMP_LE);
-}
-
-int bf_cmp_lt(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b, BF_CMP_LT);
+    return res;
 }
 
 /* Compute the number of bits 'n' matching the pattern:
@@ -1631,11 +1608,11 @@ int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags)
     slimb_t e_max;
     if (r->len == 0)
         return 0;
-    e_max = ((limb_t)1 << BF_EXP_BITS_MAX) - 1;
+    e_max = ((limb_t)1 << BF_EXT_EXP_BITS_MAX) - 1;
     e = bf_max(e, -e_max);
     e = bf_min(e, e_max);
     r->expn += e;
-    return __bf_round(r, prec, flags, r->len);
+    return __bf_round(r, prec, flags, r->len, 0);
 }
 
 /* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
@@ -1777,8 +1754,7 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
     }
 
     q_sign = a->sign ^ b->sign;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
-               rnd_mode == BF_RNDNU);
+    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
     switch(rnd_mode) {
     default:
     case BF_RNDZ:
@@ -1792,12 +1768,12 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
     case BF_RNDU:
         is_ceil = q_sign ^ 1;
         break;
+    case BF_RNDA:
+        is_ceil = TRUE;
+        break;
     case BF_DIVREM_EUCLIDIAN:
         is_ceil = a->sign;
         break;
-    case BF_RNDNU:
-        /* XXX: unsupported yet */
-        abort();
     }
 
     a1->expn = a->expn;
@@ -1845,26 +1821,14 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
     return BF_ST_MEM_ERROR;
 }
 
-int bf_fmod(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-            bf_flags_t flags)
+int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+           bf_flags_t flags, int rnd_mode)
 {
     bf_t q_s, *q = &q_s;
     int ret;
     
     bf_init(r->ctx, q);
-    ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDZ);
-    bf_delete(q);
-    return ret;
-}
-
-int bf_remainder(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                 bf_flags_t flags)
-{
-    bf_t q_s, *q = &q_s;
-    int ret;
-    
-    bf_init(r->ctx, q);
-    ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDN);
+    ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
     bf_delete(q);
     return ret;
 }
@@ -1879,13 +1843,13 @@ static inline int bf_get_limb(slimb_t *pres, const bf_t *a, int flags)
 }
 
 int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-              bf_flags_t flags)
+              bf_flags_t flags, int rnd_mode)
 {
     bf_t q_s, *q = &q_s;
     int ret;
     
     bf_init(r->ctx, q);
-    ret = bf_divrem(q, r, a, b, prec, flags, BF_RNDN);
+    ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
     bf_get_limb(pq, q, BF_GET_INT_MOD);
     bf_delete(q);
     return ret;
@@ -2791,14 +2755,14 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
             /* XXX: correct overflow/underflow handling */
             /* XXX: rigorous error analysis needed */
             extra_bits = ceil_log2(e) * 2 + 1;
-            ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN);
+            ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
             overflow = !bf_is_finite(B);
             /* XXX: if bf_pow_ui_ui returns an exact result, can stop
                after the next operation */
             if (expn_sign)
-                ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN);
+                ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
             else
-                ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN);
+                ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
             if (ret & BF_ST_MEM_ERROR)
                 break;
             if ((ret & BF_ST_INEXACT) &&
@@ -2807,6 +2771,8 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
                 /* and more precision and retry */
                 ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
             } else {
+                /* XXX: need to use __bf_round() to pass the inexact
+                   flag for the subnormal case */
                 ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
                 break;
             }
@@ -3062,7 +3028,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
             c = to_digit(*p);
             if (c >= 10)
                 break;
-            if (unlikely(expn > ((EXP_MAX - 2 - 9) / 10))) {
+            if (unlikely(expn > ((BF_RAW_EXP_MAX - 2 - 9) / 10))) {
                 /* exponent overflow */
                 if (exp_is_neg) {
                     bf_set_zero(r, is_neg);
@@ -3501,11 +3467,14 @@ static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
             prec = prec0 + ziv_extra_bits;
             /* XXX: rigorous error analysis needed */
             extra_bits = ceil_log2(e) * 2 + 1;
-            ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits, BF_RNDN);
+            ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits,
+                               BF_RNDN | BF_FLAG_EXT_EXP);
             if (!e_sign)
-                ret |= bf_mul(r, r, a, prec + extra_bits, BF_RNDN);
+                ret |= bf_mul(r, r, a, prec + extra_bits,
+                              BF_RNDN | BF_FLAG_EXT_EXP);
             else
-                ret |= bf_div(r, a, r, prec + extra_bits, BF_RNDN);
+                ret |= bf_div(r, a, r, prec + extra_bits,
+                              BF_RNDN | BF_FLAG_EXT_EXP);
             if (ret & BF_ST_MEM_ERROR)
                 return BF_ST_MEM_ERROR;
             /* if the result is not exact, check that it can be safely
@@ -3605,7 +3574,15 @@ static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
         pos = a->len;
         pos_incr = 1;
         first_buf_pos = 0;
-    } else if ((radix & (radix - 1)) != 0) {
+    } else if ((radix & (radix - 1)) == 0) {
+        a = (bf_t *)a1;
+        radix_bits = ceil_log2(radix);
+        digits_per_limb = LIMB_BITS / radix_bits;
+        pos_incr = digits_per_limb * radix_bits;
+        /* digits are aligned relative to the radix point */
+        pos = a->len * LIMB_BITS + smod(-a->expn, radix_bits);
+        first_buf_pos = 0;
+    } else {
         limb_t n, radixl;
 
         digits_per_limb = digits_per_limb_table[radix - 2];
@@ -3619,13 +3596,6 @@ static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
         pos = n;
         pos_incr = 1;
         first_buf_pos = pos * digits_per_limb - n_digits;
-    } else {
-        a = (bf_t *)a1;
-        radix_bits = ceil_log2(radix);
-        digits_per_limb = LIMB_BITS / radix_bits;
-        pos_incr = digits_per_limb * radix_bits;
-        pos = a->len * LIMB_BITS - a->expn + n_digits * radix_bits;
-        first_buf_pos = 0;
     }
     buf_pos = digits_per_limb;
     i = 0;
@@ -3668,12 +3638,13 @@ static void *bf_dbuf_realloc(void *opaque, void *ptr, size_t size)
 static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
                               limb_t prec, bf_flags_t flags, BOOL is_dec)
 {
+    bf_context_t *ctx = a2->ctx;
     DynBuf s_s, *s = &s_s;
     int radix_bits;
     
     //    bf_print_str("ftoa", a2);
     //    printf("radix=%d\n", radix);
-    dbuf_init2(s, a2->ctx, bf_dbuf_realloc);
+    dbuf_init2(s, ctx, bf_dbuf_realloc);
     if (a2->expn == BF_EXP_NAN) {
         dbuf_putstr(s, "NaN");
     } else {
@@ -3687,77 +3658,160 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
         } else {
             int fmt, ret;
             slimb_t n_digits, n, i, n_max, n1;
-            bf_t a1_s, *a1;
-            bf_t a_s, *a = &a_s;
-
-            /* make a positive number */
-            a->tab = a2->tab;
-            a->len = a2->len;
-            a->expn = a2->expn;
-            a->sign = 0;
-            
+            bf_t a1_s, *a1 = &a1_s;
+
             if ((radix & (radix - 1)) != 0)
                 radix_bits = 0;
             else
                 radix_bits = ceil_log2(radix);
 
             fmt = flags & BF_FTOA_FORMAT_MASK;
-            a1 = &a1_s;
-            bf_init(a2->ctx, a1);
+            bf_init(ctx, a1);
             if (fmt == BF_FTOA_FORMAT_FRAC) {
-                size_t pos, start;
-                assert(!is_dec);
-                /* one more digit for the rounding */
-                n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
-                n_digits = n + prec;
-                n1 = n;
-                if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
-                                        flags & BF_RND_MASK, TRUE))
-                    goto fail1;
-                start = s->size;
-                output_digits(s, a1, radix, n_digits, n, is_dec);
-                /* remove leading zeros because we allocated one more digit */
-                pos = start;
-                while ((pos + 1) < s->size && s->buf[pos] == '0' &&
-                       s->buf[pos + 1] != '.')
-                    pos++;
-                if (pos > start) {
-                    memmove(s->buf + start, s->buf + pos, s->size - pos);
-                    s->size -= (pos - start);
+                if (is_dec || radix_bits != 0) {
+                    if (bf_set(a1, a2))
+                        goto fail1;
+#ifdef USE_BF_DEC
+                    if (is_dec) {
+                        if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
+                            goto fail1;
+                        n = a1->expn;
+                    } else
+#endif
+                    {
+                        if (bf_round(a1, prec * radix_bits, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
+                            goto fail1;
+                        n = ceil_div(a1->expn, radix_bits);
+                    }
+                    if (flags & BF_FTOA_ADD_PREFIX) {
+                        if (radix == 16)
+                            dbuf_putstr(s, "0x");
+                        else if (radix == 8)
+                            dbuf_putstr(s, "0o");
+                        else if (radix == 2)
+                            dbuf_putstr(s, "0b");
+                    }
+                    if (a1->expn == BF_EXP_ZERO) {
+                        dbuf_putstr(s, "0");
+                        if (prec > 0) {
+                            dbuf_putstr(s, ".");
+                            for(i = 0; i < prec; i++) {
+                                dbuf_putc(s, '0');
+                            }
+                        }
+                    } else {
+                        n_digits = prec + n;
+                        if (n <= 0) {
+                            /* 0.x */
+                            dbuf_putstr(s, "0.");
+                            for(i = 0; i < -n; i++) {
+                                dbuf_putc(s, '0');
+                            }
+                            if (n_digits > 0) {
+                                output_digits(s, a1, radix, n_digits, n_digits, is_dec);
+                            }
+                        } else {
+                            output_digits(s, a1, radix, n_digits, n, is_dec);
+                        }
+                    }
+                } else {
+                    size_t pos, start;
+                    bf_t a_s, *a = &a_s;
+
+                    /* make a positive number */
+                    a->tab = a2->tab;
+                    a->len = a2->len;
+                    a->expn = a2->expn;
+                    a->sign = 0;
+                    
+                    /* one more digit for the rounding */
+                    n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
+                    n_digits = n + prec;
+                    n1 = n;
+                    if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
+                                            flags & BF_RND_MASK, TRUE))
+                        goto fail1;
+                    start = s->size;
+                    output_digits(s, a1, radix, n_digits, n, is_dec);
+                    /* remove leading zeros because we allocated one more digit */
+                    pos = start;
+                    while ((pos + 1) < s->size && s->buf[pos] == '0' &&
+                           s->buf[pos + 1] != '.')
+                        pos++;
+                    if (pos > start) {
+                        memmove(s->buf + start, s->buf + pos, s->size - pos);
+                        s->size -= (pos - start);
+                    }
                 }
             } else {
 #ifdef USE_BF_DEC
                 if (is_dec) {
+                    if (bf_set(a1, a2))
+                        goto fail1;
                     if (fmt == BF_FTOA_FORMAT_FIXED) {
                         n_digits = prec;
                         n_max = n_digits;
+                        if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
+                            goto fail1;
                     } else {
                         /* prec is ignored */
-                        prec = n_digits = a->len * LIMB_DIGITS;
-                        /* remove trailing zero digits */
+                        prec = n_digits = a1->len * LIMB_DIGITS;
+                        /* remove the trailing zero digits */
                         while (n_digits > 1 &&
-                               get_digit(a->tab, a->len, prec - n_digits) == 0) {
+                               get_digit(a1->tab, a1->len, prec - n_digits) == 0) {
                             n_digits--;
                         }
                         n_max = n_digits + 4;
                     }
-                    bf_init(a2->ctx, a1);
-                    bf_set(a1, a);
                     n = a1->expn;
                 } else
 #endif
-                {
+                if (radix_bits != 0) {
+                    if (bf_set(a1, a2))
+                        goto fail1;
+                    if (fmt == BF_FTOA_FORMAT_FIXED) {
+                        slimb_t prec_bits;
+                        n_digits = prec;
+                        n_max = n_digits;
+                        /* align to the radix point */
+                        prec_bits = prec * radix_bits -
+                            smod(-a1->expn, radix_bits);
+                        if (bf_round(a1, prec_bits,
+                                     (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
+                            goto fail1;
+                    } else {
+                        limb_t digit_mask;
+                        slimb_t pos;
+                        /* position of the digit before the most
+                           significant digit in bits */
+                        pos = a1->len * LIMB_BITS +
+                            smod(-a1->expn, radix_bits);
+                        n_digits = ceil_div(pos, radix_bits);
+                        /* remove the trailing zero digits */
+                        digit_mask = ((limb_t)1 << radix_bits) - 1;
+                        while (n_digits > 1 &&
+                               (get_bits(a1->tab, a1->len, pos - n_digits * radix_bits) & digit_mask) == 0) {
+                            n_digits--;
+                        }
+                        n_max = n_digits + 4;
+                    }
+                    n = ceil_div(a1->expn, radix_bits);
+                } else {
+                    bf_t a_s, *a = &a_s;
+                    
+                    /* make a positive number */
+                    a->tab = a2->tab;
+                    a->len = a2->len;
+                    a->expn = a2->expn;
+                    a->sign = 0;
+                    
                     if (fmt == BF_FTOA_FORMAT_FIXED) {
                         n_digits = prec;
                         n_max = n_digits;
                     } else {
                         slimb_t n_digits_max, n_digits_min;
                         
-                        if (prec == BF_PREC_INF) {
-                            assert(radix_bits != 0);
-                            /* XXX: could use the exact number of bits */
-                            prec = a->len * LIMB_BITS;
-                        }
+                        assert(prec != BF_PREC_INF);
                         n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
                         /* max number of digits for non exponential
                            notation. The rational is to have the same rule
@@ -3771,7 +3825,7 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
                             /* XXX: inefficient */
                             n_digits_max = n_digits;
                             n_digits_min = 1;
-                            bf_init(a2->ctx, b);
+                            bf_init(ctx, b);
                             while (n_digits_min < n_digits_max) {
                                 n_digits = (n_digits_min + n_digits_max) / 2;
                                 if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
@@ -3869,7 +3923,7 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
         *plen = s->size - 1;
     return (char *)s->buf;
  fail:
-    bf_free(a2->ctx, s->buf);
+    bf_free(ctx, s->buf);
     if (plen)
         *plen = 0;
     return NULL;
@@ -4035,7 +4089,7 @@ static void bf_const_pi_internal(bf_t *Q, limb_t prec)
 
 static int bf_const_get(bf_t *T, limb_t prec, bf_flags_t flags,
                         BFConstCache *c,
-                        void (*func)(bf_t *res, limb_t prec))
+                        void (*func)(bf_t *res, limb_t prec), int sign)
 {
     limb_t ziv_extra_bits, prec1;
 
@@ -4051,6 +4105,7 @@ static int bf_const_get(bf_t *T, limb_t prec, bf_flags_t flags,
             prec1 = c->prec;
         }
         bf_set(T, &c->val);
+        T->sign = sign;
         if (!bf_can_round(T, prec, flags & BF_RND_MASK, prec1)) {
             /* and more precision and retry */
             ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
@@ -4070,13 +4125,20 @@ static void bf_const_free(BFConstCache *c)
 int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags)
 {
     bf_context_t *s = T->ctx;
-    return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal);
+    return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal, 0);
 }
 
-int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
+/* return rounded pi * (1 - 2 * sign) */
+static int bf_const_pi_signed(bf_t *T, int sign, limb_t prec, bf_flags_t flags)
 {
     bf_context_t *s = T->ctx;
-    return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal);
+    return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal,
+                        sign);
+}
+
+int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
+{
+    return bf_const_pi_signed(T, 0, prec, flags);
 }
 
 void bf_clear_cache(bf_context_t *s)
@@ -4126,9 +4188,29 @@ static int bf_ziv_rounding(bf_t *r, const bf_t *a,
                 break;
             }
             ziv_extra_bits = ziv_extra_bits * 2;
+            //            printf("ziv_extra_bits=%" PRId64 "\n", (int64_t)ziv_extra_bits);
         }
     }
-    return bf_round(r, prec, flags) | ret;
+    if (r->len == 0)
+        return ret;
+    else
+        return __bf_round(r, prec, flags, r->len, ret);
+}
+
+/* add (1 - 2*e_sign) * 2^e */
+static int bf_add_epsilon(bf_t *r, const bf_t *a, slimb_t e, int e_sign,
+                          limb_t prec, int flags)
+{
+    bf_t T_s, *T = &T_s;
+    int ret;
+    /* small argument case: result = 1 + epsilon * sign(x) */
+    bf_init(a->ctx, T);
+    bf_set_ui(T, 1);
+    T->sign = e_sign;
+    T->expn += e;
+    ret = bf_add(r, r, T, prec, flags);
+    bf_delete(T);
+    return ret;
 }
 
 /* Compute the exponential using faithful rounding at precision 'prec'.
@@ -4193,18 +4275,70 @@ static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     
     /* undo the range reduction */
     for(i = 0; i < K; i++) {
-        bf_mul(r, r, r, prec1, BF_RNDN);
+        bf_mul(r, r, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
     }
 
     /* undo the argument reduction */
-    bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ);
+    bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ | BF_FLAG_EXT_EXP);
 
     return BF_ST_INEXACT;
 }
 
+/* crude overflow and underflow tests for exp(a). a_low <= a <= a_high */
+static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
+                                        const bf_t *a_low, const bf_t *a_high,
+                                        limb_t prec, bf_flags_t flags)
+{
+    bf_t T_s, *T = &T_s;
+    bf_t log2_s, *log2 = &log2_s;
+    slimb_t e_min, e_max;
+    
+    if (a_high->expn <= 0)
+        return 0;
+
+    e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
+    e_min = -e_max + 3;
+    if (flags & BF_FLAG_SUBNORMAL)
+        e_min -= (prec - 1);
+    
+    bf_init(s, T);
+    bf_init(s, log2);
+    bf_const_log2(log2, LIMB_BITS, BF_RNDU);
+    bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
+    /* a_low > e_max * log(2) implies exp(a) > e_max */
+    if (bf_cmp_lt(T, a_low) > 0) {
+        /* overflow */
+        bf_delete(T);
+        bf_delete(log2);
+        return bf_set_overflow(r, 0, prec, flags);
+    }
+    /* a_high < (e_min - 2) * log(2) implies exp(a) < (e_min - 2) */
+    bf_const_log2(log2, LIMB_BITS, BF_RNDD);
+    bf_mul_si(T, log2, e_min - 2, LIMB_BITS, BF_RNDD);
+    if (bf_cmp_lt(a_high, T)) {
+        int rnd_mode = flags & BF_RND_MASK;
+        
+        /* underflow */
+        bf_delete(T);
+        bf_delete(log2);
+        if (rnd_mode == BF_RNDU) {
+            /* set the smallest value */
+            bf_set_ui(r, 1);
+            r->expn = e_min;
+        } else {
+            bf_set_zero(r, 0);
+        }
+        return BF_ST_UNDERFLOW | BF_ST_INEXACT;
+    }
+    bf_delete(log2);
+    bf_delete(T);
+    return 0;
+}
+
 int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
     bf_context_t *s = r->ctx;
+    int ret;
     assert(r != a);
     if (a->len == 0) {
         if (a->expn == BF_EXP_NAN) {
@@ -4220,48 +4354,15 @@ int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
         return 0;
     }
 
-    /* crude overflow and underflow tests */
-    if (a->expn > 0) {
-        bf_t T_s, *T = &T_s;
-        bf_t log2_s, *log2 = &log2_s;
-        slimb_t e_min, e_max;
-        e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
-        e_min = -e_max + 3;
-        if (flags & BF_FLAG_SUBNORMAL)
-            e_min -= (prec - 1);
-
-        bf_init(s, T);
-        bf_init(s, log2);
-        bf_const_log2(log2, LIMB_BITS, BF_RNDU);
-        bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
-        /* a > e_max * log(2) implies exp(a) > e_max */
-        if (bf_cmp_lt(T, a) > 0) {
-            /* overflow */
-            bf_delete(T);
-            bf_delete(log2);
-            return bf_set_overflow(r, 0, prec, flags);
-        }
-        /* a < e_min * log(2) implies exp(a) < e_min */
-        bf_mul_si(T, log2, e_min, LIMB_BITS, BF_RNDD);
-        if (bf_cmp_lt(a, T)) {
-            int rnd_mode = flags & BF_RND_MASK;
-
-            /* underflow */
-            bf_delete(T);
-            bf_delete(log2);
-            if (rnd_mode == BF_RNDU) {
-                /* set the smallest value */
-                bf_set_ui(r, 1);
-                r->expn = e_min;
-            } else {
-                bf_set_zero(r, 0);
-            }
-            return BF_ST_UNDERFLOW | BF_ST_INEXACT;
-        }
-        bf_delete(log2);
-        bf_delete(T);
+    ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
+    if (ret)
+        return ret;
+    if (a->expn < 0 && (-a->expn) >= (prec + 2)) { 
+        /* small argument case: result = 1 + epsilon * sign(x) */
+        bf_set_ui(r, 1);
+        return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
     }
-
+                         
     return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
 }
 
@@ -4404,7 +4505,6 @@ int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 }
 
 /* x and y finite and x > 0 */
-/* XXX: overflow/underflow handling */
 static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
 {
     bf_context_t *s = r->ctx;
@@ -4415,15 +4515,17 @@ static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
     bf_init(s, T);
     /* XXX: proof for the added precision */
     prec1 = prec + 32;
-    bf_log(T, x, prec1, BF_RNDF);
-    bf_mul(T, T, y, prec1, BF_RNDF);
-    bf_exp(r, T, prec1, BF_RNDF);
+    bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
+    bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
+    if (bf_is_nan(T))
+        bf_set_nan(r);
+    else
+        bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
     bf_delete(T);
     return BF_ST_INEXACT;
 }
 
 /* x and y finite, x > 0, y integer and y fits on one limb */
-/* XXX: overflow/underflow handling */ 
 static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
 {
     bf_context_t *s = r->ctx;
@@ -4438,11 +4540,11 @@ static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
         y1 = -y1;
     /* XXX: proof for the added precision */
     prec1 = prec + ceil_log2(y1) * 2 + 8;
-    ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN);
+    ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
     if (y->sign) {
         bf_init(s, T);
         bf_set_ui(T, 1);
-        ret |= bf_div(r, T, r, prec1, BF_RNDN);
+        ret |= bf_div(r, T, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
         bf_delete(T);
     }
     return ret;
@@ -4508,7 +4610,7 @@ int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
             int cmp_x_abs_1;
             bf_set_ui(r, 1);
             cmp_x_abs_1 = bf_cmpu(x, r);
-            if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUICKS) &&
+            if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUIRKS) &&
                 (y->expn >= BF_EXP_INF)) {
                 bf_set_nan(r);
             } else if (cmp_x_abs_1 == 0 &&
@@ -4565,70 +4667,95 @@ int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
     if (bf_cmp_eq(T, r)) {
         /* abs(x) = 1: nothing more to do */
         ret = 0;
-    } else if (y_is_int) {
-        slimb_t T_bits, e;
-    int_pow:
-        T_bits = T->expn - bf_get_exp_min(T);
-        if (T_bits == 1) {
-            /* pow(2^b, y) = 2^(b*y) */
-            bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
-            bf_get_limb(&e, T, 0);
-            bf_set_ui(r, 1);
-            ret = bf_mul_2exp(r, e, prec, flags);
-        } else if (prec == BF_PREC_INF) {
-            slimb_t y1;
-            /* specific case for infinite precision (integer case) */
-            bf_get_limb(&y1, y, 0);
-            assert(!y->sign);
-            /* x must be an integer, so abs(x) >= 2 */
-            if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
-                bf_delete(T);
-                return bf_set_overflow(r, 0, BF_PREC_INF, flags);
-            }
-            ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
-        } else {
-            if (y->expn <= 31) {
-                /* small enough power: use exponentiation in all cases */
-            } else if (y->sign) {
-                /* cannot be exact */
-                goto general_case;
+    } else {
+        /* check the overflow/underflow cases */
+        {
+            bf_t al_s, *al = &al_s;
+            bf_t ah_s, *ah = &ah_s;
+            limb_t precl = LIMB_BITS;
+            
+            bf_init(s, al);
+            bf_init(s, ah);
+            /* compute bounds of log(abs(x)) * y with a low precision */
+            /* XXX: compute bf_log() once */
+            /* XXX: add a fast test before this slow test */
+            bf_log(al, T, precl, BF_RNDD);
+            bf_log(ah, T, precl, BF_RNDU);
+            bf_mul(al, al, y, precl, BF_RNDD ^ y->sign);
+            bf_mul(ah, ah, y, precl, BF_RNDU ^ y->sign);
+            ret = check_exp_underflow_overflow(s, r, al, ah, prec, flags);
+            bf_delete(al);
+            bf_delete(ah);
+            if (ret)
+                goto done;
+        }
+        
+        if (y_is_int) {
+            slimb_t T_bits, e;
+        int_pow:
+            T_bits = T->expn - bf_get_exp_min(T);
+            if (T_bits == 1) {
+                /* pow(2^b, y) = 2^(b*y) */
+                bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
+                bf_get_limb(&e, T, 0);
+                bf_set_ui(r, 1);
+                ret = bf_mul_2exp(r, e, prec, flags);
+            } else if (prec == BF_PREC_INF) {
+                slimb_t y1;
+                /* specific case for infinite precision (integer case) */
+                bf_get_limb(&y1, y, 0);
+                assert(!y->sign);
+                /* x must be an integer, so abs(x) >= 2 */
+                if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
+                    bf_delete(T);
+                    return bf_set_overflow(r, 0, BF_PREC_INF, flags);
+                }
+                ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
             } else {
-                if (rnd_mode == BF_RNDF)
-                    goto general_case; /* no need to track exact results */
-                /* see if the result has a chance to be exact:
-                   if x=a*2^b (a odd), x^y=a^y*2^(b*y)
-                   x^y needs a precision of at least floor_log2(a)*y bits
-                */
-                bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
-                bf_get_limb(&e, r, 0);
-                if (prec < e)
+                if (y->expn <= 31) {
+                    /* small enough power: use exponentiation in all cases */
+                } else if (y->sign) {
+                    /* cannot be exact */
                     goto general_case;
+                } else {
+                    if (rnd_mode == BF_RNDF)
+                        goto general_case; /* no need to track exact results */
+                    /* see if the result has a chance to be exact:
+                       if x=a*2^b (a odd), x^y=a^y*2^(b*y)
+                       x^y needs a precision of at least floor_log2(a)*y bits
+                    */
+                    bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
+                    bf_get_limb(&e, r, 0);
+                    if (prec < e)
+                        goto general_case;
+                }
+                ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
             }
-            ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
-        }
-    } else {
-        if (rnd_mode != BF_RNDF) {
-            bf_t *y1;
-            if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
-                /* the problem is reduced to a power to an integer */
+        } else {
+            if (rnd_mode != BF_RNDF) {
+                bf_t *y1;
+                if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
+                    /* the problem is reduced to a power to an integer */
 #if 0
-                printf("\nn=%ld\n", -y_emin);
-                bf_print_str("T", T);
-                bf_print_str("r", r);
+                    printf("\nn=%" PRId64 "\n", -(int64_t)y_emin);
+                    bf_print_str("T", T);
+                    bf_print_str("r", r);
 #endif
-                bf_set(T, r);
-                y1 = &ytmp_s;
-                y1->tab = y->tab;
-                y1->len = y->len;
-                y1->sign = y->sign;
-                y1->expn = y->expn - y_emin;
-                y = y1;
-                goto int_pow;
+                    bf_set(T, r);
+                    y1 = &ytmp_s;
+                    y1->tab = y->tab;
+                    y1->len = y->len;
+                    y1->sign = y->sign;
+                    y1->expn = y->expn - y_emin;
+                    y = y1;
+                    goto int_pow;
+                }
             }
+        general_case:
+            ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
         }
-    general_case:
-        ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
     }
+ done:
     bf_delete(T);
     r->sign = r_sign;
     return ret;
@@ -4649,7 +4776,7 @@ static void bf_sqrt_sin(bf_t *r, const bf_t *x, limb_t prec1)
     bf_delete(T);
 }
 
-int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
+static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
 {
     bf_context_t *s1 = a->ctx;
     bf_t T_s, *T = &T_s;
@@ -4659,27 +4786,6 @@ int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
     int is_neg;
     
     assert(c != a && s != a);
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            if (c)
-                bf_set_nan(c);
-            if (s)
-                bf_set_nan(s);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            if (c)
-                bf_set_nan(c);
-            if (s)
-                bf_set_nan(s);
-            return BF_ST_INVALID_OP;
-        } else {
-            if (c)
-                bf_set_ui(c, 1);
-            if (s)
-                bf_set_zero(s, a->sign);
-            return 0;
-        }
-    }
 
     bf_init(s1, T);
     bf_init(s1, U);
@@ -4699,10 +4805,10 @@ int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
         slimb_t cancel;
         cancel = 0;
         for(;;) {
-            prec2 = prec1 + cancel;
+            prec2 = prec1 + a->expn + cancel;
             bf_const_pi(U, prec2, BF_RNDF);
             bf_mul_2exp(U, -1, BF_PREC_INF, BF_RNDZ);
-            bf_remquo(&mod, T, a, U, prec2, BF_RNDN);
+            bf_remquo(&mod, T, a, U, prec2, BF_RNDN, BF_RNDN);
             //            printf("T.expn=%ld prec2=%ld\n", T->expn, prec2);
             if (mod == 0 || (T->expn != BF_EXP_ZERO &&
                              (T->expn + prec2) >= (prec1 - 1)))
@@ -4774,6 +4880,30 @@ static int bf_cos_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
 int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bf_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF) {
+            bf_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bf_set_ui(r, 1);
+            return 0;
+        }
+    }
+
+    /* small argument case: result = 1+r(x) with r(x) = -x^2/2 +
+       O(X^4). We assume r(x) < 2^(2*EXP(x) - 1). */
+    if (a->expn < 0) {
+        slimb_t e;
+        e = 2 * a->expn - 1;
+        if (e < -(prec + 2)) {
+            bf_set_ui(r, 1);
+            return bf_add_epsilon(r, r, e, 1, prec, flags);
+        }
+    }
+    
     return bf_ziv_rounding(r, a, prec, flags, bf_cos_internal, NULL);
 }
 
@@ -4784,15 +4914,6 @@ static int bf_sin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
 int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
-    return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
-}
-
-static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1;
-    
     if (a->len == 0) {
         if (a->expn == BF_EXP_NAN) {
             bf_set_nan(r);
@@ -4806,6 +4927,26 @@ static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
         }
     }
 
+    /* small argument case: result = x+r(x) with r(x) = -x^3/6 +
+       O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
+    if (a->expn < 0) {
+        slimb_t e;
+        e = sat_add(2 * a->expn, a->expn - 2);
+        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+            bf_set(r, a);
+            return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
+        }
+    }
+
+    return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
+}
+
+static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
+{
+    bf_context_t *s = r->ctx;
+    bf_t T_s, *T = &T_s;
+    limb_t prec1;
+    
     /* XXX: precision analysis */
     prec1 = prec + 8;
     bf_init(s, T);
@@ -4817,6 +4958,31 @@ static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
 int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
+    assert(r != a);
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bf_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF) {
+            bf_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bf_set_zero(r, a->sign);
+            return 0;
+        }
+    }
+
+    /* small argument case: result = x+r(x) with r(x) = x^3/3 +
+       O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
+    if (a->expn < 0) {
+        slimb_t e;
+        e = sat_add(2 * a->expn, a->expn - 1);
+        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+            bf_set(r, a);
+            return bf_add_epsilon(r, r, e, a->sign, prec, flags);
+        }
+    }
+            
     return bf_ziv_rounding(r, a, prec, flags, bf_tan_internal, NULL);
 }
 
@@ -4834,50 +5000,15 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
     int cmp_1;
     slimb_t prec1, i, K, l;
     
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else {
-            if (a->expn == BF_EXP_INF)
-                i = 1 - 2 * a->sign;
-            else
-                i = 0;
-            i += add_pi2;
-            /* return i*(pi/2) with -1 <= i <= 2 */
-            if (i == 0) {
-                bf_set_zero(r, add_pi2 ? 0 : a->sign);
-                return 0;
-            } else {
-                /* PI or PI/2 */
-                bf_const_pi(r, prec, BF_RNDF);
-                if (i != 2)
-                    bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
-                r->sign = (i < 0);
-                return BF_ST_INEXACT;
-            }
-        }
-    }
-    
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    cmp_1 = bf_cmpu(a, T);
-    if (cmp_1 == 0 && !add_pi2) {
-        /* short cut: abs(a) == 1 -> +/-pi/4 */
-        bf_const_pi(r, prec, BF_RNDF);
-        bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
-        r->sign = a->sign;
-        bf_delete(T);
-        return BF_ST_INEXACT;
-    }
-
     /* XXX: precision analysis */
     K = bf_isqrt((prec + 1) / 2);
     l = prec / (2 * K) + 1;
     prec1 = prec + K + 2 * l + 32;
-    //    printf("prec=%ld K=%ld l=%ld prec1=%ld\n", prec, K, l, prec1);
+    //    printf("prec=%d K=%d l=%d prec1=%d\n", (int)prec, (int)K, (int)l, (int)prec1);
     
-    if (cmp_1 > 0) {
+    bf_init(s, T);
+    cmp_1 = (a->expn >= 1); /* a >= 1 */
+    if (cmp_1) {
         bf_set_ui(T, 1);
         bf_div(T, T, a, prec1, BF_RNDN);
     } else {
@@ -4945,6 +5076,47 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
 
 int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
+    bf_context_t *s = r->ctx;
+    bf_t T_s, *T = &T_s;
+    int res;
+    
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bf_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF)  {
+            /* -PI/2 or PI/2 */
+            bf_const_pi_signed(r, a->sign, prec, flags);
+            bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
+            return BF_ST_INEXACT;
+        } else {
+            bf_set_zero(r, a->sign);
+            return 0;
+        }
+    }
+    
+    bf_init(s, T);
+    bf_set_ui(T, 1);
+    res = bf_cmpu(a, T);
+    bf_delete(T);
+    if (res == 0) {
+        /* short cut: abs(a) == 1 -> +/-pi/4 */
+        bf_const_pi_signed(r, a->sign, prec, flags);
+        bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
+        return BF_ST_INEXACT;
+    }
+
+    /* small argument case: result = x+r(x) with r(x) = -x^3/3 +
+       O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
+    if (a->expn < 0) {
+        slimb_t e;
+        e = sat_add(2 * a->expn, a->expn - 1);
+        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+            bf_set(r, a);
+            return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
+        }
+    }
+    
     return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
 }
 
@@ -4998,38 +5170,6 @@ static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     BOOL is_acos = (BOOL)(intptr_t)opaque;
     bf_t T_s, *T = &T_s;
     limb_t prec1, prec2;
-    int res;
-    
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            if (is_acos) {
-                bf_const_pi(r, prec, BF_RNDF);
-                bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
-                return BF_ST_INEXACT;
-            } else {
-                bf_set_zero(r, a->sign);
-                return 0;
-            }
-        }
-    }
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    res = bf_cmpu(a, T);
-    if (res > 0) {
-        bf_delete(T);
-        bf_set_nan(r);
-        return BF_ST_INVALID_OP;
-    } else if (res == 0 && a->sign == 0 && is_acos) {
-        bf_set_zero(r, 0);
-        bf_delete(T);
-        return 0;
-    }
     
     /* asin(x) = atan(x/sqrt(1-x^2)) 
        acos(x) = pi/2 - asin(x) */
@@ -5041,6 +5181,7 @@ static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
         prec2 = BF_PREC_INF;
     else
         prec2 = prec1;
+    bf_init(s, T);
     bf_mul(T, a, a, prec2, BF_RNDN);
     bf_neg(T);
     bf_add_si(T, T, 1, prec2, BF_RNDN);
@@ -5056,11 +5197,76 @@ static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
 int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
+    bf_context_t *s = r->ctx;
+    bf_t T_s, *T = &T_s;
+    int res;
+
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bf_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF) {
+            bf_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bf_set_zero(r, a->sign);
+            return 0;
+        }
+    }
+    bf_init(s, T);
+    bf_set_ui(T, 1);
+    res = bf_cmpu(a, T);
+    bf_delete(T);
+    if (res > 0) {
+        bf_set_nan(r);
+        return BF_ST_INVALID_OP;
+    }
+    
+    /* small argument case: result = x+r(x) with r(x) = x^3/6 +
+       O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
+    if (a->expn < 0) {
+        slimb_t e;
+        e = sat_add(2 * a->expn, a->expn - 2);
+        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
+            bf_set(r, a);
+            return bf_add_epsilon(r, r, e, a->sign, prec, flags);
+        }
+    }
+
     return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)FALSE);
 }
 
 int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
+    bf_context_t *s = r->ctx;
+    bf_t T_s, *T = &T_s;
+    int res;
+
+    if (a->len == 0) {
+        if (a->expn == BF_EXP_NAN) {
+            bf_set_nan(r);
+            return 0;
+        } else if (a->expn == BF_EXP_INF) {
+            bf_set_nan(r);
+            return BF_ST_INVALID_OP;
+        } else {
+            bf_const_pi(r, prec, flags);
+            bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
+            return BF_ST_INEXACT;
+        }
+    }
+    bf_init(s, T);
+    bf_set_ui(T, 1);
+    res = bf_cmpu(a, T);
+    bf_delete(T);
+    if (res > 0) {
+        bf_set_nan(r);
+        return BF_ST_INVALID_OP;
+    } else if (res == 0 && a->sign == 0) {
+        bf_set_zero(r, 0);
+        return 0;
+    }
+    
     return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
 }
 
@@ -5124,14 +5330,14 @@ int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 
 #endif /* LIMB_BITS != 64 */
 
-static inline limb_t shrd(limb_t low, limb_t high, long shift)
+static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
 {
     if (shift != 0)
         low = (low >> shift) | (high << (LIMB_BITS - shift));
     return low;
 }
 
-static inline limb_t shld(limb_t a1, limb_t a0, long shift)
+static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
 {
     if (shift != 0)
         return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
@@ -5185,21 +5391,18 @@ do {\
 /* fast integer division by a fixed constant */
 
 typedef struct FastDivData {
-    limb_t d; /* divisor (only user visible field) */
     limb_t m1; /* multiplier */
-    int shift1;
-    int shift2;
+    int8_t shift1;
+    int8_t shift2;
 } FastDivData;
 
-#if 1
 /* From "Division by Invariant Integers using Multiplication" by
    Torborn Granlund and Peter L. Montgomery */
 /* d must be != 0 */
-static inline void fast_udiv_init(FastDivData *s, limb_t d)
+static inline __maybe_unused void fast_udiv_init(FastDivData *s, limb_t d)
 {
     int l;
     limb_t q, r, m1;
-    s->d = d;
     if (d == 1)
         l = 0;
     else
@@ -5225,52 +5428,78 @@ static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
     return (t1 + t0) >> s->shift2;
 }
 
-static inline limb_t fast_urem(limb_t a, const FastDivData *s)
-{
-    limb_t q;
-    q = fast_udiv(a, s);
-    return a - q * s->d;
-}
+/* contains 10^i */
+const limb_t mp_pow_dec[LIMB_DIGITS + 1] = {
+    1U,
+    10U,
+    100U,
+    1000U,
+    10000U,
+    100000U,
+    1000000U,
+    10000000U,
+    100000000U,
+    1000000000U,
+#if LIMB_BITS == 64
+    10000000000U,
+    100000000000U,
+    1000000000000U,
+    10000000000000U,
+    100000000000000U,
+    1000000000000000U,
+    10000000000000000U,
+    100000000000000000U,
+    1000000000000000000U,
+    10000000000000000000U,
+#endif
+};
 
-#define fast_udivrem(q, r, a, s) q = fast_udiv(a, s), r = a - q * (s)->d
-    
+/* precomputed from fast_udiv_init(10^i) */
+static const FastDivData mp_pow_div[LIMB_DIGITS + 1] = {
+#if LIMB_BITS == 32
+    { 0x00000001, 0, 0 },
+    { 0x9999999a, 1, 3 },
+    { 0x47ae147b, 1, 6 },
+    { 0x0624dd30, 1, 9 },
+    { 0xa36e2eb2, 1, 13 },
+    { 0x4f8b588f, 1, 16 },
+    { 0x0c6f7a0c, 1, 19 },
+    { 0xad7f29ac, 1, 23 },
+    { 0x5798ee24, 1, 26 },
+    { 0x12e0be83, 1, 29 },
 #else
-
-static inline void fast_udiv_init(FastDivData *s, limb_t d)
-{
-    s->d = d;
-}
-static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
-{
-    return a / s->d;
-}
-static inline limb_t fast_urem(limb_t a, const FastDivData *s)
-{
-    return a % s->d;
-}
-
-#define fast_udivrem(q, r, a, s) q = a / (s)->d, r = a % (s)->d
-
+    { 0x0000000000000001, 0, 0 },
+    { 0x999999999999999a, 1, 3 },
+    { 0x47ae147ae147ae15, 1, 6 },
+    { 0x0624dd2f1a9fbe77, 1, 9 },
+    { 0xa36e2eb1c432ca58, 1, 13 },
+    { 0x4f8b588e368f0847, 1, 16 },
+    { 0x0c6f7a0b5ed8d36c, 1, 19 },
+    { 0xad7f29abcaf48579, 1, 23 },
+    { 0x5798ee2308c39dfa, 1, 26 },
+    { 0x12e0be826d694b2f, 1, 29 },
+    { 0xb7cdfd9d7bdbab7e, 1, 33 },
+    { 0x5fd7fe17964955fe, 1, 36 },
+    { 0x19799812dea11198, 1, 39 },
+    { 0xc25c268497681c27, 1, 43 },
+    { 0x6849b86a12b9b01f, 1, 46 },
+    { 0x203af9ee756159b3, 1, 49 },
+    { 0xcd2b297d889bc2b7, 1, 53 },
+    { 0x70ef54646d496893, 1, 56 },
+    { 0x2725dd1d243aba0f, 1, 59 },
+    { 0xd83c94fb6d2ac34d, 1, 63 },
 #endif
+};
 
-/* contains 10^i */
-/* XXX: make it const */
-limb_t mp_pow_dec[LIMB_DIGITS + 1];
-static FastDivData mp_pow_div[LIMB_DIGITS + 1];
-
-static void mp_pow_init(void)
+/* divide by 10^shift with 0 <= shift <= LIMB_DIGITS */
+static inline limb_t fast_shr_dec(limb_t a, int shift)
 {
-    limb_t a;
-    int i;
-    
-    a = 1;
-    for(i = 0; i <= LIMB_DIGITS; i++) {
-        mp_pow_dec[i] = a;
-        fast_udiv_init(&mp_pow_div[i], a);
-        a = a * 10;
-    }
+    return fast_udiv(a, &mp_pow_div[shift]);
 }
 
+/* division and remainder by 10^shift */
+#define fast_shr_rem_dec(q, r, a, shift) q = fast_shr_dec(a, shift), r = a - q * mp_pow_dec[shift]
+    
 limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
                   mp_size_t n, limb_t carry)
 {
@@ -5653,7 +5882,7 @@ static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
     l = high;
     for(i = n - 1; i >= 0; i--) {
         a = tab[i];
-        fast_udivrem(q, r, a, &mp_pow_div[shift]);
+        fast_shr_rem_dec(q, r, a, shift);
         tab_r[i] = q + l * mp_pow_dec[LIMB_DIGITS - shift];
         l = r;
     }
@@ -5671,7 +5900,7 @@ static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
     l = low;
     for(i = 0; i < n; i++) {
         a = tab[i];
-        fast_udivrem(q, r, a, &mp_pow_div[LIMB_DIGITS - shift]);
+        fast_shr_rem_dec(q, r, a, LIMB_DIGITS - shift);
         tab_r[i] = r * mp_pow_dec[shift] + l;
         l = q;
     }
@@ -6011,7 +6240,7 @@ static inline limb_t scan_digit_nz(const bfdec_t *r, slimb_t bit_pos)
         return 0;
     pos = (limb_t)bit_pos / LIMB_DIGITS;
     shift = (limb_t)bit_pos % LIMB_DIGITS;
-    fast_udivrem(q, v, r->tab[pos], &mp_pow_div[shift + 1]);
+    fast_shr_rem_dec(q, v, r->tab[pos], shift + 1);
     (void)q;
     if (v != 0)
         return 1;
@@ -6032,7 +6261,7 @@ static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos)
     if (i < 0 || i >= len)
         return 0;
     shift = pos - i * LIMB_DIGITS;
-    return fast_udiv(tab[i], &mp_pow_div[shift]) % 10;
+    return fast_shr_dec(tab[i], shift) % 10;
 }
 
 #if 0
@@ -6056,7 +6285,7 @@ static limb_t get_digits(const limb_t *tab, limb_t len, slimb_t pos)
             a1 = tab[i];
         else
             a1 = 0;
-        return fast_udiv(a0, &mp_pow_div[shift]) +
+        return fast_shr_dec(a0, shift) +
             fast_urem(a1, &mp_pow_div[LIMB_DIGITS - shift]) *
             mp_pow_dec[shift];
     }
@@ -6108,13 +6337,8 @@ static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
     case BF_RNDF:
         add_one = (digit1 >= 5);
         break;
-    case BF_RNDNU:
-        if (digit1 >= 5) {
-            if (r->sign)
-                add_one = (digit0 != 0);
-            else
-                add_one = 1;
-        }
+    case BF_RNDA:
+        add_one = inexact;
         break;
     default:
         abort();
@@ -6135,8 +6359,7 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     int shift, add_one, rnd_mode, ret;
     slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
 
-    /* e_min and e_max are computed to match the IEEE 754 conventions */
-    /* XXX: does not matter for decimal numbers */
+    /* XXX: align to IEEE 754 2008 for decimal numbers ? */
     e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
     e_min = -e_range + 3;
     e_max = e_range;
@@ -6147,6 +6370,11 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
             prec = r->expn + prec1;
         else
             prec = prec1;
+    } else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
+        /* restrict the precision in case of potentially subnormal
+           result */
+        assert(prec1 != BF_PREC_INF);
+        prec = prec1 - (e_min - r->expn);
     } else {
         prec = prec1;
     }
@@ -6183,10 +6411,16 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     
     /* check underflow */
     if (unlikely(r->expn < e_min)) {
-    underflow:
-        bfdec_set_zero(r, r->sign);
-        ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
-        return ret;
+        if (flags & BF_FLAG_SUBNORMAL) {
+            /* if inexact, also set the underflow flag */
+            if (ret & BF_ST_INEXACT)
+                ret |= BF_ST_UNDERFLOW;
+        } else {
+        underflow:
+            bfdec_set_zero(r, r->sign);
+            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
+            return ret;
+        }
     }
     
     /* check overflow */
@@ -6202,7 +6436,7 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     if (i >= 0) {
         shift = smod(bit_pos, LIMB_DIGITS);
         if (shift != 0) {
-            r->tab[i] = fast_udiv(r->tab[i], &mp_pow_div[shift]) *
+            r->tab[i] = fast_shr_dec(r->tab[i], shift) *
                 mp_pow_dec[shift];
         }
     } else {
@@ -6571,10 +6805,10 @@ static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
         /* number of digits after the decimal point */
         /* XXX: check (2 extra digits for rounding + 2 digits) */
         precl = (bf_max(a->expn - b->expn, 0) + 2 +
-                 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+                 prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
     } else {
         /* number of limbs of the quotient (2 extra digits for rounding) */
-         precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
+        precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
     }
     n = bf_max(a->len, precl);
     
@@ -6679,8 +6913,7 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
     }
 
     q_sign = a->sign ^ b->sign;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA ||
-               rnd_mode == BF_RNDNU);
+    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
     switch(rnd_mode) {
     default:
     case BF_RNDZ:
@@ -6694,12 +6927,12 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
     case BF_RNDU:
         is_ceil = q_sign ^ 1;
         break;
+    case BF_RNDA:
+        is_ceil = TRUE;
+        break;
     case BF_DIVREM_EUCLIDIAN:
         is_ceil = a->sign;
         break;
-    case BF_RNDNU:
-        /* XXX: unsupported yet */
-        abort();
     }
 
     a1->expn = a->expn;
@@ -6756,14 +6989,14 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
     return BF_ST_MEM_ERROR;
 }
 
-int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-               bf_flags_t flags)
+int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags, int rnd_mode)
 {
     bfdec_t q_s, *q = &q_s;
     int ret;
     
     bfdec_init(r->ctx, q);
-    ret = bfdec_divrem(q, r, a, b, prec, flags, BF_RNDZ);
+    ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
     bfdec_delete(q);
     return ret;
 }
@@ -6779,7 +7012,7 @@ int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags)
     bf_context_t *s = a->ctx;
     int ret, k;
     limb_t *a1, v;
-    slimb_t n, n1;
+    slimb_t n, n1, prec1;
     limb_t res;
 
     assert(r != a);
@@ -6798,9 +7031,14 @@ int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags)
         bfdec_set_nan(r);
         ret = BF_ST_INVALID_OP;
     } else {
+        if (flags & BF_FLAG_RADPNT_PREC) {
+            prec1 = bf_max(floor_div(a->expn + 1, 2) + prec, 1);
+        } else {
+            prec1 = prec;
+        }
         /* convert the mantissa to an integer with at least 2 *
            prec + 4 digits */
-        n = (2 * (prec + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
+        n = (2 * (prec1 + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
         if (bfdec_resize(r, n))
             goto fail;
         a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
@@ -6869,7 +7107,7 @@ int bfdec_get_int32(int *pres, const bfdec_t *a)
         v = 0;
         ret = 0;
     } else if (a->expn <= 9) {
-        v = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+        v = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
         if (a->sign)
             v = -v;
         ret = 0;
@@ -6877,7 +7115,7 @@ int bfdec_get_int32(int *pres, const bfdec_t *a)
         uint64_t v1;
         uint32_t v_max;
 #if LIMB_BITS == 64
-        v1 = fast_udiv(a->tab[a->len - 1], &mp_pow_div[LIMB_DIGITS - a->expn]);
+        v1 = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
 #else
         v1 = (uint64_t)a->tab[a->len - 1] * 10 +
             get_digit(a->tab, a->len, (a->len - 1) * LIMB_DIGITS - 1);
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index 500124c293..60439dcac1 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -41,8 +41,8 @@ typedef unsigned __int128 uint128_t;
 typedef int64_t slimb_t;
 typedef uint64_t limb_t;
 typedef uint128_t dlimb_t;
-#define EXP_MIN INT64_MIN
-#define EXP_MAX INT64_MAX
+#define BF_RAW_EXP_MIN INT64_MIN
+#define BF_RAW_EXP_MAX INT64_MAX
 
 #define LIMB_DIGITS 19
 #define BF_DEC_BASE UINT64_C(10000000000000000000)
@@ -52,8 +52,8 @@ typedef uint128_t dlimb_t;
 typedef int32_t slimb_t;
 typedef uint32_t limb_t;
 typedef uint64_t dlimb_t;
-#define EXP_MIN INT32_MIN
-#define EXP_MAX INT32_MAX
+#define BF_RAW_EXP_MIN INT32_MIN
+#define BF_RAW_EXP_MAX INT32_MAX
 
 #define LIMB_DIGITS 9
 #define BF_DEC_BASE 1000000000U
@@ -61,10 +61,17 @@ typedef uint64_t dlimb_t;
 #endif
 
 /* in bits */
+/* minimum number of bits for the exponent */
 #define BF_EXP_BITS_MIN 3
-#define BF_EXP_BITS_MAX (LIMB_BITS - 2)
+/* maximum number of bits for the exponent */
+#define BF_EXP_BITS_MAX (LIMB_BITS - 3)
+/* extended range for exponent, used internally */
+#define BF_EXT_EXP_BITS_MAX (BF_EXP_BITS_MAX + 1)
+/* minimum possible precision */
 #define BF_PREC_MIN 2
-#define BF_PREC_MAX (((limb_t)1 << BF_EXP_BITS_MAX) - 2)
+/* minimum possible precision */
+#define BF_PREC_MAX (((limb_t)1 << (LIMB_BITS - 2)) - 2)
+/* some operations support infinite precision */
 #define BF_PREC_INF (BF_PREC_MAX + 1) /* infinite precision */
 
 #if LIMB_BITS == 64
@@ -73,9 +80,9 @@ typedef uint64_t dlimb_t;
 #define BF_CHKSUM_MOD 975620677U
 #endif
 
-#define BF_EXP_ZERO EXP_MIN
-#define BF_EXP_INF (EXP_MAX - 1)
-#define BF_EXP_NAN EXP_MAX
+#define BF_EXP_ZERO BF_RAW_EXP_MIN
+#define BF_EXP_INF (BF_RAW_EXP_MAX - 1)
+#define BF_EXP_NAN BF_RAW_EXP_MAX
 
 /* +/-zero is represented with expn = BF_EXP_ZERO and len = 0,
    +/-infinity is represented with expn = BF_EXP_INF and len = 0,
@@ -101,27 +108,29 @@ typedef struct {
 typedef enum {
     BF_RNDN, /* round to nearest, ties to even */
     BF_RNDZ, /* round to zero */
-    BF_RNDD, /* round to -inf */
+    BF_RNDD, /* round to -inf (the code relies on (BF_RNDD xor BF_RNDU) = 1) */
     BF_RNDU, /* round to +inf */
     BF_RNDNA, /* round to nearest, ties away from zero */
-    BF_RNDNU, /* round to nearest, ties to +inf */
+    BF_RNDA, /* round away from zero */
     BF_RNDF, /* faithful rounding (nondeterministic, either RNDD or RNDU,
                 inexact flag is always set)  */
 } bf_rnd_t;
 
 /* allow subnormal numbers. Only available if the number of exponent
-   bits is < BF_EXP_BITS_MAX and prec != BF_PREC_INF. Not supported
-   for decimal floating point numbers. */
+   bits is <= BF_EXP_BITS_USER_MAX and prec != BF_PREC_INF. */
 #define BF_FLAG_SUBNORMAL (1 << 3)
 /* 'prec' is the precision after the radix point instead of the whole
-   mantissa. Can only be used with bf_round(), bfdec_round() and
-   bfdev_div(). */
+   mantissa. Can only be used with bf_round() and
+   bfdec_[add|sub|mul|div|sqrt|round](). */
 #define BF_FLAG_RADPNT_PREC (1 << 4)
 
 #define BF_RND_MASK 0x7
 #define BF_EXP_BITS_SHIFT 5
 #define BF_EXP_BITS_MASK 0x3f
 
+/* shortcut for bf_set_exp_bits(BF_EXT_EXP_BITS_MAX) */
+#define BF_FLAG_EXT_EXP (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)
+
 /* contains the rounding mode and number of exponents bits */
 typedef uint32_t bf_flags_t;
 
@@ -142,12 +151,17 @@ typedef struct bf_context_t {
 
 static inline int bf_get_exp_bits(bf_flags_t flags)
 {
-    return BF_EXP_BITS_MAX - ((flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK);
+    int e;
+    e = (flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK;
+    if (e == BF_EXP_BITS_MASK)
+        return BF_EXP_BITS_MAX + 1;
+    else
+        return BF_EXP_BITS_MAX - e;
 }
 
 static inline bf_flags_t bf_set_exp_bits(int n)
 {
-    return (BF_EXP_BITS_MAX - n) << BF_EXP_BITS_SHIFT;
+    return ((BF_EXP_BITS_MAX - n) & BF_EXP_BITS_MASK) << BF_EXP_BITS_SHIFT;
 }
 
 /* returned status */
@@ -249,9 +263,22 @@ int bf_set_float64(bf_t *a, double d);
 
 int bf_cmpu(const bf_t *a, const bf_t *b);
 int bf_cmp_full(const bf_t *a, const bf_t *b);
-int bf_cmp_eq(const bf_t *a, const bf_t *b);
-int bf_cmp_le(const bf_t *a, const bf_t *b);
-int bf_cmp_lt(const bf_t *a, const bf_t *b);
+int bf_cmp(const bf_t *a, const bf_t *b);
+static inline int bf_cmp_eq(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) == 0;
+}
+
+static inline int bf_cmp_le(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) <= 0;
+}
+
+static inline int bf_cmp_lt(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) < 0;
+}
+
 int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
 int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
 int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
@@ -264,12 +291,10 @@ int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags)
 #define BF_DIVREM_EUCLIDIAN BF_RNDF
 int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
               limb_t prec, bf_flags_t flags, int rnd_mode);
-int bf_fmod(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-            bf_flags_t flags);
-int bf_remainder(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                 bf_flags_t flags);
+int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+           bf_flags_t flags, int rnd_mode);
 int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-              bf_flags_t flags);
+              bf_flags_t flags, int rnd_mode);
 /* round to integer with infinite precision */
 int bf_rint(bf_t *r, int rnd_mode);
 int bf_round(bf_t *r, limb_t prec, bf_flags_t flags);
@@ -304,8 +329,8 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
 /* Conversion of floating point number to string. Return a null
    terminated string or NULL if memory error. *plen contains its
    length if plen != NULL.  The exponent letter is "e" for base 10,
-   "p" for bases 2, 8, 16 with the binary exponent and "@" for the
-   other bases. */
+   "p" for bases 2, 8, 16 with a binary exponent and "@" for the other
+   bases. */
 
 #define BF_FTOA_FORMAT_MASK (3 << 16)
 
@@ -316,17 +341,23 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
 /* fractional format: prec digits after the decimal point rounded with
    (flags & BF_RND_MASK) */
 #define BF_FTOA_FORMAT_FRAC  (1 << 16)
-/* free format: use as many digits as necessary so that bf_atof()
-   return the same number when using precision 'prec', rounding to
-   nearest and the subnormal+exponent configuration of 'flags'. The
-   result is meaningful only if 'a' is already rounded to the wanted
-   precision.
+/* free format: 
+   
+   For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
+   number of digits to represent 'a'. The precision and the rounding
+   mode are ignored.
    
-   Infinite precision (BF_PREC_INF) is supported when the radix is a
-   power of two. */
+   For the non binary radices with bf_ftoa(): use as many digits as
+   necessary so that bf_atof() return the same number when using
+   precision 'prec', rounding to nearest and the subnormal
+   configuration of 'flags'. The result is meaningful only if 'a' is
+   already rounded to 'prec' bits. If the subnormal flag is set, the
+   exponent in 'flags' must also be set to the desired exponent range.
+*/
 #define BF_FTOA_FORMAT_FREE  (2 << 16)
 /* same as BF_FTOA_FORMAT_FREE but uses the minimum number of digits
-   (takes more computation time). */
+   (takes more computation time). Identical to BF_FTOA_FORMAT_FREE for
+   binary radices with bf_ftoa() and for bfdec_ftoa(). */
 #define BF_FTOA_FORMAT_FREE_MIN (3 << 16)
 
 /* force exponential notation for fixed or free format */
@@ -370,7 +401,7 @@ int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags);
 int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags);
 int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
 int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-#define BF_POW_JS_QUICKS (1 << 16)
+#define BF_POW_JS_QUIRKS (1 << 16) /* (+/-1)^(+/-Inf) = NaN, 1^NaN = NaN */
 int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags);
 int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
 int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
@@ -448,17 +479,21 @@ static inline int bfdec_cmp_full(const bfdec_t *a, const bfdec_t *b)
 {
     return bf_cmp_full((const bf_t *)a, (const bf_t *)b);
 }
+static inline int bfdec_cmp(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp((const bf_t *)a, (const bf_t *)b);
+}
 static inline int bfdec_cmp_eq(const bfdec_t *a, const bfdec_t *b)
 {
-    return bf_cmp_eq((const bf_t *)a, (const bf_t *)b);
+    return bfdec_cmp(a, b) == 0;
 }
 static inline int bfdec_cmp_le(const bfdec_t *a, const bfdec_t *b)
 {
-    return bf_cmp_le((const bf_t *)a, (const bf_t *)b);
+    return bfdec_cmp(a, b) <= 0;
 }
 static inline int bfdec_cmp_lt(const bfdec_t *a, const bfdec_t *b)
 {
-    return bf_cmp_lt((const bf_t *)a, (const bf_t *)b);
+    return bfdec_cmp(a, b) < 0;
 }
 
 int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
@@ -475,8 +510,8 @@ int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
               bf_flags_t flags);
 int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
                  limb_t prec, bf_flags_t flags, int rnd_mode);
-int bfdec_fmod(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-               bf_flags_t flags);
+int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags, int rnd_mode);
 int bfdec_rint(bfdec_t *r, int rnd_mode);
 int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags);
 int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags);
@@ -488,7 +523,7 @@ int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
                limb_t prec, bf_flags_t flags);
 
 /* the following functions are exported for testing only. */
-extern limb_t mp_pow_dec[LIMB_DIGITS + 1];
+extern const limb_t mp_pow_dec[LIMB_DIGITS + 1];
 void bfdec_print_str(const char *str, const bfdec_t *a);
 static inline int bfdec_resize(bfdec_t *r, limb_t len)
 {
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 92042d2735..501aa1f8db 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -219,6 +219,8 @@ DEF(BigInt, "BigInt")
 DEF(BigFloat, "BigFloat")
 DEF(BigFloatEnv, "BigFloatEnv")
 DEF(BigDecimal, "BigDecimal")
+DEF(OperatorSet, "OperatorSet")
+DEF(Operators, "Operators")
 #endif
 DEF(Map, "Map")
 DEF(Set, "Set") /* Map + 1 */
@@ -263,27 +265,7 @@ DEF(Symbol_species, "Symbol.species")
 DEF(Symbol_unscopables, "Symbol.unscopables")
 DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
 #ifdef CONFIG_BIGNUM
-DEF(Symbol_operatorOrder, "Symbol.operatorOrder")
-DEF(Symbol_operatorAdd, "Symbol.operatorAdd")
-DEF(Symbol_operatorSub, "Symbol.operatorSub")
-DEF(Symbol_operatorMul, "Symbol.operatorMul")
-DEF(Symbol_operatorDiv, "Symbol.operatorDiv")
-DEF(Symbol_operatorMod, "Symbol.operatorMod")
-DEF(Symbol_operatorPow, "Symbol.operatorPow")
-DEF(Symbol_operatorShl, "Symbol.operatorShl")
-DEF(Symbol_operatorShr, "Symbol.operatorShr")
-DEF(Symbol_operatorAnd, "Symbol.operatorAnd")
-DEF(Symbol_operatorOr, "Symbol.operatorOr")
-DEF(Symbol_operatorXor, "Symbol.operatorXor")
-DEF(Symbol_operatorCmpLT, "Symbol.operatorCmpLT")
-DEF(Symbol_operatorCmpLE, "Symbol.operatorCmpLE")
-DEF(Symbol_operatorCmpEQ, "Symbol.operatorCmpEQ")
-DEF(Symbol_operatorPlus, "Symbol.operatorPlus")
-DEF(Symbol_operatorNeg, "Symbol.operatorNeg")
-DEF(Symbol_operatorNot, "Symbol.operatorNot")
-DEF(Symbol_operatorInc, "Symbol.operatorInc")
-DEF(Symbol_operatorDec, "Symbol.operatorDec")
-DEF(Symbol_operatorMathMod, "Symbol.operatorMathMod")
+DEF(Symbol_operatorSet, "Symbol.operatorSet")
 #endif
-
+    
 #endif /* DEF */
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index da53fefc18..aff1b8911a 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -2027,6 +2027,20 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
 
 #if !defined(_WIN32)
 
+static JSValue js_os_chdir(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
+{
+    const char *target;
+    int err;
+
+    target = JS_ToCString(ctx, argv[0]);
+    if (!target)
+        return JS_EXCEPTION;
+    err = chdir(target);
+    JS_FreeCString(ctx, target);
+    return js_os_return(ctx, err);
+}
+
 /* return [path, errorcode] */
 static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv)
@@ -2581,6 +2595,7 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
     JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
 #if !defined(_WIN32)
+    JS_CFUNC_DEF("chdir", 0, js_os_chdir ),
     JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
     JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
     JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index cc514e5502..57f6969b1e 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -260,9 +260,7 @@ DEF(             or, 1, 2, 1, none)
 DEF(is_undefined_or_null, 1, 1, 1, none)
 #ifdef CONFIG_BIGNUM
 DEF(      mul_pow10, 1, 2, 1, none)
-DEF(       math_div, 1, 2, 1, none)
 DEF(       math_mod, 1, 2, 1, none)
-DEF(       math_pow, 1, 2, 1, none)
 #endif
 /* must be the last non short and non temporary opcode */
 DEF(            nop, 1, 0, 0, none) 
@@ -271,7 +269,6 @@ DEF(            nop, 1, 0, 0, none)
 
 def(set_arg_valid_upto, 3, 0, 0, arg) /* emitted in phase 1, removed in phase 2 */
 
-def(close_var_object, 1, 0, 0, none) /* emitted in phase 1, removed in phase 2 */
 def(    enter_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
 def(    leave_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
 
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 646af8aacc..b19a4d9fdb 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -42,10 +42,6 @@
 #include "list.h"
 #include "quickjs.h"
 #include "libregexp.h"
-
-/* enable bignums */
-#define CONFIG_BIGNUM
-
 #ifdef CONFIG_BIGNUM
 #include "libbf.h"
 #endif
@@ -151,7 +147,8 @@ enum {
     JS_CLASS_BIG_INT,           /* u.object_data */
     JS_CLASS_BIG_FLOAT,         /* u.object_data */
     JS_CLASS_FLOAT_ENV,         /* u.float_env */
-    JS_CLASS_BIG_DECIMAL,         /* u.object_data */
+    JS_CLASS_BIG_DECIMAL,       /* u.object_data */
+    JS_CLASS_OPERATOR_SET,      /* u.operator_set */
 #endif
     JS_CLASS_MAP,               /* u.map_state */
     JS_CLASS_SET,               /* u.map_state */
@@ -285,6 +282,7 @@ struct JSRuntime {
     JSNumericOperations bigint_ops;
     JSNumericOperations bigfloat_ops;
     JSNumericOperations bigdecimal_ops;
+    uint32_t operator_count;
 #endif
 };
 
@@ -300,8 +298,7 @@ struct JSClass {
 
 #define JS_MODE_STRICT (1 << 0)
 #define JS_MODE_STRIP  (1 << 1)
-#define JS_MODE_BIGINT (1 << 2)
-#define JS_MODE_MATH   (1 << 3)
+#define JS_MODE_MATH   (1 << 2)
 
 typedef struct JSStackFrame {
     struct JSStackFrame *prev_frame; /* NULL if first stack frame */
@@ -312,7 +309,7 @@ typedef struct JSStackFrame {
     const uint8_t *cur_pc; /* only used in bytecode functions : PC of the
                         instruction after the call */
     int arg_count;
-    int js_mode; /* 0 or JS_MODE_BIGINT for C functions */
+    int js_mode; /* 0 or JS_MODE_MATH for C functions */
     /* only used in generators. Current stack pointer value. NULL if
        the function is running. */ 
     JSValue *cur_sp;
@@ -419,8 +416,8 @@ struct JSContext {
 #ifdef CONFIG_BIGNUM
     bf_context_t *bf_ctx;   /* points to rt->bf_ctx, shared by all contexts */
     JSFloatEnv fp_env; /* global FP environment */
-    BOOL bignum_ext; /* enable bigint mode, math mode and operator
-                        overloading */
+    BOOL bignum_ext : 8; /* enable math mode */
+    BOOL allow_operator_overloading : 8;
 #endif
     /* when the counter reaches zero, JSRutime.interrupt_handler is called */
     int interrupt_counter;
@@ -653,6 +650,53 @@ typedef struct JSAsyncFunctionData {
     JSAsyncFunctionState func_state;
 } JSAsyncFunctionData;
 
+typedef enum {
+   /* binary operators */
+   JS_OVOP_ADD,
+   JS_OVOP_SUB,
+   JS_OVOP_MUL,
+   JS_OVOP_DIV,
+   JS_OVOP_MOD,
+   JS_OVOP_POW,
+   JS_OVOP_OR,
+   JS_OVOP_AND,
+   JS_OVOP_XOR,
+   JS_OVOP_SHL,
+   JS_OVOP_SAR,
+   JS_OVOP_SHR,
+   JS_OVOP_EQ,
+   JS_OVOP_LESS,
+
+   JS_OVOP_BINARY_COUNT,
+   /* unary operators */
+   JS_OVOP_POS = JS_OVOP_BINARY_COUNT,
+   JS_OVOP_NEG,
+   JS_OVOP_INC,
+   JS_OVOP_DEC,
+   JS_OVOP_NOT,
+
+   JS_OVOP_COUNT,
+} JSOverloadableOperatorEnum;
+
+typedef struct {
+    uint32_t operator_index;
+    JSObject *ops[JS_OVOP_BINARY_COUNT]; /* self operators */
+} JSBinaryOperatorDefEntry;
+
+typedef struct {
+    int count;
+    JSBinaryOperatorDefEntry *tab;
+} JSBinaryOperatorDef;
+
+typedef struct {
+    uint32_t operator_counter;
+    BOOL is_primitive; /* OperatorSet for a primitive type */
+    /* NULL if no operator is defined */
+    JSObject *self_ops[JS_OVOP_COUNT]; /* self operators */
+    JSBinaryOperatorDef left;
+    JSBinaryOperatorDef right;
+} JSOperatorSetData;
+
 typedef struct JSReqModuleEntry {
     JSAtom module_name;
     JSModuleDef *module; /* used using resolution */
@@ -808,6 +852,7 @@ struct JSObject {
         struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_DATAVIEW */
 #ifdef CONFIG_BIGNUM
         struct JSFloatEnv *float_env; /* JS_CLASS_FLOAT_ENV */
+        struct JSOperatorSetData *operator_set; /* JS_CLASS_OPERATOR_SET */
 #endif
         struct JSMapState *map_state;   /* JS_CLASS_MAP..JS_CLASS_WEAKSET */
         struct JSMapIteratorData *map_iterator_data; /* JS_CLASS_MAP_ITERATOR, JS_CLASS_SET_ITERATOR */
@@ -991,6 +1036,11 @@ static void js_promise_mark(JSRuntime *rt, JSValueConst val,
 static void js_promise_resolve_function_finalizer(JSRuntime *rt, JSValue val);
 static void js_promise_resolve_function_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
+#ifdef CONFIG_BIGNUM
+static void js_operator_set_finalizer(JSRuntime *rt, JSValue val);
+static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
+                                 JS_MarkFunc *mark_func);
+#endif
 static JSValue JS_ToStringFree(JSContext *ctx, JSValue val);
 static int JS_ToBoolFree(JSContext *ctx, JSValue val);
 static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val);
@@ -1021,10 +1071,27 @@ static JSProperty *add_property(JSContext *ctx,
                                 JSObject *p, JSAtom prop, int prop_flags);
 #ifdef CONFIG_BIGNUM
 static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
-static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a);
-static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a);
-static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint);
-static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a);
+static JSValue JS_NewBigFloat(JSContext *ctx);
+static inline bf_t *JS_GetBigFloat(JSValueConst val)
+{
+    JSBigFloat *p = JS_VALUE_GET_PTR(val);
+    return &p->num;
+}
+static JSValue JS_NewBigDecimal(JSContext *ctx);
+static inline bfdec_t *JS_GetBigDecimal(JSValueConst val)
+{
+    JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+    return &p->num;
+}
+static JSValue JS_NewBigInt(JSContext *ctx);
+static inline bf_t *JS_GetBigInt(JSValueConst val)
+{
+    JSBigFloat *p = JS_VALUE_GET_PTR(val);
+    return &p->num;
+}
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+                                 BOOL convert_to_safe_integer);
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val);
 static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
 static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
 static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
@@ -1123,19 +1190,6 @@ static const JSClassExoticMethods js_proxy_exotic_methods;
 static const JSClassExoticMethods js_module_ns_exotic_methods;
 static JSClassID js_class_id_alloc = JS_CLASS_INIT_COUNT;
 
-JS_BOOL JS_IsNumber(JSValueConst v)
-{
-#ifdef CONFIG_BIGNUM
-    /* XXX: check the bignum case. Should use a different function */
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
-        tag == JS_TAG_BIG_FLOAT || JS_TAG_IS_FLOAT64(tag);
-#else
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);
-#endif
-}
-
 static void js_trigger_gc(JSRuntime *rt, size_t size)
 {
     BOOL force_gc;
@@ -1333,6 +1387,7 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_BigFloat, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_FLOAT */
     { JS_ATOM_BigFloatEnv, js_float_env_finalizer, NULL },      /* JS_CLASS_FLOAT_ENV */
     { JS_ATOM_BigDecimal, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_DECIMAL */
+    { JS_ATOM_OperatorSet, js_operator_set_finalizer, js_operator_set_mark },    /* JS_CLASS_OPERATOR_SET */
 #endif
     { JS_ATOM_Map, js_map_finalizer, js_map_mark },             /* JS_CLASS_MAP */
     { JS_ATOM_Set, js_map_finalizer, js_map_mark },             /* JS_CLASS_SET */
@@ -2136,10 +2191,10 @@ static inline BOOL is_strict_mode(JSContext *ctx)
 }
 
 #ifdef CONFIG_BIGNUM
-static inline BOOL is_bigint_mode(JSContext *ctx)
+static inline BOOL is_math_mode(JSContext *ctx)
 {
     JSStackFrame *sf = ctx->current_stack_frame;
-    return (sf && (sf->js_mode & JS_MODE_BIGINT));
+    return (sf && (sf->js_mode & JS_MODE_MATH));
 }
 #endif
 
@@ -2148,25 +2203,12 @@ JSValue JS_NewInt64(JSContext *ctx, int64_t v)
     if (v == (int32_t)v) {
         return JS_NewInt32(ctx, v);
     } else {
-#ifdef CONFIG_BIGNUM
-        if (is_bigint_mode(ctx)) {
-            bf_t a_s, *a = &a_s;
-            bf_init(ctx->bf_ctx, a);
-            bf_set_si(a, v);
-            return JS_NewBigInt(ctx, a);
-        } else
-#endif
-        {
-            return __JS_NewFloat64(ctx, (double)v);
-        }
+        return __JS_NewFloat64(ctx, (double)v);
     }
 }
 
 static force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
 {
-#ifdef CONFIG_BIGNUM
-    return JS_NewInt64(ctx, val);
-#else
     JSValue v;
     if (val <= 0x7fffffff) {
         v = JS_MKVAL(JS_TAG_INT, val);
@@ -2174,7 +2216,6 @@ static force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
         v = __JS_NewFloat64(ctx, val);
     }
     return v;
-#endif
 }
 
 /* JSAtom support */
@@ -5720,6 +5761,7 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
 #ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:           /* u.object_data */
         case JS_CLASS_BIG_FLOAT:         /* u.object_data */
+        case JS_CLASS_BIG_DECIMAL:         /* u.object_data */
 #endif
             compute_value_size(p->u.object_data, hp);
             break;
@@ -6515,28 +6557,17 @@ JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val)
     case JS_TAG_BIG_INT:
         val = ctx->class_proto[JS_CLASS_BIG_INT];
         break;
-    case JS_TAG_INT:
-        if (is_bigint_mode(ctx)) {
-            val = ctx->class_proto[JS_CLASS_BIG_INT];
-        } else {
-            val = ctx->class_proto[JS_CLASS_NUMBER];
-        }
-        break;
-    case JS_TAG_FLOAT64:
-        val = ctx->class_proto[JS_CLASS_NUMBER];
-        break;
     case JS_TAG_BIG_FLOAT:
         val = ctx->class_proto[JS_CLASS_BIG_FLOAT];
         break;
     case JS_TAG_BIG_DECIMAL:
         val = ctx->class_proto[JS_CLASS_BIG_DECIMAL];
         break;
-#else
+#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         val = ctx->class_proto[JS_CLASS_NUMBER];
         break;
-#endif
     case JS_TAG_BOOL:
         val = ctx->class_proto[JS_CLASS_BOOLEAN];
         break;
@@ -7750,11 +7781,7 @@ static int set_array_length(JSContext *ctx, JSObject *p, JSProperty *prop,
             }
             p->u.array.count = len;
         }
-#ifdef CONFIG_BIGNUM
-        set_value(ctx, &prop->u.value, JS_NewUint32(ctx, len));
-#else
         prop->u.value = JS_NewUint32(ctx, len);
-#endif
     } else {
         /* Note: length is always a uint32 because the object is an
            array */
@@ -9352,9 +9379,6 @@ void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id)
 #define HINT_STRING  0
 #define HINT_NUMBER  1
 #define HINT_NONE    2
-#ifdef CONFIG_BIGNUM
-#define HINT_INTEGER 3
-#endif
 /* don't try Symbol.toPrimitive */
 #define HINT_FORCE_ORDINARY (1 << 4)
 
@@ -9389,11 +9413,6 @@ static JSValue JS_ToPrimitiveFree(JSContext *ctx, JSValue val, int hint)
             case HINT_NONE:
                 atom = JS_ATOM_default;
                 break;
-#ifdef CONFIG_BIGNUM
-            case HINT_INTEGER:
-                atom = JS_ATOM_integer;
-                break;
-#endif
             }
             arg = JS_AtomToString(ctx, atom);
             ret = JS_CallFree(ctx, method, val, 1, (JSValueConst *)&arg);
@@ -9605,22 +9624,31 @@ static JSValue js_string_to_bigint(JSContext *ctx, const char *buf,
 {
     bf_t a_s, *a = &a_s;
     int ret;
-    bf_init(ctx->bf_ctx, a);
+    JSValue val;
+    val = JS_NewBigInt(ctx);
+    if (JS_IsException(val))
+        return val;
+    a = JS_GetBigInt(val);
     ret = bf_atof(a, buf, NULL, radix, BF_PREC_INF, BF_RNDZ);
     if (ret & BF_ST_MEM_ERROR) {
-        bf_delete(a);
+        JS_FreeValue(ctx, val);
         return JS_ThrowOutOfMemory(ctx);
     }
-    return JS_NewBigInt2(ctx, a, !(flags & ATOD_MODE_BIGINT));
+    val = JS_CompactBigInt1(ctx, val, (flags & ATOD_MODE_BIGINT) != 0);
+    return val;
 }
 
 static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
                                      int radix, int flags, slimb_t *pexponent)
 {
-    bf_t a_s, *a = &a_s;
+    bf_t *a;
     int ret;
-
-    bf_init(ctx->bf_ctx, a);
+    JSValue val;
+    
+    val = JS_NewBigFloat(ctx);
+    if (JS_IsException(val))
+        return val;
+    a = JS_GetBigFloat(val);
     if (flags & ATOD_ACCEPT_SUFFIX) {
         /* return the exponent to get infinite precision */
         ret = bf_atof2(a, pexponent, buf, NULL, radix, BF_PREC_INF,
@@ -9630,25 +9658,30 @@ static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
                       ctx->fp_env.flags);
     }
     if (ret & BF_ST_MEM_ERROR) {
-        bf_delete(a);
+        JS_FreeValue(ctx, val);
         return JS_ThrowOutOfMemory(ctx);
     }
-    return JS_NewBigFloat(ctx, a);
+    return val;
 }
 
 static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
                                        int radix, int flags, slimb_t *pexponent)
 {
-    bfdec_t a_s, *a = &a_s;
+    bfdec_t *a;
     int ret;
-    bfdec_init(ctx->bf_ctx, a);
+    JSValue val;
+    
+    val = JS_NewBigDecimal(ctx);
+    if (JS_IsException(val))
+        return val;
+    a = JS_GetBigDecimal(val);
     ret = bfdec_atof(a, buf, NULL, BF_PREC_INF,
                      BF_RNDZ | BF_ATOF_NO_NAN_INF);
     if (ret & BF_ST_MEM_ERROR) {
-        bfdec_delete(a);
+        JS_FreeValue(ctx, val);
         return JS_ThrowOutOfMemory(ctx);
     }
-    return JS_NewBigDecimal(ctx, a);
+    return val;
 }
 
 #endif
@@ -9730,10 +9763,12 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
             strstart(p, "Infinity", &p)) {
 #ifdef CONFIG_BIGNUM
             if (atod_type == ATOD_TYPE_BIG_FLOAT) {
-                bf_t a_s, *a = &a_s;
-                bf_init(ctx->bf_ctx, a);
+                bf_t *a;
+                val = JS_NewBigFloat(ctx);
+                if (JS_IsException(val))
+                    goto done;
+                a = JS_GetBigFloat(val);
                 bf_set_inf(a, is_neg);
-                val = JS_NewBigFloat(ctx, a);
             } else
 #endif
             {
@@ -9810,7 +9845,7 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
         } else if (*p == 'l') {
             p++;
             atod_type = ATOD_TYPE_BIG_FLOAT;
-        } else if (*p == 'd') {
+        } else if (*p == 'm') {
             p++;
             atod_type = ATOD_TYPE_BIG_DECIMAL;
         } else {
@@ -9901,7 +9936,6 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
 
 typedef enum JSToNumberHintEnum {
     TON_FLAG_NUMBER,
-    TON_FLAG_INTEGER,
     TON_FLAG_NUMERIC,
 } JSToNumberHintEnum;
 
@@ -9910,7 +9944,6 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
 {
     uint32_t tag;
     JSValue ret;
-    int hint;
 
  redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
@@ -9924,12 +9957,19 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
         ret = val;
         break;
     case JS_TAG_BIG_INT:
-        if (flag == TON_FLAG_NUMBER && !is_bigint_mode(ctx)) {
+        if (flag != TON_FLAG_NUMERIC) {
             JS_FreeValue(ctx, val);
             return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
         }
-        /* fall thru */
+        ret = val;
+        break;
     case JS_TAG_BIG_FLOAT:
+        if (flag != TON_FLAG_NUMERIC) {
+            JS_FreeValue(ctx, val);
+            return JS_ThrowTypeError(ctx, "cannot convert bigfloat to number");
+        }
+        ret = val;
+        break;
 #endif
     case JS_TAG_FLOAT64:
     case JS_TAG_INT:
@@ -9944,12 +9984,7 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
         ret = JS_NAN;
         break;
     case JS_TAG_OBJECT:
-#ifdef CONFIG_BIGNUM
-        hint = flag == TON_FLAG_INTEGER ? HINT_INTEGER : HINT_NUMBER;
-#else
-        hint = HINT_NUMBER;
-#endif
-        val = JS_ToPrimitiveFree(ctx, val, hint);
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
         if (JS_IsException(val))
             return JS_EXCEPTION;
         goto redo;
@@ -9969,10 +10004,6 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
                 ret = JS_NewInt32(ctx, 0);
             } else {
                 int flags = ATOD_ACCEPT_BIN_OCT;
-#ifdef CONFIG_BIGNUM
-                if (is_bigint_mode(ctx))
-                    flags |= ATOD_MODE_BIGINT;
-#endif
                 ret = js_atof(ctx, p, &p, 0, flags);
                 if (!JS_IsException(ret)) {
                     p += skip_spaces(p);
@@ -10001,7 +10032,6 @@ static JSValue JS_ToNumberFree(JSContext *ctx, JSValue val)
     return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMBER);
 }
 
-#ifdef CONFIG_BIGNUM
 static JSValue JS_ToNumericFree(JSContext *ctx, JSValue val)
 {
     return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMERIC);
@@ -10011,7 +10041,6 @@ static JSValue JS_ToNumeric(JSContext *ctx, JSValueConst val)
 {
     return JS_ToNumericFree(ctx, JS_DupValue(ctx, val));
 }
-#endif
 
 static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
                                           JSValue val)
@@ -10078,6 +10107,7 @@ static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val)
     return JS_ToNumberFree(ctx, JS_DupValue(ctx, val));
 }
 
+/* same as JS_ToNumber() but return 0 in case of NaN/Undefined */
 static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag;
@@ -10106,11 +10136,6 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
         }
         break;
 #ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_INT:
-        if (!is_bigint_mode(ctx))
-            goto to_number;
-        ret = val;
-        break;
     case JS_TAG_BIG_FLOAT:
         {
             bf_t a_s, *a, r_s, *r = &r_s;
@@ -10124,10 +10149,13 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
                 else
                     ret = JS_DupValue(ctx, val);
             } else {
-                bf_init(ctx->bf_ctx, r);
-                bf_set(r, a);
-                bf_rint(r, BF_RNDZ);
-                ret = JS_NewBigInt(ctx, r);
+                ret = JS_NewBigInt(ctx);
+                if (!JS_IsException(ret)) {
+                    r = JS_GetBigInt(ret);
+                    bf_set(r, a);
+                    bf_rint(r, BF_RNDZ);
+                    ret = JS_CompactBigInt(ctx, ret);
+                }
             }
             if (a == &a_s)
                 bf_delete(a);
@@ -10136,9 +10164,6 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
         break;
 #endif
     default:
-#ifdef CONFIG_BIGNUM
-    to_number:
-#endif
         val = JS_ToNumberFree(ctx, val);
         if (JS_IsException(val))
             return val;
@@ -10182,17 +10207,12 @@ static int JS_ToInt32SatFree(JSContext *ctx, int *pres, JSValue val)
         break;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
-    to_bf:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             bf_get_int32(&ret, &p->num, 0);
             JS_FreeValue(ctx, val);
         }
         break;
-    case JS_TAG_BIG_INT:
-        if (is_bigint_mode(ctx))
-            goto to_bf;
-        /* fall thru */
 #endif
     default:
         val = JS_ToNumberFree(ctx, val);
@@ -10261,17 +10281,12 @@ static int JS_ToInt64SatFree(JSContext *ctx, int64_t *pres, JSValue val)
         return 0;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
-    to_bf:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             bf_get_int64(pres, &p->num, 0);
             JS_FreeValue(ctx, val);
         }
         return 0;
-    case JS_TAG_BIG_INT:
-        if (is_bigint_mode(ctx))
-            goto to_bf;
-        /* fall thru */
 #endif
     default:
         val = JS_ToNumberFree(ctx, val);
@@ -10346,17 +10361,12 @@ static int JS_ToInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
         break;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
-    to_bf:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             bf_get_int64(&ret, &p->num, BF_GET_INT_MOD);
             JS_FreeValue(ctx, val);
         }
         break;
-    case JS_TAG_BIG_INT:
-        if (is_bigint_mode(ctx))
-            goto to_bf;
-        /* fall thru */
 #endif
     default:
         val = JS_ToNumberFree(ctx, val);
@@ -10418,17 +10428,12 @@ static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
         break;
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
-    to_bf:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             bf_get_int32(&ret, &p->num, BF_GET_INT_MOD);
             JS_FreeValue(ctx, val);
         }
         break;
-    case JS_TAG_BIG_INT:
-        if (is_bigint_mode(ctx))
-            goto to_bf;
-        /* fall thru */
 #endif
     default:
         val = JS_ToNumberFree(ctx, val);
@@ -10486,15 +10491,6 @@ static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
         }
         break;
 #ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_INT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            if (!is_bigint_mode(ctx))
-                goto to_number;
-            bf_get_int32(&res, &p->num, 0);
-            JS_FreeValue(ctx, val);
-        }
-        goto int_clamp;
     case JS_TAG_BIG_FLOAT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
@@ -10509,9 +10505,6 @@ static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
         goto int_clamp;
 #endif
     default:
-#ifdef CONFIG_BIGNUM
-    to_number:
-#endif
         val = JS_ToNumberFree(ctx, val);
         if (JS_IsException(val)) {
             *pres = 0;
@@ -10584,6 +10577,12 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
 
 #define MAX_SAFE_INTEGER (((int64_t)1 << 53) - 1)
 
+static BOOL is_safe_integer(double d)
+{
+    return isfinite(d) && floor(d) == d &&
+        fabs(d) <= (double)MAX_SAFE_INTEGER;
+}
+
 int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val)
 {
     int64_t v;
@@ -10609,7 +10608,6 @@ static __exception int JS_ToLengthFree(JSContext *ctx, int64_t *plen,
 }
 
 /* Note: can return an exception */
-/* XXX: bignum case */
 static int JS_NumberIsInteger(JSContext *ctx, JSValueConst val)
 {
     double d;
@@ -10753,7 +10751,8 @@ static JSValue js_bigfloat_to_string(JSContext *ctx, JSValueConst val)
     return js_ftoa(ctx, val, 10, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
 }
 
-static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+static JSValue js_bigdecimal_to_string1(JSContext *ctx, JSValueConst val,
+                                        limb_t prec, int flags)
 {
     JSValue ret;
     bfdec_t *a;
@@ -10764,8 +10763,7 @@ static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
     saved_sign = a->sign;
     if (a->expn == BF_EXP_ZERO)
         a->sign = 0;
-    str = bfdec_ftoa(NULL, a, 0, BF_RNDZ | BF_FTOA_FORMAT_FREE |
-                     BF_FTOA_JS_QUIRKS);
+    str = bfdec_ftoa(NULL, a, prec, flags | BF_FTOA_JS_QUIRKS);
     a->sign = saved_sign;
     if (!str)
         return JS_ThrowOutOfMemory(ctx);
@@ -10774,6 +10772,12 @@ static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
     return ret;
 }
 
+static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+{
+    return js_bigdecimal_to_string1(ctx, val, 0,
+                                    BF_RNDZ | BF_FTOA_FORMAT_FREE);
+}
+
 #endif /* CONFIG_BIGNUM */
 
 /* 2 <= base <= 36 */
@@ -11478,30 +11482,48 @@ static double js_pow(double a, double b)
 
 #ifdef CONFIG_BIGNUM
 
+JSValue JS_NewBigInt64_1(JSContext *ctx, int64_t v)
+{
+    JSValue val;
+    bf_t *a;
+    val = JS_NewBigInt(ctx);
+    if (JS_IsException(val))
+        return val;
+    a = JS_GetBigInt(val);
+    if (bf_set_si(a, v)) {
+        JS_FreeValue(ctx, val);
+        return JS_ThrowOutOfMemory(ctx);
+    }
+    return val;
+}
+
 JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
 {
-    BOOL is_bignum = is_bigint_mode(ctx);
-    if (is_bignum && v == (int32_t)v) {
-        return JS_NewInt32(ctx, v);
+    if (is_math_mode(ctx) &&
+        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
+        return JS_NewInt64(ctx, v);
     } else {
-        bf_t a_s, *a = &a_s;
-        bf_init(ctx->bf_ctx, a);
-        bf_set_si(a, v);
-        return JS_NewBigInt2(ctx, a, TRUE);
+        return JS_NewBigInt64_1(ctx, v);
     }
 }
 
 JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
 {
-    BOOL is_bignum = is_bigint_mode(ctx);
-    if (is_bignum && v == (int32_t)v) {
-        return JS_NewInt32(ctx, v);
+    JSValue val;
+    if (is_math_mode(ctx) && v <= MAX_SAFE_INTEGER) {
+        val = JS_NewInt64(ctx, v);
     } else {
-        bf_t a_s, *a = &a_s;
-        bf_init(ctx->bf_ctx, a);
-        bf_set_ui(a, v);
-        return JS_NewBigInt2(ctx, a, TRUE);
+        bf_t *a;
+        val = JS_NewBigInt(ctx);
+        if (JS_IsException(val))
+            return val;
+        a = JS_GetBigInt(val);
+        if (bf_set_ui(a, v)) {
+            JS_FreeValue(ctx, val);
+            return JS_ThrowOutOfMemory(ctx);
+        }
     }
+    return val;
 }
 
 /* if the returned bigfloat is allocated it is equal to
@@ -11582,13 +11604,10 @@ static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
     p = str;
     p += skip_spaces(p);
     if ((p - str) == len) {
-        bf_t a_s, *a = &a_s;
-        bf_init(ctx->bf_ctx, a);
-        bf_set_si(a, 0);
-        val = JS_NewBigInt(ctx, a);
+        val = JS_NewBigInt64(ctx, 0);
     } else {
         flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
-        if (is_bigint_mode(ctx))
+        if (is_math_mode(ctx))
             flags |= ATOD_MODE_BIGINT;
         val = js_atof(ctx, p, &p, 0, flags);
         p += skip_spaces(p);
@@ -11625,7 +11644,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
     case JS_TAG_INT:
     case JS_TAG_NULL:
     case JS_TAG_UNDEFINED:
-        if (!is_bigint_mode(ctx))
+        if (!is_math_mode(ctx))
             goto fail;
         /* fall tru */
     case JS_TAG_BOOL:
@@ -11636,7 +11655,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
     case JS_TAG_FLOAT64:
         {
             double d = JS_VALUE_GET_FLOAT64(val);
-            if (!is_bigint_mode(ctx))
+            if (!is_math_mode(ctx))
                 goto fail;
             if (!isfinite(d))
                 goto fail;
@@ -11651,7 +11670,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
         r = &p->num;
         break;
     case JS_TAG_BIG_FLOAT:
-        if (!is_bigint_mode(ctx))
+        if (!is_math_mode(ctx))
             goto fail;
         p = JS_VALUE_GET_PTR(val);
         if (!bf_is_finite(&p->num))
@@ -11668,8 +11687,7 @@ static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
             return NULL;
         goto redo;
     case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val,
-                                 is_bigint_mode(ctx) ? HINT_INTEGER : HINT_NUMBER);
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
         if (JS_IsException(val))
             return NULL;
         goto redo;
@@ -11692,21 +11710,26 @@ static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
     if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
         return val;
     } else {
-        bf_t a_s, *a, b_s, *b;
+        bf_t a_s, *a, *r;
         int ret;
-        
+        JSValue res; 
+
+        res = JS_NewBigInt(ctx);
+        if (JS_IsException(res))
+            return JS_EXCEPTION;
         a = JS_ToBigIntFree(ctx, &a_s, val);
-        if (!a)
+        if (!a) {
+            JS_FreeValue(ctx, res);
             return JS_EXCEPTION;
-        b = &b_s;
-        bf_init(ctx->bf_ctx, b);
-        ret = bf_set(b, a);
+        }
+        r = JS_GetBigInt(res);
+        ret = bf_set(r, a);
         JS_FreeBigInt(ctx, a, &a_s);
         if (ret) {
-            bf_delete(b);
+            JS_FreeValue(ctx, res);
             return JS_ThrowOutOfMemory(ctx);
         }
-        return JS_NewBigInt2(ctx, b, TRUE);
+        return JS_CompactBigInt(ctx, res);
     }
 }
 
@@ -11745,7 +11768,7 @@ int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
 static JSBigFloat *js_new_bf(JSContext *ctx)
 {
     JSBigFloat *p;
-    p = js_mallocz(ctx, sizeof(*p));
+    p = js_malloc(ctx, sizeof(*p));
     if (!p)
         return NULL;
     p->header.ref_count = 1;
@@ -11753,224 +11776,387 @@ static JSBigFloat *js_new_bf(JSContext *ctx)
     return p;
 }
 
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigFloat(JSContext *ctx, bf_t *a)
+static JSValue JS_NewBigFloat(JSContext *ctx)
 {
-    JSValue ret;
     JSBigFloat *p;
-
-    p = js_new_bf(ctx);
-    bf_memcpy(&p->num, a);
-    ret = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
-    return ret;
+    p = js_malloc(ctx, sizeof(*p));
+    if (!p)
+        return JS_EXCEPTION;
+    p->header.ref_count = 1;
+    bf_init(ctx->bf_ctx, &p->num);
+    return JS_MKPTR(JS_TAG_BIG_FLOAT, p);
 }
 
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigDecimal(JSContext *ctx, bfdec_t *a)
+static JSValue JS_NewBigDecimal(JSContext *ctx)
 {
-    JSValue ret;
     JSBigDecimal *p;
-
-    p = js_mallocz(ctx, sizeof(*p));
+    p = js_malloc(ctx, sizeof(*p));
     if (!p)
         return JS_EXCEPTION;
     p->header.ref_count = 1;
     bfdec_init(ctx->bf_ctx, &p->num);
-    bfdec_memcpy(&p->num, a);
-    ret = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
-    return ret;
+    return JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
 }
 
-/* WARNING: 'a' is freed */
-static JSValue JS_NewBigInt2(JSContext *ctx, bf_t *a, BOOL force_bigint)
+static JSValue JS_NewBigInt(JSContext *ctx)
 {
-    JSValue ret;
     JSBigFloat *p;
-    int32_t v;
-
-    if (!force_bigint && bf_get_int32(&v, a, 0) == 0) {
-        /* can fit in an int32 */
-        ret = JS_NewInt32(ctx, v);
-        bf_delete(a);
-    } else {
-        p = js_new_bf(ctx);
-        bf_memcpy(&p->num, a);
-        /* normalize the zero representation */
-        if (bf_is_zero(&p->num))
-            p->num.sign = 0;
-        ret = JS_MKPTR(JS_TAG_BIG_INT, p);
-    }
-    return ret;
+    p = js_malloc(ctx, sizeof(*p));
+    if (!p)
+        return JS_EXCEPTION;
+    p->header.ref_count = 1;
+    bf_init(ctx->bf_ctx, &p->num);
+    return JS_MKPTR(JS_TAG_BIG_INT, p);
 }
 
-static JSValue JS_NewBigInt(JSContext *ctx, bf_t *a)
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+                                 BOOL convert_to_safe_integer)
 {
-    return JS_NewBigInt2(ctx, a, !is_bigint_mode(ctx));
+    int64_t v;
+    bf_t *a;
+    
+    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
+        return val; /* fail safe */
+    a = JS_GetBigInt(val);
+    if (convert_to_safe_integer && bf_get_int64(&v, a, 0) == 0 &&
+        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
+        JS_FreeValue(ctx, val);
+        return JS_NewInt64(ctx, v);
+    } else if (a->expn == BF_EXP_ZERO && a->sign) {
+        JSBigFloat *p = JS_VALUE_GET_PTR(val);
+        assert(p->header.ref_count == 1);
+        a->sign = 0;
+    }
+    return val;
 }
 
-/* return < 0 if exception, 0 if overloading method, 1 if overloading
-   operator called */
-static __exception int js_call_binary_op_fallback(JSContext *ctx,
-                                                   JSValue *pret,
-                                                   JSValueConst op1,
-                                                   JSValueConst op2,
-                                                   OPCodeEnum op)
-{
-    JSAtom op_name;
-    JSValue method, ret, c1, c2;
-    BOOL bool_result, swap_op;
-    JSValueConst args[2];
+/* Convert the big int to a safe integer if in math mode. normalize
+   the zero representation. Could also be used to convert the bigint
+   to a short bigint value. The reference count of the value must be
+   1. Cannot fail */
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
+{
+    return JS_CompactBigInt1(ctx, val, is_math_mode(ctx));
+}
+
+/* must be kept in sync with JSOverloadableOperatorEnum */
+static const char *js_overloadable_operator_names[JS_OVOP_COUNT] = {
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "**",
+    "|",
+    "&",
+    "^",
+    "<<",
+    ">>",
+    ">>>",
+    "==",
+    "<",
+    "pos",
+    "neg",
+    "++",
+    "--",
+    "~",
+};
 
-    bool_result = FALSE;
-    swap_op = FALSE;
-    c1 = JS_UNDEFINED;
-    c2 = JS_UNDEFINED;
+static int get_ovop_from_opcode(OPCodeEnum op)
+{
     switch(op) {
     case OP_add:
-        op_name = JS_ATOM_Symbol_operatorAdd;
-        break;
+        return JS_OVOP_ADD;
     case OP_sub:
-        op_name = JS_ATOM_Symbol_operatorSub;
-        break;
+        return JS_OVOP_SUB;
     case OP_mul:
-        op_name = JS_ATOM_Symbol_operatorMul;
-        break;
+        return JS_OVOP_MUL;
     case OP_div:
-    case OP_math_div:
-        op_name = JS_ATOM_Symbol_operatorDiv;
-        break;
+        return JS_OVOP_DIV;
     case OP_mod:
-        op_name = JS_ATOM_Symbol_operatorMod;
-        break;
-    case OP_pow:
-    case OP_math_pow:
-        op_name = JS_ATOM_Symbol_operatorPow;
-        break;
     case OP_math_mod:
-        op_name = JS_ATOM_Symbol_operatorMathMod;
-        break;
-    case OP_shl:
-        op_name = JS_ATOM_Symbol_operatorShl;
-        break;
-    case OP_sar:
-        op_name = JS_ATOM_Symbol_operatorShr;
-        break;
-    case OP_and:
-        op_name = JS_ATOM_Symbol_operatorAnd;
-        break;
+        return JS_OVOP_MOD;
+    case OP_pow:
+        return JS_OVOP_POW;
     case OP_or:
-        op_name = JS_ATOM_Symbol_operatorOr;
-        break;
+        return JS_OVOP_OR;
+    case OP_and:
+        return JS_OVOP_AND;
     case OP_xor:
-        op_name = JS_ATOM_Symbol_operatorXor;
-        break;
+        return JS_OVOP_XOR;
+    case OP_shl:
+        return JS_OVOP_SHL;
+    case OP_sar:
+        return JS_OVOP_SAR;
+    case OP_shr:
+        return JS_OVOP_SHR;
+    case OP_eq:
+    case OP_neq:
+        return JS_OVOP_EQ;
     case OP_lt:
-        op_name = JS_ATOM_Symbol_operatorCmpLT;
-        bool_result = TRUE;
-        break;
     case OP_lte:
-        op_name = JS_ATOM_Symbol_operatorCmpLE;
-        bool_result = TRUE;
-        break;
     case OP_gt:
-        op_name = JS_ATOM_Symbol_operatorCmpLT;
-        bool_result = TRUE;
-        swap_op = TRUE;
-        break;
     case OP_gte:
-        op_name = JS_ATOM_Symbol_operatorCmpLE;
-        bool_result = TRUE;
-        swap_op = TRUE;
-        break;
-    case OP_eq:
-    case OP_neq:
-        op_name = JS_ATOM_Symbol_operatorCmpEQ;
-        bool_result = TRUE;
-        break;
+        return JS_OVOP_LESS;
+    case OP_plus:
+        return JS_OVOP_POS;
+    case OP_neg:
+        return JS_OVOP_NEG;
+    case OP_inc:
+        return JS_OVOP_INC;
+    case OP_dec:
+        return JS_OVOP_DEC;
     default:
-        goto fail;
+        abort();
+    }
+}
+
+/* return NULL if not present */
+static JSObject *find_binary_op(JSBinaryOperatorDef *def,
+                                uint32_t operator_index,
+                                JSOverloadableOperatorEnum op)
+{
+    JSBinaryOperatorDefEntry *ent;
+    int i;
+    for(i = 0; i < def->count; i++) {
+        ent = &def->tab[i];
+        if (ent->operator_index == operator_index)
+            return ent->ops[op];
     }
-    c1 = JS_GetProperty(ctx, op1, JS_ATOM_constructor);
-    if (JS_IsException(c1))
+    return NULL;
+}
+
+/* return -1 if exception, 0 if no operator overloading, 1 if
+   overloaded operator called */
+static __exception int js_call_binary_op_fallback(JSContext *ctx,
+                                                  JSValue *pret,
+                                                  JSValueConst op1,
+                                                  JSValueConst op2,
+                                                  OPCodeEnum op,
+                                                  BOOL is_numeric,
+                                                  int hint)
+{
+    JSValue opset1_obj, opset2_obj, method, ret, new_op1, new_op2;
+    JSOperatorSetData *opset1, *opset2;
+    JSOverloadableOperatorEnum ovop;
+    JSObject *p;
+    JSValueConst args[2];
+    
+    if (!ctx->allow_operator_overloading)
+        return 0;
+    
+    opset2_obj = JS_UNDEFINED;
+    opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
+    if (JS_IsException(opset1_obj))
         goto exception;
-    c2 = JS_GetProperty(ctx, op2, JS_ATOM_constructor);
-    if (JS_IsException(c2))
+    if (JS_IsUndefined(opset1_obj))
+        return 0;
+    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+    if (!opset1)
         goto exception;
-    if (JS_VALUE_GET_TAG(c1) != JS_TAG_OBJECT ||
-        JS_VALUE_GET_TAG(c2) != JS_TAG_OBJECT)
-        goto fail;
-    if (JS_VALUE_GET_OBJ(c1) == JS_VALUE_GET_OBJ(c2)) {
-        /* if same constructor, there is no ambiguity */
-        method = JS_GetProperty(ctx, c1, op_name);
+
+    opset2_obj = JS_GetProperty(ctx, op2, JS_ATOM_Symbol_operatorSet);
+    if (JS_IsException(opset2_obj))
+        goto exception;
+    if (JS_IsUndefined(opset2_obj)) {
+        JS_FreeValue(ctx, opset1_obj);
+        return 0;
+    }
+    opset2 = JS_GetOpaque2(ctx, opset2_obj, JS_CLASS_OPERATOR_SET);
+    if (!opset2)
+        goto exception;
+
+    if (opset1->is_primitive && opset2->is_primitive) {
+        JS_FreeValue(ctx, opset1_obj);
+        JS_FreeValue(ctx, opset2_obj);
+        return 0;
+    }
+
+    ovop = get_ovop_from_opcode(op);
+    
+    if (opset1->operator_counter == opset2->operator_counter) {
+        p = opset1->self_ops[ovop];
+    } else if (opset1->operator_counter > opset2->operator_counter) {
+        p = find_binary_op(&opset1->left, opset2->operator_counter, ovop);
     } else {
-        JSValue val;
-        int order1, order2;
+        p = find_binary_op(&opset2->right, opset1->operator_counter, ovop);
+    }
+    if (!p) {
+        JS_ThrowTypeError(ctx, "operator %s: no function defined",
+                          js_overloadable_operator_names[ovop]);
+        goto exception;
+    }
 
-        /* different constructors: we use a user-defined ordering */
-        val = JS_GetProperty(ctx, c1, JS_ATOM_Symbol_operatorOrder);
-        if (JS_IsException(val))
-            goto exception;
-        if (JS_IsUndefined(val))
-            goto undef_order;
-        if (JS_ToInt32Free(ctx, &order1, val))
-            goto exception;
-        val = JS_GetProperty(ctx, c2, JS_ATOM_Symbol_operatorOrder);
-        if (JS_IsException(val))
-            goto exception;
-        if (JS_IsUndefined(val)) {
-        undef_order:
-            JS_FreeValue(ctx, c1);
-            JS_FreeValue(ctx, c2);
-            *pret = JS_UNDEFINED;
-            return 0;
+    if (opset1->is_primitive) {
+        if (is_numeric) {
+            new_op1 = JS_ToNumeric(ctx, op1);
+        } else {
+            new_op1 = JS_ToPrimitive(ctx, op1, hint);
         }
-        if (JS_ToInt32Free(ctx, &order2, val))
+        if (JS_IsException(new_op1))
             goto exception;
-        /* ambiguous priority: error */
-        if (order1 == order2) {
-            JS_ThrowTypeError(ctx, "operator_order is identical in both constructors");
-            goto exception;
-        }
-        if (order1 > order2) {
-            val = c1;
+    } else {
+        new_op1 = JS_DupValue(ctx, op1);
+    }
+    
+    if (opset2->is_primitive) {
+        if (is_numeric) {
+            new_op2 = JS_ToNumeric(ctx, op2);
         } else {
-            val = c2;
+            new_op2 = JS_ToPrimitive(ctx, op2, hint);
         }
-        method = JS_GetProperty(ctx, val, op_name);
-    }
-    JS_FreeValue(ctx, c1);
-    JS_FreeValue(ctx, c2);
-    c1 = JS_UNDEFINED;
-    c2 = JS_UNDEFINED;
-    if (JS_IsException(method))
-        goto exception;
-    if (JS_IsUndefined(method) || JS_IsNull(method)) {
-        *pret = JS_UNDEFINED;
-        return 0;
+        if (JS_IsException(new_op2)) {
+            JS_FreeValue(ctx, new_op1);
+            goto exception;
+        }
+    } else {
+        new_op2 = JS_DupValue(ctx, op2);
     }
-    if (swap_op) {
-        args[0] = op2;
-        args[1] = op1;
+
+    /* XXX: could apply JS_ToPrimitive() if primitive type so that the
+       operator function does not get a value object */
+    
+    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+    if (ovop == JS_OVOP_LESS && (op == OP_lte || op == OP_gt)) {
+        args[0] = new_op2;
+        args[1] = new_op1;
     } else {
-        args[0] = op1;
-        args[1] = op2;
+        args[0] = new_op1;
+        args[1] = new_op2;
     }
     ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
+    JS_FreeValue(ctx, new_op1);
+    JS_FreeValue(ctx, new_op2);
     if (JS_IsException(ret))
         goto exception;
-    if (bool_result) {
+    if (ovop == JS_OVOP_EQ) {
         BOOL res = JS_ToBoolFree(ctx, ret);
         if (op == OP_neq)
             res ^= 1;
         ret = JS_NewBool(ctx, res);
+    } else if (ovop == JS_OVOP_LESS) {
+        if (JS_IsUndefined(ret)) {
+            ret = JS_FALSE;
+        } else {
+            BOOL res = JS_ToBoolFree(ctx, ret);
+            if (op == OP_lte || op == OP_gte)
+                res ^= 1;
+            ret = JS_NewBool(ctx, res);
+        }
     }
+    JS_FreeValue(ctx, opset1_obj);
+    JS_FreeValue(ctx, opset2_obj);
     *pret = ret;
     return 1;
- fail:
-    JS_ThrowTypeError(ctx, "invalid types for binary operator");
  exception:
-    JS_FreeValue(ctx, c1);
-    JS_FreeValue(ctx, c2);
+    JS_FreeValue(ctx, opset1_obj);
+    JS_FreeValue(ctx, opset2_obj);
+    *pret = JS_UNDEFINED;
+    return -1;
+}
+
+/* try to call the operation on the operatorSet field of 'obj'. Only
+   used for "/" and "**" on the BigInt prototype in math mode */
+static __exception int js_call_binary_op_simple(JSContext *ctx,
+                                                JSValue *pret,
+                                                JSValueConst obj,
+                                                JSValueConst op1,
+                                                JSValueConst op2,
+                                                OPCodeEnum op)
+{
+    JSValue opset1_obj, method, ret, new_op1, new_op2;
+    JSOperatorSetData *opset1;
+    JSOverloadableOperatorEnum ovop;
+    JSObject *p;
+    JSValueConst args[2];
+
+    opset1_obj = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
+    if (JS_IsException(opset1_obj))
+        goto exception;
+    if (JS_IsUndefined(opset1_obj))
+        return 0;
+    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+    if (!opset1)
+        goto exception;
+    ovop = get_ovop_from_opcode(op);
+
+    p = opset1->self_ops[ovop];
+    if (!p) {
+        JS_FreeValue(ctx, opset1_obj);
+        return 0;
+    }
+
+    new_op1 = JS_ToNumeric(ctx, op1);
+    if (JS_IsException(new_op1))
+        goto exception;
+    new_op2 = JS_ToNumeric(ctx, op2);
+    if (JS_IsException(new_op2)) {
+        JS_FreeValue(ctx, new_op1);
+        goto exception;
+    }
+
+    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+    args[0] = new_op1;
+    args[1] = new_op2;
+    ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
+    JS_FreeValue(ctx, new_op1);
+    JS_FreeValue(ctx, new_op2);
+    if (JS_IsException(ret))
+        goto exception;
+    JS_FreeValue(ctx, opset1_obj);
+    *pret = ret;
+    return 1;
+ exception:
+    JS_FreeValue(ctx, opset1_obj);
+    *pret = JS_UNDEFINED;
+    return -1;
+}
+
+/* return -1 if exception, 0 if no operator overloading, 1 if
+   overloaded operator called */
+static __exception int js_call_unary_op_fallback(JSContext *ctx,
+                                                 JSValue *pret,
+                                                 JSValueConst op1,
+                                                 OPCodeEnum op)
+{
+    JSValue opset1_obj, method, ret;
+    JSOperatorSetData *opset1;
+    JSOverloadableOperatorEnum ovop;
+    JSObject *p;
+
+    if (!ctx->allow_operator_overloading)
+        return 0;
+    
+    opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
+    if (JS_IsException(opset1_obj))
+        goto exception;
+    if (JS_IsUndefined(opset1_obj))
+        return 0;
+    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
+    if (!opset1)
+        goto exception;
+    if (opset1->is_primitive) {
+        JS_FreeValue(ctx, opset1_obj);
+        return 0;
+    }
+
+    ovop = get_ovop_from_opcode(op);
+
+    p = opset1->self_ops[ovop];
+    if (!p) {
+        JS_ThrowTypeError(ctx, "no overloaded operator %s",
+                          js_overloadable_operator_names[ovop]);
+        goto exception;
+    }
+    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+    ret = JS_CallFree(ctx, method, JS_UNDEFINED, 1, &op1);
+    if (JS_IsException(ret))
+        goto exception;
+    JS_FreeValue(ctx, opset1_obj);
+    *pret = ret;
+    return 1;
+ exception:
+    JS_FreeValue(ctx, opset1_obj);
     *pret = JS_UNDEFINED;
     return -1;
 }
@@ -11993,16 +12179,22 @@ static JSValue throw_bf_exception(JSContext *ctx, int status)
 static int js_unary_arith_bigint(JSContext *ctx,
                                  JSValue *pres, OPCodeEnum op, JSValue op1)
 {
-    bf_t a_s, r_s, *r = &r_s, *a;
+    bf_t a_s, *r, *a;
     int ret, v;
+    JSValue res;
     
-    if (op == OP_plus && !is_bigint_mode(ctx)) {
+    if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigint argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
+    res = JS_NewBigInt(ctx);
+    if (JS_IsException(res)) {
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+    r = JS_GetBigInt(res);
     a = JS_ToBigInt(ctx, &a_s, op1);
-    bf_init(ctx->bf_ctx, r);
     ret = 0;
     switch(op) {
     case OP_inc:
@@ -12027,28 +12219,35 @@ static int js_unary_arith_bigint(JSContext *ctx,
     JS_FreeBigInt(ctx, a, &a_s);
     JS_FreeValue(ctx, op1);
     if (unlikely(ret)) {
-        bf_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigInt(ctx, r);
+    res = JS_CompactBigInt(ctx, res);
+    *pres = res;
     return 0;
 }
 
 static int js_unary_arith_bigfloat(JSContext *ctx,
                                    JSValue *pres, OPCodeEnum op, JSValue op1)
 {
-    bf_t a_s, r_s, *r = &r_s, *a;
+    bf_t a_s, *r, *a;
     int ret, v;
+    JSValue res;
     
-    if (op == OP_plus && !is_bigint_mode(ctx)) {
+    if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
 
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res)) {
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+    r = JS_GetBigFloat(res);
     a = JS_ToBigFloat(ctx, &a_s, op1);
-    bf_init(ctx->bf_ctx, r);
     ret = 0;
     switch(op) {
     case OP_inc:
@@ -12070,28 +12269,34 @@ static int js_unary_arith_bigfloat(JSContext *ctx,
         bf_delete(a);
     JS_FreeValue(ctx, op1);
     if (unlikely(ret & BF_ST_MEM_ERROR)) {
-        bf_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigFloat(ctx, r);
+    *pres = res;
     return 0;
 }
 
 static int js_unary_arith_bigdecimal(JSContext *ctx,
                                      JSValue *pres, OPCodeEnum op, JSValue op1)
 {
-    bfdec_t r_s, *r = &r_s, *a;
+    bfdec_t *r, *a;
     int ret, v;
-
-    if (op == OP_plus && !is_bigint_mode(ctx)) {
+    JSValue res;
+    
+    if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
 
+    res = JS_NewBigDecimal(ctx);
+    if (JS_IsException(res)) {
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
+    r = JS_GetBigDecimal(res);
     a = JS_ToBigDecimal(ctx, op1);
-    bfdec_init(ctx->bf_ctx, r);
     ret = 0;
     switch(op) {
     case OP_inc:
@@ -12111,11 +12316,11 @@ static int js_unary_arith_bigdecimal(JSContext *ctx,
     }
     JS_FreeValue(ctx, op1);
     if (unlikely(ret)) {
-        bfdec_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigDecimal(ctx, r);
+    *pres = res;
     return 0;
 }
 
@@ -12123,112 +12328,93 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
                                                      JSValue *sp,
                                                      OPCodeEnum op)
 {
-    JSValue op1, val, method;
-    BOOL is_legacy;
-    JSAtom op_name;
-    int v;
+    JSValue op1, val;
+    int v, ret;
     uint32_t tag;
 
     op1 = sp[-1];
     /* fast path for float64 */
     if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(op1)))
         goto handle_float64;
-    if (JS_IsObject(op1) && ctx->bignum_ext) {
-        switch(op) {
-        case OP_plus:
-            op_name = JS_ATOM_Symbol_operatorPlus;
-            break;
-        case OP_neg:
-            op_name = JS_ATOM_Symbol_operatorNeg;
-            break;
-        case OP_inc:
-            op_name = JS_ATOM_Symbol_operatorInc;
-            break;
-        case OP_dec:
-            op_name = JS_ATOM_Symbol_operatorDec;
-            break;
-        default:
-            abort();
-        }
-        method = JS_GetProperty(ctx, op1, op_name);
-        if (JS_IsException(method))
-            return -1;
-        if (JS_IsUndefined(method) || JS_IsNull(method))
-            goto to_number;
-        val = JS_CallFree(ctx, method, op1, 0, NULL);
-        if (JS_IsException(val))
+    if (JS_IsObject(op1)) {
+        ret = js_call_unary_op_fallback(ctx, &val, op1, op);
+        if (ret < 0)
             return -1;
-        JS_FreeValue(ctx, op1);
-        sp[-1] = val;
-    } else {
-    to_number:
-        op1 = JS_ToNumericFree(ctx, op1);
-        if (JS_IsException(op1))
-            goto exception;
-        is_legacy = is_bigint_mode(ctx) ^ 1;
-        tag = JS_VALUE_GET_TAG(op1);
-        switch(tag) {
-        case JS_TAG_INT:
-            {
-                int64_t v64;
-                v64 = JS_VALUE_GET_INT(op1);
-                switch(op) {
-                case OP_inc:
-                case OP_dec:
-                    v = 2 * (op - OP_dec) - 1;
-                    v64 += v;
-                    break;
-                case OP_plus:
-                    break;
-                case OP_neg:
-                    if (v64 == 0 && is_legacy) {
-                        sp[-1] = __JS_NewFloat64(ctx, -0.0);
-                        return 0;
-                    } else {
-                        v64 = -v64;
-                    }
-                    break;
-                default:
-                    abort();
+        if (ret) {
+            JS_FreeValue(ctx, op1);
+            sp[-1] = val;
+            return 0;
+        }
+    }
+
+    op1 = JS_ToNumericFree(ctx, op1);
+    if (JS_IsException(op1))
+        goto exception;
+    tag = JS_VALUE_GET_TAG(op1);
+    switch(tag) {
+    case JS_TAG_INT:
+        {
+            int64_t v64;
+            v64 = JS_VALUE_GET_INT(op1);
+            switch(op) {
+            case OP_inc:
+            case OP_dec:
+                v = 2 * (op - OP_dec) - 1;
+                v64 += v;
+                break;
+            case OP_plus:
+                break;
+            case OP_neg:
+                if (v64 == 0) {
+                    sp[-1] = __JS_NewFloat64(ctx, -0.0);
+                    return 0;
+                } else {
+                    v64 = -v64;
                 }
-                sp[-1] = JS_NewInt64(ctx, v64);
+                break;
+            default:
+                abort();
             }
-            break;
-        case JS_TAG_BIG_INT:
-            if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
-                goto exception;
-            break;
-        case JS_TAG_BIG_FLOAT:
-            if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
-                goto exception;
-            break;
-        case JS_TAG_BIG_DECIMAL:
-            if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
-                goto exception;
-            break;
-        default:
-        handle_float64:
-            {
-                double d;
-                d = JS_VALUE_GET_FLOAT64(op1);
-                switch(op) {
-                case OP_inc:
-                case OP_dec:
-                    v = 2 * (op - OP_dec) - 1;
-                    d += v;
-                    break;
-                case OP_plus:
-                    break;
-                case OP_neg:
-                    d = -d;
-                    break;
-                default:
-                    abort();
-                }
-                sp[-1] = __JS_NewFloat64(ctx, d);
+            sp[-1] = JS_NewInt64(ctx, v64);
+        }
+        break;
+    case JS_TAG_BIG_INT:
+    handle_bigint:
+        if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
+            goto exception;
+        break;
+    case JS_TAG_BIG_FLOAT:
+        if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
+            goto exception;
+        break;
+    case JS_TAG_BIG_DECIMAL:
+        if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
+            goto exception;
+        break;
+    default:
+    handle_float64:
+        {
+            double d;
+            if (is_math_mode(ctx))
+                goto handle_bigint;
+            d = JS_VALUE_GET_FLOAT64(op1);
+            switch(op) {
+            case OP_inc:
+            case OP_dec:
+                v = 2 * (op - OP_dec) - 1;
+                d += v;
+                break;
+            case OP_plus:
+                break;
+            case OP_neg:
+                d = -d;
+                break;
+            default:
+                abort();
             }
-            break;
+            sp[-1] = __JS_NewFloat64(ctx, d);
         }
+        break;
     }
     return 0;
  exception:
@@ -12255,39 +12441,33 @@ static __exception int js_post_inc_slow(JSContext *ctx,
 
 static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 {
-    JSValue op1, method, val;
-
+    JSValue op1, val;
+    int ret;
+    
     op1 = sp[-1];
     if (JS_IsObject(op1)) {
-        if (!ctx->bignum_ext)
-            goto to_number;
-        method = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorNot);
-        if (JS_IsException(method))
-            return -1;
-        if (JS_IsUndefined(method) || JS_IsNull(method))
-            goto to_number;
-        val = JS_CallFree(ctx, method, op1, 0, NULL);
-        if (JS_IsException(val))
+        ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
+        if (ret < 0)
             return -1;
-        JS_FreeValue(ctx, op1);
-        sp[-1] = val;
-    } else {
-        if (JS_IsString(op1)) {
-        to_number:
-            op1 = JS_ToNumberHintFree(ctx, op1, TON_FLAG_INTEGER);
-            if (JS_IsException(op1))
-                goto exception;
-        }
-        if (is_bigint_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
-            if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
-                goto exception;
-        } else {
-            int32_t v1;
-            if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
-                goto exception;
-            sp[-1] = JS_NewInt32(ctx, ~v1);
+        if (ret) {
+            JS_FreeValue(ctx, op1);
+            sp[-1] = val;
+            return 0;
         }
     }
+
+    op1 = JS_ToNumericFree(ctx, op1);
+    if (JS_IsException(op1))
+        goto exception;
+    if (is_math_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
+        if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
+            goto exception;
+    } else {
+        int32_t v1;
+        if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
+            goto exception;
+        sp[-1] = JS_NewInt32(ctx, ~v1);
+    }
     return 0;
  exception:
     sp[-1] = JS_UNDEFINED;
@@ -12297,12 +12477,19 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
                                     JSValue *pres, JSValue op1, JSValue op2)
 {
-    bf_t a_s, b_s, r_s, *r, *a, *b;
-    int ret, rnd_mode;
+    bf_t a_s, b_s, *r, *a, *b;
+    int ret;
+    JSValue res;
     
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res)) {
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        return -1;
+    }
+    r = JS_GetBigFloat(res);
     a = JS_ToBigFloat(ctx, &a_s, op1);
     b = JS_ToBigFloat(ctx, &b_s, op2);
-    r = &r_s;
     bf_init(ctx->bf_ctx, r);
     switch(op) {
     case OP_add:
@@ -12314,29 +12501,21 @@ static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
     case OP_mul:
         ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
         break;
-    case OP_math_div:
     case OP_div:
         ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
         break;
     case OP_math_mod:
         /* Euclidian remainder */
-        rnd_mode = BF_DIVREM_EUCLIDIAN;
-        goto do_mod;
+        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+                     BF_DIVREM_EUCLIDIAN);
+        break;
     case OP_mod:
-        rnd_mode = BF_RNDZ;
-    do_mod:
-        {
-            bf_t q_s, *q = &q_s;
-            bf_init(ctx->bf_ctx, q);
-            ret = bf_divrem(q, r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                            rnd_mode);
-            bf_delete(q);
-        }
+        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+                     BF_RNDZ);
         break;
     case OP_pow:
-    case OP_math_pow:
         ret = bf_pow(r, a, b, ctx->fp_env.prec,
-                     ctx->fp_env.flags | BF_POW_JS_QUICKS);
+                     ctx->fp_env.flags | BF_POW_JS_QUIRKS);
         break;
     default:
         abort();
@@ -12348,21 +12527,24 @@ static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
     if (unlikely(ret & BF_ST_MEM_ERROR)) {
-        bf_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigFloat(ctx, r);
+    *pres = res;
     return 0;
 }
 
 static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
                                   JSValue *pres, JSValue op1, JSValue op2)
 {
-    bf_t a_s, b_s, r_s, *r, *a, *b;
-    int ret, rnd_mode;
+    bf_t a_s, b_s, *r, *a, *b;
+    int ret;
     JSValue res;
     
+    res = JS_NewBigInt(ctx);
+    if (JS_IsException(res))
+        goto fail;
     a = JS_ToBigInt(ctx, &a_s, op1);
     if (!a)
         goto fail;
@@ -12371,8 +12553,7 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
         JS_FreeBigInt(ctx, a, &a_s);
         goto fail;
     }
-    r = &r_s;
-    bf_init(ctx->bf_ctx, r);
+    r = JS_GetBigInt(res);
     ret = 0;
     switch(op) {
     case OP_add:
@@ -12384,73 +12565,75 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
     case OP_mul:
         ret = bf_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
         break;
-    case OP_math_div:
-        goto op_fallback;
     case OP_div:
-        if (!is_bigint_mode(ctx)) {
+        if (!is_math_mode(ctx)) {
             bf_t rem_s, *rem = &rem_s;
             bf_init(ctx->bf_ctx, rem);
             ret = bf_divrem(r, rem, a, b, BF_PREC_INF, BF_RNDZ,
                             BF_RNDZ);
             bf_delete(rem);
         } else {
-            bf_div(r, a, b, 53, bf_set_exp_bits(11) |
-                   BF_RNDN | BF_FLAG_SUBNORMAL);
-            goto float64_result;
+            goto math_mode_div_pow;
         }
         break;
     case OP_math_mod:
         /* Euclidian remainder */
-        rnd_mode = BF_DIVREM_EUCLIDIAN;
-        goto do_int_mod;
+        ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
+                     BF_DIVREM_EUCLIDIAN) & BF_ST_INVALID_OP;
+        break;
     case OP_mod:
-        rnd_mode = BF_RNDZ;
-    do_int_mod:
-        {
-            bf_t q_s, *q = &q_s;
-            bf_init(ctx->bf_ctx, q);
-            ret = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ,
-                            rnd_mode) & BF_ST_INVALID_OP;
-            bf_delete(q);
-        }
+        ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
+                     BF_RNDZ) & BF_ST_INVALID_OP;
         break;
     case OP_pow:
-    case OP_math_pow:
         if (b->sign) {
-            if (!is_bigint_mode(ctx)) {
+            if (!is_math_mode(ctx)) {
                 ret = BF_ST_INVALID_OP;
-            } else if (op == OP_math_pow) {
-            op_fallback:
-                bf_delete(r);
+            } else {
+            math_mode_div_pow:
+                JS_FreeValue(ctx, res);
+                ret = js_call_binary_op_simple(ctx, &res, ctx->class_proto[JS_CLASS_BIG_INT], op1, op2, op);
+                if (ret != 0) {
+                    JS_FreeBigInt(ctx, a, &a_s);
+                    JS_FreeBigInt(ctx, b, &b_s);
+                    JS_FreeValue(ctx, op1);
+                    JS_FreeValue(ctx, op2);
+                    if (ret < 0) {
+                        return -1;
+                    } else {
+                        *pres = res;
+                        return 0;
+                    }
+                }
+                /* if no BigInt power operator defined, return a
+                   bigfloat */
+                res = JS_NewBigFloat(ctx);
+                if (JS_IsException(res)) {
+                    JS_FreeBigInt(ctx, a, &a_s);
+                    JS_FreeBigInt(ctx, b, &b_s);
+                    goto fail;
+                }
+                r = JS_GetBigFloat(res);
+                if (op == OP_div) {
+                    ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags) & BF_ST_MEM_ERROR;
+                } else {
+                    ret = bf_pow(r, a, b, ctx->fp_env.prec,
+                                 ctx->fp_env.flags | BF_POW_JS_QUIRKS) & BF_ST_MEM_ERROR;
+                }
                 JS_FreeBigInt(ctx, a, &a_s);
                 JS_FreeBigInt(ctx, b, &b_s);
-                ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
                 JS_FreeValue(ctx, op1);
                 JS_FreeValue(ctx, op2);
-                if (ret < 0) {
-                    return -1;
-                } else if (ret == 0) {
-                    JS_ThrowTypeError(ctx, "operator must be defined for exact division or power");
+                if (unlikely(ret)) {
+                    JS_FreeValue(ctx, res);
+                    throw_bf_exception(ctx, ret);
                     return -1;
                 }
                 *pres = res;
                 return 0;
-            } else {
-                double dr;
-                bf_pow(r, a, b, 53, bf_set_exp_bits(11) |
-                       BF_RNDN | BF_FLAG_SUBNORMAL);
-            float64_result:
-                bf_get_float64(r, &dr, BF_RNDN);
-                bf_delete(r);
-                JS_FreeBigInt(ctx, a, &a_s);
-                JS_FreeBigInt(ctx, b, &b_s);
-                JS_FreeValue(ctx, op1);
-                JS_FreeValue(ctx, op2);
-                *pres = __JS_NewFloat64(ctx, dr);
-                return 0;
             }
         } else {
-            ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUICKS);
+            ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUIRKS);
         }
         break;
 
@@ -12494,13 +12677,14 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
     if (unlikely(ret)) {
-        bf_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigInt(ctx, r);
+    *pres = JS_CompactBigInt(ctx, res);
     return 0;
  fail:
+    JS_FreeValue(ctx, res);
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
     return -1;
@@ -12536,18 +12720,21 @@ static int js_bfdec_pow(bfdec_t *r, const bfdec_t *a, const bfdec_t *b)
 static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
                                       JSValue *pres, JSValue op1, JSValue op2)
 {
-    bfdec_t r_s, *r, *a, *b;
-    int ret, rnd_mode;
- 
-    /* big decimal result */
+    bfdec_t *r, *a, *b;
+    int ret;
+    JSValue res;
+
+    res = JS_NewBigDecimal(ctx);
+    if (JS_IsException(res))
+        goto fail;
+    r = JS_GetBigDecimal(res);
+    
     a = JS_ToBigDecimal(ctx, op1);
     if (!a)
         goto fail;
     b = JS_ToBigDecimal(ctx, op2);
     if (!b)
         goto fail;
-    r = &r_s;
-    bfdec_init(ctx->bf_ctx, r);
     switch(op) {
     case OP_add:
         ret = bfdec_add(r, a, b, BF_PREC_INF, BF_RNDZ);
@@ -12558,26 +12745,17 @@ static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
     case OP_mul:
         ret = bfdec_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
         break;
-    case OP_math_div:
     case OP_div:
         ret = bfdec_div(r, a, b, BF_PREC_INF, BF_RNDZ);
         break;
     case OP_math_mod:
         /* Euclidian remainder */
-        rnd_mode = BF_DIVREM_EUCLIDIAN;
-        goto do_mod_dec;
+        ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_DIVREM_EUCLIDIAN);
+        break;
     case OP_mod:
-        rnd_mode = BF_RNDZ;
-    do_mod_dec:
-        {
-            bfdec_t q_s, *q = &q_s;
-            bfdec_init(ctx->bf_ctx, q);
-            ret = bfdec_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, rnd_mode);
-            bfdec_delete(q);
-        }
+        ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_RNDZ);
         break;
     case OP_pow:
-    case OP_math_pow:
         ret = js_bfdec_pow(r, a, b);
         break;
     default:
@@ -12586,13 +12764,14 @@ static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
     if (unlikely(ret)) {
-        bfdec_delete(r);
+        JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    *pres = JS_NewBigDecimal(ctx, r);
+    *pres = res;
     return 0;
  fail:
+    JS_FreeValue(ctx, res);
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
     return -1;
@@ -12602,7 +12781,6 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                                                       OPCodeEnum op)
 {
     JSValue op1, op2, res;
-    BOOL is_legacy;
     uint32_t tag1, tag2;
     int ret;
     double d1, d2;
@@ -12619,12 +12797,11 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     }
 
     /* try to call an overloaded operator */
-    if (((tag1 == JS_TAG_OBJECT &&
-          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-         (tag2 == JS_TAG_OBJECT &&
-          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
-        ctx->bignum_ext) {
-        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+    if ((tag1 == JS_TAG_OBJECT &&
+         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+        (tag2 == JS_TAG_OBJECT &&
+         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -12655,23 +12832,23 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         int64_t v;
         v1 = JS_VALUE_GET_INT(op1);
         v2 = JS_VALUE_GET_INT(op2);
-        is_legacy = is_bigint_mode(ctx) ^ 1;
         switch(op) {
         case OP_sub:
             v = (int64_t)v1 - (int64_t)v2;
             break;
         case OP_mul:
             v = (int64_t)v1 * (int64_t)v2;
-            if (is_legacy && v == 0 && (v1 | v2) < 0) {
+            if (is_math_mode(ctx) &&
+                (v < -MAX_SAFE_INTEGER || v > MAX_SAFE_INTEGER))
+                goto handle_bigint;
+            if (v == 0 && (v1 | v2) < 0) {
                 sp[-2] = __JS_NewFloat64(ctx, -0.0);
                 return 0;
             }
             break;
-        case OP_math_div:
-            if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-                goto exception;
-            return 0;
         case OP_div:
+            if (is_math_mode(ctx))
+                goto handle_bigint;
             sp[-2] = __JS_NewFloat64(ctx, (double)v1 / (double)v2);
             return 0;
         case OP_math_mod:
@@ -12688,26 +12865,19 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             }
             break;
         case OP_mod:
-            if (is_legacy && (v1 < 0 || v2 <= 0)) {
+            if (v1 < 0 || v2 <= 0) {
                 sp[-2] = JS_NewFloat64(ctx, fmod(v1, v2));
                 return 0;
             } else {
-                if (unlikely(v2 == 0)) {
-                    throw_bf_exception(ctx, BF_ST_DIVIDE_ZERO);
-                    goto exception;
-                }
                 v = (int64_t)v1 % (int64_t)v2;
             }
             break;
         case OP_pow:
-        case OP_math_pow:
-            if (is_legacy) {
+            if (!is_math_mode(ctx)) {
                 sp[-2] = JS_NewFloat64(ctx, js_pow(v1, v2));
                 return 0;
             } else {
-                if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-                    goto exception;
-                return 0;
+                goto handle_bigint;
             }
             break;
         default:
@@ -12720,6 +12890,10 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
         if (ctx->rt->bigfloat_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
+    } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+    handle_bigint:
+        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+            goto exception;
     } else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
         double dr;
         /* float64 result */
@@ -12730,6 +12904,8 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         if (JS_ToFloat64Free(ctx, &d2, op2))
             goto exception;
     handle_float64:
+        if (is_math_mode(ctx) && is_safe_integer(d1) && is_safe_integer(d2))
+            goto handle_bigint;
         switch(op) {
         case OP_sub:
             dr = d1 - d2;
@@ -12738,7 +12914,6 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             dr = d1 * d2;
             break;
         case OP_div:
-        case OP_math_div:
             dr = d1 / d2;
             break;
         case OP_mod:
@@ -12752,16 +12927,12 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                 dr += d2;
             break;
         case OP_pow:
-        case OP_math_pow:
             dr = js_pow(d1, d2);
             break;
         default:
             abort();
         }
         sp[-2] = __JS_NewFloat64(ctx, dr);
-    } else {
-        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-            goto exception;
     }
     return 0;
  exception:
@@ -12792,12 +12963,14 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
 
     if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
         /* try to call an overloaded operator */
-        if (((tag1 == JS_TAG_OBJECT &&
-              (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-             (tag2 == JS_TAG_OBJECT &&
-              (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
-            ctx->bignum_ext) {
-            ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add);
+        if ((tag1 == JS_TAG_OBJECT &&
+             (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED &&
+              tag2 != JS_TAG_STRING)) ||
+            (tag2 == JS_TAG_OBJECT &&
+             (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED &&
+              tag1 != JS_TAG_STRING))) {
+            ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add,
+                                             FALSE, HINT_NONE);
             if (ret != 0) {
                 JS_FreeValue(ctx, op1);
                 JS_FreeValue(ctx, op2);
@@ -12886,6 +13059,7 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     JSValue op1, op2, res;
     int ret;
     uint32_t tag1, tag2;
+    uint32_t v1, v2, r;
 
     op1 = sp[-2];
     op2 = sp[-1];
@@ -12893,12 +13067,11 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
     /* try to call an overloaded operator */
-    if (((tag1 == JS_TAG_OBJECT &&
-          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-         (tag2 == JS_TAG_OBJECT &&
-          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
-        ctx->bignum_ext) {
-        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op);
+    if ((tag1 == JS_TAG_OBJECT &&
+         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+        (tag2 == JS_TAG_OBJECT &&
+         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -12911,63 +13084,60 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
         }
     }
 
-    op1 = JS_ToNumberHintFree(ctx, op1, TON_FLAG_INTEGER);
+    op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1)) {
         JS_FreeValue(ctx, op2);
         goto exception;
     }
-    op2 = JS_ToNumberHintFree(ctx, op2, TON_FLAG_INTEGER);
+    op2 = JS_ToNumericFree(ctx, op2);
     if (JS_IsException(op2)) {
         JS_FreeValue(ctx, op1);
         goto exception;
     }
 
-    if (!is_bigint_mode(ctx)) {
-        uint32_t v1, v2, r;
+    if (is_math_mode(ctx))
+        goto bigint_op;
 
-        tag1 = JS_VALUE_GET_TAG(op1);
-        tag2 = JS_VALUE_GET_TAG(op2);
-        if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
-            if (tag1 != tag2) {
-                JS_FreeValue(ctx, op1);
-                JS_FreeValue(ctx, op2);
-                JS_ThrowTypeError(ctx, "both operands must be bigint");
-                goto exception;
-            } else {
-                goto bigint_op;
-            }
+    tag1 = JS_VALUE_GET_TAG(op1);
+    tag2 = JS_VALUE_GET_TAG(op2);
+    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+        if (tag1 != tag2) {
+            JS_FreeValue(ctx, op1);
+            JS_FreeValue(ctx, op2);
+            JS_ThrowTypeError(ctx, "both operands must be bigint");
+            goto exception;
         } else {
-            if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
-                JS_FreeValue(ctx, op2);
-                goto exception;
-            }
-            if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v2, op2)))
+        bigint_op:
+            if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
                 goto exception;
-            switch(op) {
-            case OP_shl:
-                r = v1 << (v2 & 0x1f);
-                break;
-            case OP_sar:
-                r = (int)v1 >> (v2 & 0x1f);
-                break;
-            case OP_and:
-                r = v1 & v2;
-                break;
-            case OP_or:
-                r = v1 | v2;
-                break;
-            case OP_xor:
-                r = v1 ^ v2;
-                break;
-            default:
-                abort();
-            }
-            sp[-2] = JS_NewInt32(ctx, r);
         }
     } else {
-    bigint_op:
-        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+        if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
+            JS_FreeValue(ctx, op2);
+            goto exception;
+        }
+        if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v2, op2)))
             goto exception;
+        switch(op) {
+        case OP_shl:
+            r = v1 << (v2 & 0x1f);
+            break;
+        case OP_sar:
+            r = (int)v1 >> (v2 & 0x1f);
+            break;
+        case OP_and:
+            r = v1 & v2;
+            break;
+        case OP_or:
+            r = v1 | v2;
+            break;
+        case OP_xor:
+            r = v1 ^ v2;
+            break;
+        default:
+            abort();
+        }
+        sp[-2] = JS_NewInt32(ctx, r);
     }
     return 0;
  exception:
@@ -13081,12 +13251,12 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
     /* try to call an overloaded operator */
-    if (((tag1 == JS_TAG_OBJECT &&
-          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-         (tag2 == JS_TAG_OBJECT &&
-          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) &&
-        ctx->bignum_ext) {
-        res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op);
+    if ((tag1 == JS_TAG_OBJECT &&
+         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
+        (tag2 == JS_TAG_OBJECT &&
+         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+        res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op,
+                                         FALSE, HINT_NUMBER);
         if (res != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -13165,7 +13335,7 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     } else {
         if (((tag1 == JS_TAG_BIG_INT && tag2 == JS_TAG_STRING) ||
              (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_STRING)) &&
-            !is_bigint_mode(ctx)) {
+            !is_math_mode(ctx)) {
             if (tag1 == JS_TAG_STRING) {
                 op1 = JS_StringToBigInt(ctx, op1);
                 if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
@@ -13271,10 +13441,11 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 goto exception;
         }
     } else if (tag1 == tag2) {
-        if (tag1 == JS_TAG_OBJECT && ctx->bignum_ext) {
+        if (tag1 == JS_TAG_OBJECT) {
             /* try the fallback operator */
             res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
-                                              is_neq ? OP_neq : OP_eq);
+                                             is_neq ? OP_neq : OP_eq,
+                                             FALSE, HINT_NONE);
             if (res != 0) {
                 JS_FreeValue(ctx, op1);
                 JS_FreeValue(ctx, op2);
@@ -13294,7 +13465,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                (tag2 == JS_TAG_STRING && tag_is_number(tag1))) {
 
         if ((tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
-            !is_bigint_mode(ctx)) {
+            !is_math_mode(ctx)) {
             if (tag1 == JS_TAG_STRING) {
                 op1 = JS_StringToBigInt(ctx, op1);
                 if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
@@ -13336,7 +13507,8 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
 
         /* try the fallback operator */
         res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
-                                          is_neq ? OP_neq : OP_eq);
+                                         is_neq ? OP_neq : OP_eq,
+                                         FALSE, HINT_NONE);
         if (res != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -13391,7 +13563,7 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
         goto exception;
     }
     /* XXX: could forbid >>> in bignum mode */
-    if (!is_bigint_mode(ctx) &&
+    if (!is_math_mode(ctx) &&
         (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
          JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT)) {
         JS_ThrowTypeError(ctx, "bigint operands are forbidden for >>>");
@@ -13433,34 +13605,38 @@ static JSValue js_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
 
 static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
 {
-    bf_t a_s, *a, r_s, *r = &r_s;
-    JSValue op1, op2;
-    slimb_t e;
+    bf_t a_s, *a, *r;
+    JSValue op1, op2, res;
+    int64_t e;
     int ret;
 
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res))
+        return -1;
+    r = JS_GetBigFloat(res);
     op1 = sp[-2];
     op2 = sp[-1];
     a = JS_ToBigFloat(ctx, &a_s, op1);
     if (!a)
         return -1;
-#if LIMB_BITS == 32
-    ret = JS_ToInt32(ctx, &e, op2);
-#else
-    ret = JS_ToInt64(ctx, &e, op2);
-#endif
+    if (JS_IsBigInt(ctx, op2)) {
+        ret = JS_ToBigInt64(ctx, &e, op2);
+    } else {
+        ret = JS_ToInt64(ctx, &e, op2);
+    }
     if (ret) {
         if (a == &a_s)
             bf_delete(a);
+        JS_FreeValue(ctx, res);
         return -1;
     }
 
-    bf_init(ctx->bf_ctx, r);
     bf_mul_pow_radix(r, a, 10, e, ctx->fp_env.prec, ctx->fp_env.flags);
     if (a == &a_s)
         bf_delete(a);
     JS_FreeValue(ctx, op1);
     JS_FreeValue(ctx, op2);
-    sp[-2] = JS_NewBigFloat(ctx, r);
+    sp[-2] = res;
     return 0;
 }
 
@@ -13882,22 +14058,9 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             d2 = JS_VALUE_GET_INT(op2);
             goto number_test;
         } else if (tag2 == JS_TAG_FLOAT64) {
-#ifdef CONFIG_BIGNUM
-            if (is_bigint_mode(ctx)) {
-                res = FALSE;
-            } else
-#endif
-            {
-                d2 = JS_VALUE_GET_FLOAT64(op2);
-                goto number_test;
-            }
-        } else
-#ifdef CONFIG_BIGNUM
-        if (tag2 == JS_TAG_BIG_INT && is_bigint_mode(ctx)) {
-            goto bigint_test;
-        } else
-#endif
-        {
+            d2 = JS_VALUE_GET_FLOAT64(op2);
+            goto number_test;
+        } else {
             res = FALSE;
         }
         break;
@@ -13905,11 +14068,7 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
         d1 = JS_VALUE_GET_FLOAT64(op1);
         if (tag2 == JS_TAG_FLOAT64) {
             d2 = JS_VALUE_GET_FLOAT64(op2);
-        } else if (tag2 == JS_TAG_INT
-#ifdef CONFIG_BIGNUM
-                   && !is_bigint_mode(ctx)
-#endif
-                   ) {
+        } else if (tag2 == JS_TAG_INT) {
             d2 = JS_VALUE_GET_INT(op2);
         } else {
             res = FALSE;
@@ -13936,15 +14095,10 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
     case JS_TAG_BIG_INT:
         {
             bf_t a_s, *a, b_s, *b;
-            if (tag1 == tag2) {
-                /* OK */
-            } else if (tag2 == JS_TAG_INT && is_bigint_mode(ctx)) {
-                /* OK */
-            } else {
+            if (tag1 != tag2) {
                 res = FALSE;
                 break;
             }
-        bigint_test:
             a = JS_ToBigFloat(ctx, &a_s, op1);
             b = JS_ToBigFloat(ctx, &b_s, op2);
             res = bf_cmp_eq(a, b);
@@ -14100,30 +14254,20 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
     tag = JS_VALUE_GET_NORM_TAG(op1);
     switch(tag) {
 #ifdef CONFIG_BIGNUM
-    case JS_TAG_INT:
-        if (is_bigint_mode(ctx))
-            atom = JS_ATOM_bigint;
-        else
-            atom = JS_ATOM_number;
-        break;
     case JS_TAG_BIG_INT:
         atom = JS_ATOM_bigint;
         break;
-    case JS_TAG_FLOAT64:
-        atom = JS_ATOM_number;
-        break;
     case JS_TAG_BIG_FLOAT:
         atom = JS_ATOM_bigfloat;
         break;
     case JS_TAG_BIG_DECIMAL:
         atom = JS_ATOM_bigdecimal;
         break;
-#else
+#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         atom = JS_ATOM_number;
         break;
-#endif
     case JS_TAG_UNDEFINED:
         atom = JS_ATOM_undefined;
         break;
@@ -15288,7 +15432,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     /* we only propagate the bignum mode as some runtime functions
        test it */
     if (prev_sf)
-        sf->js_mode = prev_sf->js_mode & JS_MODE_BIGINT;
+        sf->js_mode = prev_sf->js_mode & JS_MODE_MATH;
     else
         sf->js_mode = 0;
 #else
@@ -17315,11 +17459,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     v1 = JS_VALUE_GET_INT(op1);
                     v2 = JS_VALUE_GET_INT(op2);
                     r = (int64_t)v1 * v2;
-#ifdef CONFIG_BIGNUM
-                    if (unlikely((int)r != r) || (r == 0 && !is_bigint_mode(ctx)))
-                        goto binary_arith_slow;
-#else
                     if (unlikely((int)r != r)) {
+#ifdef CONFIG_BIGNUM
+                        if (unlikely(sf->js_mode & JS_MODE_MATH) &&
+                            (r < -MAX_SAFE_INTEGER || r > MAX_SAFE_INTEGER))
+                            goto binary_arith_slow;
+#endif
                         d = (double)r;
                         goto mul_fp_res;
                     }
@@ -17328,14 +17473,15 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                         d = -0.0;
                         goto mul_fp_res;
                     }
-#endif
                     sp[-2] = JS_NewInt32(ctx, r);
                     sp--;
                 } else if (JS_VALUE_IS_BOTH_FLOAT(op1, op2)) {
+#ifdef CONFIG_BIGNUM
+                    if (unlikely(sf->js_mode & JS_MODE_MATH))
+                        goto binary_arith_slow;
+#endif
                     d = JS_VALUE_GET_FLOAT64(op1) * JS_VALUE_GET_FLOAT64(op2);
-#ifndef CONFIG_BIGNUM
                 mul_fp_res:
-#endif
                     sp[-2] = __JS_NewFloat64(ctx, d);
                     sp--;
                 } else {
@@ -17343,11 +17489,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 }
             }
             BREAK;
-#ifdef CONFIG_BIGNUM
-        CASE(OP_math_div):
-        CASE(OP_div):
-            goto binary_arith_slow;
-#else
         CASE(OP_div):
             {
                 JSValue op1, op2;
@@ -17355,6 +17496,8 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 op2 = sp[-1];
                 if (likely(JS_VALUE_IS_BOTH_INT(op1, op2))) {
                     int v1, v2;
+                    if (unlikely(sf->js_mode & JS_MODE_MATH))
+                        goto binary_arith_slow;
                     v1 = JS_VALUE_GET_INT(op1);
                     v2 = JS_VALUE_GET_INT(op2);
                     sp[-2] = JS_NewFloat64(ctx, (double)v1 / (double)v2);
@@ -17364,7 +17507,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 }
             }
             BREAK;
-#endif
         CASE(OP_mod):
 #ifdef CONFIG_BIGNUM
         CASE(OP_math_mod):
@@ -17390,9 +17532,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             }
             BREAK;
         CASE(OP_pow):
-#ifdef CONFIG_BIGNUM
-        CASE(OP_math_pow):
-#endif
         binary_arith_slow:
             if (js_binary_arith_slow(ctx, sp, opcode))
                 goto exception;
@@ -17422,11 +17561,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 tag = JS_VALUE_GET_TAG(op1);
                 if (tag == JS_TAG_INT) {
                     val = JS_VALUE_GET_INT(op1);
-#ifdef CONFIG_BIGNUM
-                    if (unlikely(val == INT32_MIN) ||
-                        (val == 0 && !is_bigint_mode(ctx)))
-                        goto slow_neg;
-#else
                     /* Note: -0 cannot be expressed as integer */
                     if (unlikely(val == 0)) {
                         d = -0.0;
@@ -17436,18 +17570,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                         d = -(double)val;
                         goto neg_fp_res;
                     }
-#endif
                     sp[-1] = JS_NewInt32(ctx, -val);
                 } else if (JS_TAG_IS_FLOAT64(tag)) {
                     d = -JS_VALUE_GET_FLOAT64(op1);
-#ifndef CONFIG_BIGNUM
                 neg_fp_res:
-#endif
                     sp[-1] = __JS_NewFloat64(ctx, d);
                 } else {
-#ifdef CONFIG_BIGNUM
-                slow_neg:
-#endif
                     if (js_unary_arith_slow(ctx, sp, opcode))
                         goto exception;
                 }
@@ -17560,7 +17688,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 #ifdef CONFIG_BIGNUM
                     {
                         int64_t r;
-                        if (is_bigint_mode(ctx)) {
+                        if (unlikely(sf->js_mode & JS_MODE_MATH)) {
                             if (v2 > 0x1f)
                                 goto shl_slow;
                             r = (int64_t)v1 << v2;
@@ -17616,7 +17744,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     v2 = JS_VALUE_GET_INT(op2);
 #ifdef CONFIG_BIGNUM
                     if (unlikely(v2 > 0x1f)) {
-                        if (is_bigint_mode(ctx))
+                        if (unlikely(sf->js_mode & JS_MODE_MATH))
                             goto sar_slow;
                         else
                             v2 &= 0x1f;
@@ -20182,7 +20310,7 @@ static __exception int next_token(JSParseState *s)
                     ATOD_ACCEPT_UNDERSCORES;
 #ifdef CONFIG_BIGNUM
                 flags |= ATOD_ACCEPT_SUFFIX;
-                if (s->cur_func->js_mode & JS_MODE_BIGINT) {
+                if (s->cur_func->js_mode & JS_MODE_MATH) {
                     flags |= ATOD_MODE_BIGINT;
                     if (s->cur_func->js_mode & JS_MODE_MATH)
                         flags |= ATOD_TYPE_BIG_FLOAT;
@@ -23312,7 +23440,6 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             } else
 #ifdef CONFIG_BIGNUM
             if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
-                bf_t r_s, *r = &r_s;
                 slimb_t e;
                 int ret;
 
@@ -23326,9 +23453,9 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     emit_op(s, OP_push_i32);
                     emit_u32(s, e);
                 } else {
-                    bf_init(s->ctx->bf_ctx, r);
-                    bf_set_si(r, e);
-                    val = JS_NewBigInt(s->ctx, r);
+                    val = JS_NewBigInt64_1(s->ctx, e);
+                    if (JS_IsException(val))
+                        return -1;
                     ret = emit_push_const(s, val, 0);
                     JS_FreeValue(s->ctx, val);
                     if (ret < 0)
@@ -24105,10 +24232,7 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
                 return -1;
             if (js_parse_unary(s, 1))
                 return -1;
-            if (s->cur_func->js_mode & JS_MODE_MATH)
-                emit_op(s, OP_math_pow);
-            else
-                emit_op(s, OP_pow);
+            emit_op(s, OP_pow);
         }
 #else
         if (s->token.val == TOK_POW) {
@@ -24151,12 +24275,7 @@ static __exception int js_parse_expr_binary(JSParseState *s, int level,
                 opcode = OP_mul;
                 break;
             case '/':
-#ifdef CONFIG_BIGNUM
-                if (s->cur_func->js_mode & JS_MODE_MATH)
-                    opcode = OP_math_div;
-                else
-#endif
-                    opcode = OP_div;
+                opcode = OP_div;
                 break;
             case '%':
 #ifdef CONFIG_BIGNUM
@@ -24549,12 +24668,8 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
             op = assign_opcodes[op - TOK_MUL_ASSIGN];
 #ifdef CONFIG_BIGNUM
             if (s->cur_func->js_mode & JS_MODE_MATH) {
-                if (op == OP_div)
-                    op = OP_math_div;
-                else if (op == OP_mod)
+                if (op == OP_mod)
                     op = OP_math_mod;
-                else if (op == OP_pow)
-                    op = OP_math_pow;
             }
 #endif
             emit_op(s, op);
@@ -30149,20 +30264,6 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
         len = opcode_info[op].size;
         pos_next = pos + len;
         switch(op) {
-        case OP_close_var_object:
-            {
-                if (s->var_object_idx >= 0) {
-                    /* close the var object and create a new one */
-                    add_pc2line_info(s, bc_out.size, line_num);
-                    dbuf_putc(&bc_out, OP_close_loc);
-                    dbuf_put_u16(&bc_out, s->var_object_idx);
-                    dbuf_putc(&bc_out, OP_special_object);
-                    dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
-                    put_short_code(&bc_out, OP_put_loc, s->var_object_idx);
-                }
-            }
-            break;
-
         case OP_line_num:
             /* line number info (for debug). We put it in a separate
                compressed table to reduce memory usage and get better
@@ -31508,11 +31609,8 @@ static __exception int js_parse_directives(JSParseState *s)
         }
 #endif
 #ifdef CONFIG_BIGNUM
-        else if (s->ctx->bignum_ext && !strcmp(str, "use bigint")) {
-            s->cur_func->js_mode |= JS_MODE_BIGINT;
-        }
         else if (s->ctx->bignum_ext && !strcmp(str, "use math")) {
-            s->cur_func->js_mode |= JS_MODE_BIGINT | JS_MODE_MATH;
+            s->cur_func->js_mode |= JS_MODE_MATH;
         }
 #endif
     }
@@ -31804,13 +31902,6 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                 }
                 if (js_parse_destructing_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
                     goto fail;
-                /* Close var object: necessary if direct eval call
-                   occurred in the assignment expression or if any
-                   variable was captured and a later direct eval call
-                   may instantiate it in the var object.
-                   The next pass will generate the capture if required.
-                 */
-                emit_op(s, OP_close_var_object);
             } else if (s->token.val == TOK_IDENT) {
                 if (s->token.u.ident.is_reserved) {
                     js_parse_error_reserved_identifier(s);
@@ -31889,8 +31980,6 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                         set_object_name(s, name);
                         emit_op(s, OP_put_arg);
                         emit_u16(s, idx);
-                        /* Close var object: see above comment. */
-                        emit_op(s, OP_close_var_object);
                         emit_label(s, label);
                     }
                 } else if (!has_opt_arg) {
@@ -34399,30 +34488,20 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val)
     case JS_TAG_EXCEPTION:
         return JS_DupValue(ctx, val);
 #ifdef CONFIG_BIGNUM
-    case JS_TAG_INT:
-        if (is_bigint_mode(ctx))
-            obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
-        else
-            obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
-        goto set_value;
     case JS_TAG_BIG_INT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
         goto set_value;
-    case JS_TAG_FLOAT64:
-        obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
-        goto set_value;
     case JS_TAG_BIG_FLOAT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_FLOAT);
         goto set_value;
     case JS_TAG_BIG_DECIMAL:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_DECIMAL);
         goto set_value;
-#else
+#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
         goto set_value;
-#endif
     case JS_TAG_STRING:
         /* XXX: should call the string constructor */
         {
@@ -34995,10 +35074,13 @@ static JSValue js_object_preventExtensions(JSContext *ctx, JSValueConst this_val
     ret = JS_PreventExtensions(ctx, obj);
     if (ret < 0)
         return JS_EXCEPTION;
-    if (reflect)
+    if (reflect) {
         return JS_NewBool(ctx, ret);
-    else
+    } else {
+        if (!ret)
+            return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
         return JS_DupValue(ctx, obj);
+    }
 }
 
 static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValueConst this_val,
@@ -35166,7 +35248,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
             goto exception;
     }
     js_free_prop_enum(ctx, props, len);
-    return JS_TRUE;
+    return JS_DupValue(ctx, obj);
 
  exception:
     js_free_prop_enum(ctx, props, len);
@@ -37690,17 +37772,14 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
                                      int argc, JSValueConst *argv)
 {
     JSValue val, obj;
-#ifdef CONFIG_BIGNUM
     if (argc == 0) {
-        if (is_bigint_mode(ctx))
-            val = __JS_NewFloat64(ctx, 0);
-        else
-            val = JS_NewInt32(ctx, 0);
+        val = JS_NewInt32(ctx, 0);
     } else {
         val = JS_ToNumeric(ctx, argv[0]);
         if (JS_IsException(val))
             return val;
         switch(JS_VALUE_GET_TAG(val)) {
+#ifdef CONFIG_BIGNUM
         case JS_TAG_BIG_INT:
         case JS_TAG_BIG_FLOAT:
             {
@@ -37711,25 +37790,19 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
                 val = __JS_NewFloat64(ctx, d);
             }
             break;
-        case JS_TAG_INT:
-            if (is_bigint_mode(ctx)) {
-                /* always return a number in bignum mode */
-                val = __JS_NewFloat64(ctx, JS_VALUE_GET_INT(val));
-            }
+        case JS_TAG_BIG_DECIMAL:
+            val = JS_ToStringFree(ctx, val);
+            if (JS_IsException(val))
+                return val;
+            val = JS_ToNumberFree(ctx, val);
+            if (JS_IsException(val))
+                return val;
             break;
+#endif
         default:
             break;
         }
     }
-#else
-    if (argc == 0) {
-        val = JS_NewInt32(ctx, 0);
-    } else {
-        val = JS_ToNumber(ctx, argv[0]);
-        if (JS_IsException(val))
-            return val;
-    }
-#endif
     if (!JS_IsUndefined(new_target)) {
         obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
         if (!JS_IsException(obj))
@@ -37760,7 +37833,6 @@ static JSValue js_number___toLength(JSContext *ctx, JSValueConst this_val,
 static JSValue js_number_isNaN(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
 {
-    /* XXX: should just check for float and big_float */
     if (!JS_IsNumber(argv[0]))
         return JS_FALSE;
     return js_global_isNaN(ctx, this_val, argc, argv);
@@ -37793,8 +37865,7 @@ static JSValue js_number_isSafeInteger(JSContext *ctx, JSValueConst this_val,
         return JS_FALSE;
     if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
         return JS_EXCEPTION;
-    return JS_NewBool(ctx, isfinite(d) && floor(d) == d &&
-                      fabs(d) <= (double)MAX_SAFE_INTEGER);
+    return JS_NewBool(ctx, is_safe_integer(d));
 }
 
 static const JSCFunctionListEntry js_number_funcs[] = {
@@ -37838,6 +37909,18 @@ static JSValue js_number_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisNumberValue(ctx, this_val);
 }
 
+static int js_get_radix(JSContext *ctx, JSValueConst val)
+{
+    int radix;
+    if (JS_ToInt32Sat(ctx, &radix, val))
+        return -1;
+    if (radix < 2 || radix > 36) {
+        JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+        return -1;
+    }
+    return radix;
+}
+
 static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv, int magic)
 {
@@ -37851,12 +37934,9 @@ static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
     if (magic || JS_IsUndefined(argv[0])) {
         base = 10;
     } else {
-        if (JS_ToInt32Sat(ctx, &base, argv[0]))
-            goto fail;
-        if (base < 2 || base > 36) {
-            JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+        base = js_get_radix(ctx, argv[0]);
+        if (base < 0)
             goto fail;
-        }
     }
     if (JS_ToFloat64Free(ctx, &d, val))
         return JS_EXCEPTION;
@@ -37972,10 +38052,6 @@ static JSValue js_parseInt(JSContext *ctx, JSValueConst this_val,
         p = str;
         p += skip_spaces(p);
         flags = ATOD_INT_ONLY | ATOD_ACCEPT_PREFIX_AFTER_SIGN;
-#ifdef CONFIG_BIGNUM
-        if (is_bigint_mode(ctx))
-            flags |= ATOD_MODE_BIGINT;
-#endif
         ret = js_atof(ctx, p, NULL, radix, flags);
     }
     JS_FreeCString(ctx, str);
@@ -39738,348 +39814,6 @@ static double js_fmax(double a, double b)
     }
 }
 
-#ifdef CONFIG_BIGNUM
-
-enum {
-    MATH_OP_ABS,
-    MATH_OP_FLOOR,
-    MATH_OP_CEIL,
-    MATH_OP_ROUND,
-    MATH_OP_TRUNC,
-    MATH_OP_SQRT,
-    MATH_OP_FPROUND,
-    MATH_OP_ACOS,
-    MATH_OP_ASIN,
-    MATH_OP_ATAN,
-    MATH_OP_ATAN2,
-    MATH_OP_COS,
-    MATH_OP_EXP,
-    MATH_OP_LOG,
-    MATH_OP_POW,
-    MATH_OP_SIN,
-    MATH_OP_TAN,
-    MATH_OP_FMOD,
-    MATH_OP_REM,
-    MATH_OP_SIGN,
-
-    MATH_OP_ADD,
-    MATH_OP_SUB,
-    MATH_OP_MUL,
-    MATH_OP_DIV,
-};
-
-static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
-                           int argc, JSValueConst *argv, int magic)
-{
-    bf_t a_s, *a, r_s, *r = &r_s;
-    JSFloatEnv *fe;
-    int rnd_mode;
-    JSValue op1;
-
-    op1 = JS_ToNumber(ctx, argv[0]);
-    if (JS_IsException(op1))
-        return op1;
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    fe = &ctx->fp_env;
-    if (argc > 1) {
-        fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
-        if (!fe) {
-            if (a == &a_s)
-                bf_delete(a);
-            JS_FreeValue(ctx, op1);
-            return JS_EXCEPTION;
-        }
-    }
-
-    bf_init(ctx->bf_ctx, r);
-    switch (magic) {
-    case MATH_OP_ABS:
-        bf_set(r, a);
-        r->sign = 0;
-        break;
-    case MATH_OP_FLOOR:
-        rnd_mode = BF_RNDD;
-        goto rint;
-    case MATH_OP_CEIL:
-        rnd_mode = BF_RNDU;
-        goto rint;
-    case MATH_OP_ROUND:
-        rnd_mode = BF_RNDNU;
-        goto rint;
-    case MATH_OP_TRUNC:
-        rnd_mode = BF_RNDZ;
-    rint:
-        bf_set(r, a);
-        fe->status |= bf_rint(r, rnd_mode);
-        break;
-    case MATH_OP_SQRT:
-        fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_FPROUND:
-        bf_set(r, a);
-        fe->status |= bf_round(r, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ACOS:
-        fe->status |= bf_acos(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ASIN:
-        fe->status |= bf_asin(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ATAN:
-        fe->status |= bf_atan(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_COS:
-        fe->status |= bf_cos(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_EXP:
-        fe->status |= bf_exp(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_LOG:
-        fe->status |= bf_log(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SIN:
-        fe->status |= bf_sin(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_TAN:
-        fe->status |= bf_tan(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SIGN:
-        if (bf_is_nan(a) || bf_is_zero(a)) {
-            bf_set(r, a);
-        } else {
-            bf_set_si(r, 1 - 2 * a->sign);
-        }
-        break;
-    default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    JS_FreeValue(ctx, op1);
-    return JS_NewBigFloat(ctx, r);
-}
-
-static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
-                            int argc, JSValueConst *argv, int magic)
-{
-    bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
-    JSFloatEnv *fe;
-    JSValue op1, op2;
-
-    op1 = JS_ToNumber(ctx, argv[0]);
-    if (JS_IsException(op1))
-        return op1;
-    op2 = JS_ToNumber(ctx, argv[1]);
-    if (JS_IsException(op2)) {
-        JS_FreeValue(ctx, op1);
-        return op2;
-    }
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    b = JS_ToBigFloat(ctx, &b_s, op2);
-    fe = &ctx->fp_env;
-    if (argc > 2) {
-        fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
-        if (!fe) {
-            if (a == &a_s)
-                bf_delete(a);
-            if (b == &b_s)
-                bf_delete(b);
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            return JS_EXCEPTION;
-        }
-    }
-
-    bf_init(ctx->bf_ctx, r);
-    switch (magic) {
-    case MATH_OP_ATAN2:
-        fe->status |= bf_atan2(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_POW:
-        fe->status |= bf_pow(r, a, b, fe->prec, fe->flags | BF_POW_JS_QUICKS);
-        break;
-    case MATH_OP_FMOD:
-        fe->status |= bf_fmod(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_REM:
-        fe->status |= bf_remainder(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ADD:
-        fe->status |= bf_add(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SUB:
-        fe->status |= bf_sub(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_MUL:
-        fe->status |= bf_mul(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_DIV:
-        fe->status |= bf_div(r, a, b, fe->prec, fe->flags);
-        break;
-    default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    if (b == &b_s)
-        bf_delete(b);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return JS_NewBigFloat(ctx, r);
-}
-
-static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
-                               int argc, JSValueConst *argv, int magic)
-{
-    BOOL is_max = magic;
-    JSValue val, ret;
-    int i;
-    uint32_t tag;
-
-    if (unlikely(argc == 0)) {
-        return __JS_NewFloat64(ctx, is_max ? -1.0 / 0.0 : 1.0 / 0.0);
-    }
-
-    tag = JS_VALUE_GET_TAG(argv[0]);
-    if (tag == JS_TAG_INT) {
-        int a1, r1 = JS_VALUE_GET_INT(argv[0]);
-        for(i = 1; i < argc; i++) {
-            tag = JS_VALUE_GET_TAG(argv[i]);
-            if (tag != JS_TAG_INT) {
-                ret = JS_NewInt32(ctx, r1);
-                goto generic_case;
-            }
-            a1 = JS_VALUE_GET_INT(argv[i]);
-            if (is_max)
-                r1 = max_int(r1, a1);
-            else
-                r1 = min_int(r1, a1);
-        }
-        ret = JS_NewInt32(ctx, r1);
-    } else {
-        ret = JS_ToNumber(ctx, argv[0]);
-        if (JS_IsException(ret))
-            return ret;
-        i = 1;
-    generic_case:
-        for(; i < argc; i++) {
-            val = JS_ToNumber(ctx, argv[i]);
-            if (JS_IsException(val)) {
-                JS_FreeValue(ctx, ret);
-                return val;
-            }
-            if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(ret)) &&
-                JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(val))) {
-                double r, a;
-                r = JS_VALUE_GET_FLOAT64(ret);
-                a = JS_VALUE_GET_FLOAT64(val);
-                if (!isnan(r)) {
-                    if (isnan(a)) {
-                        r = a;
-                    } else {
-                        if (is_max)
-                            r = js_fmax(r, a);
-                        else
-                            r = js_fmin(r, a);
-                    }
-                    ret = __JS_NewFloat64(ctx, r);
-                }
-            } else {
-                bf_t a_s, *a, r_s, *r;
-                int res;
-
-                r = JS_ToBigFloat(ctx, &r_s, ret);
-                if (!bf_is_nan(r)) {
-                    a = JS_ToBigFloat(ctx, &a_s, val);
-                    res = bf_cmp_full(a, r);
-                    if (is_max)
-                        res = -res;
-                    if (bf_is_nan(a) || res < 0) {
-                        JS_FreeValue(ctx, ret);
-                        ret = JS_DupValue(ctx, val);
-                    }
-                    if (a == &a_s)
-                        bf_delete(a);
-                }
-                if (r == &r_s)
-                    bf_delete(r);
-                JS_FreeValue(ctx, val);
-            }
-        }
-    }
-    return ret;
-}
-
-static JSValue js_math_abs(JSContext *ctx, JSValueConst this_val,
-                           int argc, JSValueConst *argv)
-{
-    JSValue val;
-    uint32_t tag;
-
-    val = JS_ToNumeric(ctx, argv[0]);
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-        if (JS_VALUE_GET_INT(val) < 0)
-            val = JS_NewInt64(ctx, -(int64_t)JS_VALUE_GET_INT(val));
-        break;
-    case JS_TAG_FLOAT64:
-        val = __JS_NewFloat64(ctx, fabs(JS_VALUE_GET_FLOAT64(val)));
-        break;
-    case JS_TAG_BIG_FLOAT:
-    case JS_TAG_BIG_INT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_t r_s, *r = &r_s;
-            bf_init(ctx->bf_ctx, r);
-            bf_set(r, &p->num);
-            r->sign = 0;
-            JS_FreeValue(ctx, val);
-            if (tag == JS_TAG_BIG_FLOAT)
-                val = JS_NewBigFloat(ctx, r);
-            else
-                val = JS_NewBigInt2(ctx, r, TRUE);
-        }
-        break;
-    default:
-        break;
-    }
-    return val;
-}
-
-#if 0
-/* XXX: should give exact rounding */
-/* XXX: correct NaN/Infinity handling */
-static JSValue js_math_hypot(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv)
-{
-    bf_t a_s, *a, r_s, *r = &r_s, r2_s, *r2 = &r2_s;
-    JSValue val;
-    int i;
-    BOOL is_float;
-
-    bf_init(ctx->bf_ctx, r);
-    bf_set_si(r, 0);
-    for(i = 0; i < argc; i++) {
-        val = JS_ToNumber(ctx, argv[i]);
-        if (JS_IsException(val)) {
-            bf_delete(r);
-            return val;
-        }
-        a = JS_ToBigFloat(ctx, &is_float, &a_s, val);
-        bf_add(r, r, a, ctx->fp_env.prec, ctx->fp_env.flags);
-        if (a == &a_s)
-            bf_delete(a);
-    }
-    bf_init(ctx->bf_ctx, r2);
-    bf_sqrt(r2, r, ctx->fp_env.prec, ctx->fp_env.flags);
-    bf_delete(r);
-    return JS_NewBigFloat(ctx, r2);
-}
-#endif
-
-#else
-
 static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv, int magic)
 {
@@ -40133,8 +39867,6 @@ static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
     }
 }
 
-#endif /* !CONFIG_BIGNUM */
-
 static double js_math_sign(double a)
 {
     if (isnan(a) || a == 0.0)
@@ -40267,11 +39999,7 @@ static JSValue js_math_random(JSContext *ctx, JSValueConst this_val,
 static const JSCFunctionListEntry js_math_funcs[] = {
     JS_CFUNC_MAGIC_DEF("min", 2, js_math_min_max, 0 ),
     JS_CFUNC_MAGIC_DEF("max", 2, js_math_min_max, 1 ),
-#ifdef CONFIG_BIGNUM
-    JS_CFUNC_DEF("abs", 1, js_math_abs ),
-#else
     JS_CFUNC_SPECIAL_DEF("abs", 1, f_f, fabs ),
-#endif
     JS_CFUNC_SPECIAL_DEF("floor", 1, f_f, floor ),
     JS_CFUNC_SPECIAL_DEF("ceil", 1, f_f, ceil ),
     JS_CFUNC_SPECIAL_DEF("round", 1, f_f, js_math_round ),
@@ -41959,46 +41687,12 @@ static JSValue json_parse_value(JSParseState *s)
         }
         is_neg = 1;
     number:
-#ifdef CONFIG_BIGNUM
-        val = JS_DupValue(ctx, s->token.u.num.val);
-        if (is_neg) {
-            switch(JS_VALUE_GET_NORM_TAG(val)) {
-            case JS_TAG_BIG_INT:
-            case JS_TAG_BIG_FLOAT:
-                {
-                    JSBigFloat *p;
-                    p = JS_VALUE_GET_PTR(val);
-                    bf_neg(&p->num);
-                }
-                break;
-            case JS_TAG_FLOAT64:
-                {
-                    double d;
-                    d = JS_VALUE_GET_FLOAT64(val);
-                    val = __JS_NewFloat64(ctx, -d);
-                }
-                break;
-            default:
-            case JS_TAG_INT:
-                {
-                    int v;
-                    v = JS_VALUE_GET_INT(val);
-                    if (v == 0 && !is_bigint_mode(s->ctx))
-                        val = __JS_NewFloat64(ctx, -0.0);
-                    else
-                        val = JS_NewInt64(ctx, -(int64_t)v);
-                }
-                break;
-            }
-        }
-#else
         val = s->token.u.num.val;
         if (is_neg) {
             double d;
             JS_ToFloat64(ctx, &d, val);  /* no exception possible */
             val = JS_NewFloat64(ctx, -d);
         }
-#endif
         if (next_token(s))
             goto fail;
         break;
@@ -42168,10 +41862,6 @@ static JSValue JS_ToQuotedStringFree(JSContext *ctx, JSValue val) {
     return r;
 }
 
-#ifdef CONFIG_BIGNUM
-static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v);
-#endif
-
 static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
                              JSValueConst holder, JSValue val, JSValueConst key)
 {
@@ -46764,7 +46454,8 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
     double d;
     int p, i, c, sgn;
     JSString *sp;
-
+    BOOL is_local;
+    
     rv = JS_NAN;
 
     s = JS_ToString(ctx, argv[0]);
@@ -46780,11 +46471,15 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
         if (string_get_signed_field(sp, &p, &fields[0]))
             goto done;
 
+        is_local = TRUE;
         for (i = 1; i < 6; i++) {
             if (string_get_field(sp, &p, &fields[i]))
                 break;
         }
-        if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
+        if (i <= 3) {
+            /* no time: UTC by default */
+            is_local = FALSE;
+        } else if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
             /* parse milliseconds as a fractional part, round to nearest */
             /* XXX: the spec does not indicate which rounding should be used */
             int mul = 1000, ms = 0;
@@ -46802,14 +46497,20 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
 
         /* parse the time zone offset if present: [+-]HH:mm */
         tz = 0;
-        if (p < sp->len && ((sgn = string_get(sp, p)) == '+' || sgn == '-')) {
-            if (string_get_field(sp, &p, &hh))
-                goto done;
-            if (string_get_field(sp, &p, &mm))
-                goto done;
-            tz = hh * 60 + mm;
-            if (sgn == '-')
-                tz = -tz;
+        if (p < sp->len) {
+            sgn = string_get(sp, p);
+            if (sgn == '+' || sgn == '-') {
+                if (string_get_field(sp, &p, &hh))
+                    goto done;
+                if (string_get_field(sp, &p, &mm))
+                    goto done;
+                tz = hh * 60 + mm;
+                if (sgn == '-')
+                    tz = -tz;
+                is_local = FALSE;
+            } else if (sgn == 'Z') {
+                is_local = FALSE;
+            }
         }
     } else {
         /* toString or toUTCString format */
@@ -46844,6 +46545,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
         // XXX: parse optional milliseconds?
 
         /* parse the time zone offset if present: [+-]HHmm */
+        is_local = FALSE;
         tz = 0;
         for (tz = 0; p < sp->len; p++) {
             sgn = string_get(sp, p);
@@ -46860,7 +46562,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
             }
         }
     }
-    d = set_date_fields(fields, 0) - tz * 60000;
+    d = set_date_fields(fields, is_local) - tz * 60000;
     rv = __JS_NewFloat64(ctx, d);
 
 done:
@@ -47080,61 +46782,364 @@ void JS_AddIntrinsicEval(JSContext *ctx)
 
 #ifdef CONFIG_BIGNUM
 
+/* Operators */
+
+static void js_operator_set_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
+    int i, j;
+    JSBinaryOperatorDefEntry *ent;
+    
+    if (opset) {
+        for(i = 0; i < JS_OVOP_COUNT; i++) {
+            if (opset->self_ops[i])
+                JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]));
+        }
+        for(j = 0; j < opset->left.count; j++) {
+            ent = &opset->left.tab[j];
+            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+                if (ent->ops[i])
+                    JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
+            }
+        }
+        js_free_rt(rt, opset->left.tab);
+        for(j = 0; j < opset->right.count; j++) {
+            ent = &opset->right.tab[j];
+            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+                if (ent->ops[i])
+                    JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
+            }
+        }
+        js_free_rt(rt, opset->right.tab);
+        js_free_rt(rt, opset);
+    }
+}
+
+static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
+                                 JS_MarkFunc *mark_func)
+{
+    JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
+    int i, j;
+    JSBinaryOperatorDefEntry *ent;
+    
+    if (opset) {
+        for(i = 0; i < JS_OVOP_COUNT; i++) {
+            if (opset->self_ops[i])
+                JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]),
+                             mark_func);
+        }
+        for(j = 0; j < opset->left.count; j++) {
+            ent = &opset->left.tab[j];
+            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+                if (ent->ops[i])
+                    JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
+                                 mark_func);
+            }
+        }
+        for(j = 0; j < opset->right.count; j++) {
+            ent = &opset->right.tab[j];
+            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+                if (ent->ops[i])
+                    JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
+                                 mark_func);
+            }
+        }
+    }
+}
+
+
+/* create an OperatorSet object */
+static JSValue js_operators_create_internal(JSContext *ctx,
+                                            int argc, JSValueConst *argv,
+                                            BOOL is_primitive)
+{
+    JSValue opset_obj, prop, obj;
+    JSOperatorSetData *opset, *opset1;
+    JSBinaryOperatorDef *def;
+    JSValueConst arg;
+    int i, j;
+    JSBinaryOperatorDefEntry *new_tab;
+    JSBinaryOperatorDefEntry *ent;
+    uint32_t op_count;
+
+    if (ctx->rt->operator_count == UINT32_MAX) {
+        return JS_ThrowTypeError(ctx, "too many operators");
+    }
+    opset_obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_OPERATOR_SET);
+    if (JS_IsException(opset_obj))
+        goto fail;
+    opset = js_mallocz(ctx, sizeof(*opset));
+    if (!opset)
+        goto fail;
+    JS_SetOpaque(opset_obj, opset);
+    if (argc >= 1) {
+        arg = argv[0];
+        /* self operators */
+        for(i = 0; i < JS_OVOP_COUNT; i++) {
+            prop = JS_GetPropertyStr(ctx, arg, js_overloadable_operator_names[i]);
+            if (JS_IsException(prop))
+                goto fail;
+            if (!JS_IsUndefined(prop)) {
+                if (check_function(ctx, prop)) {
+                    JS_FreeValue(ctx, prop);
+                    goto fail;
+                }
+                opset->self_ops[i] = JS_VALUE_GET_OBJ(prop);
+            }
+        }
+    }
+    /* left & right operators */
+    for(j = 1; j < argc; j++) {
+        arg = argv[j];
+        prop = JS_GetPropertyStr(ctx, arg, "left");
+        if (JS_IsException(prop))
+            goto fail;
+        def = &opset->right;
+        if (JS_IsUndefined(prop)) {
+            prop = JS_GetPropertyStr(ctx, arg, "right");
+            if (JS_IsException(prop))
+                goto fail;
+            if (JS_IsUndefined(prop)) {
+                JS_ThrowTypeError(ctx, "left or right property must be present");
+                goto fail;
+            }
+            def = &opset->left;
+        }
+        /* get the operator set */
+        obj = JS_GetProperty(ctx, prop, JS_ATOM_prototype);
+        JS_FreeValue(ctx, prop);
+        if (JS_IsException(obj))
+            goto fail;
+        prop = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
+        JS_FreeValue(ctx, obj);
+        if (JS_IsException(prop))
+            goto fail;
+        opset1 = JS_GetOpaque2(ctx, prop, JS_CLASS_OPERATOR_SET);
+        if (!opset1) {
+            JS_FreeValue(ctx, prop);
+            goto fail;
+        }
+        op_count = opset1->operator_counter;
+        JS_FreeValue(ctx, prop);
+        
+        /* we assume there are few entries */
+        new_tab = js_realloc(ctx, def->tab,
+                             (def->count + 1) * sizeof(def->tab[0]));
+        if (!new_tab)
+            goto fail;
+        def->tab = new_tab;
+        def->count++;
+        ent = def->tab + def->count - 1;
+        memset(ent, 0, sizeof(def->tab[0]));
+        ent->operator_index = op_count;
+        
+        for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
+            prop = JS_GetPropertyStr(ctx, arg,
+                                     js_overloadable_operator_names[i]);
+            if (JS_IsException(prop))
+                goto fail;
+            if (!JS_IsUndefined(prop)) {
+                if (check_function(ctx, prop)) {
+                    JS_FreeValue(ctx, prop);
+                    goto fail;
+                }
+                ent->ops[i] = JS_VALUE_GET_OBJ(prop);
+            }
+        }
+    }
+    opset->is_primitive = is_primitive;
+    opset->operator_counter = ctx->rt->operator_count++;
+    return opset_obj;
+ fail:
+    JS_FreeValue(ctx, opset_obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_operators_create(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv)
+{
+    return js_operators_create_internal(ctx, argc, argv, FALSE);
+}
+
+static JSValue js_operators_updateBigIntOperators(JSContext *ctx, JSValueConst this_val,
+                                                  int argc, JSValueConst *argv)
+{
+    JSValue opset_obj, prop;
+    JSOperatorSetData *opset;
+    const JSOverloadableOperatorEnum ops[2] = { JS_OVOP_DIV, JS_OVOP_POW };
+    JSOverloadableOperatorEnum op;
+    int i;
+    
+    opset_obj = JS_GetProperty(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
+                               JS_ATOM_Symbol_operatorSet);
+    if (JS_IsException(opset_obj))
+        goto fail;
+    opset = JS_GetOpaque2(ctx, opset_obj, JS_CLASS_OPERATOR_SET);
+    if (!opset)
+        goto fail;
+    for(i = 0; i < countof(ops); i++) {
+        op = ops[i];
+        prop = JS_GetPropertyStr(ctx, argv[0],
+                                 js_overloadable_operator_names[op]);
+        if (JS_IsException(prop))
+            goto fail;
+        if (!JS_IsUndefined(prop)) {
+            if (!JS_IsNull(prop) && check_function(ctx, prop)) {
+                JS_FreeValue(ctx, prop);
+                goto fail;
+            }
+            if (opset->self_ops[op])
+                JS_FreeValue(ctx, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[op]));
+            if (JS_IsNull(prop)) {
+                opset->self_ops[op] = NULL;
+            } else {
+                opset->self_ops[op] = JS_VALUE_GET_PTR(prop);
+            }
+        }
+    }
+    JS_FreeValue(ctx, opset_obj);
+    return JS_UNDEFINED;
+ fail:
+    JS_FreeValue(ctx, opset_obj);
+    return JS_EXCEPTION;
+}
+
+static int js_operators_set_default(JSContext *ctx, JSValueConst obj)
+{
+    JSValue opset_obj;
+
+    if (!JS_IsObject(obj)) /* in case the prototype is not defined */
+        return 0;
+    opset_obj = js_operators_create_internal(ctx, 0, NULL, TRUE);
+    if (JS_IsException(opset_obj))
+        return -1;
+    /* cannot be modified by the user */
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_Symbol_operatorSet,
+                           opset_obj, 0);
+    return 0;
+}
+
+static JSValue js_dummy_operators_ctor(JSContext *ctx, JSValueConst new_target,
+                                       int argc, JSValueConst *argv)
+{
+    return js_create_from_ctor(ctx, new_target, JS_CLASS_OBJECT);
+}
+
+static JSValue js_global_operators(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
+{
+    JSValue func_obj, proto, opset_obj;
+
+    func_obj = JS_UNDEFINED;
+    proto = JS_NewObject(ctx);
+    if (JS_IsException(proto))
+        return JS_EXCEPTION;
+    opset_obj = js_operators_create_internal(ctx, argc, argv, FALSE);
+    if (JS_IsException(opset_obj))
+        goto fail;
+    JS_DefinePropertyValue(ctx, proto, JS_ATOM_Symbol_operatorSet,
+                           opset_obj, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    func_obj = JS_NewCFunction2(ctx, js_dummy_operators_ctor, "Operators",
+                                0, JS_CFUNC_constructor, 0);
+    if (JS_IsException(func_obj))
+        goto fail;
+    JS_SetConstructor2(ctx, func_obj, proto,
+                       0, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_FreeValue(ctx, proto);
+    return func_obj;
+ fail:
+    JS_FreeValue(ctx, proto);
+    JS_FreeValue(ctx, func_obj);
+    return JS_EXCEPTION;
+}
+
+static const JSCFunctionListEntry js_operators_funcs[] = {
+    JS_CFUNC_DEF("create", 1, js_operators_create ),
+    JS_CFUNC_DEF("updateBigIntOperators", 2, js_operators_updateBigIntOperators ),
+};
+
+/* must be called after all overloadable base types are initialized */
+void JS_AddIntrinsicOperators(JSContext *ctx)
+{
+    JSValue obj;
+
+    ctx->allow_operator_overloading = TRUE;
+    obj = JS_NewCFunction(ctx, js_global_operators, "Operators", 1);
+    JS_SetPropertyFunctionList(ctx, obj,
+                               js_operators_funcs,
+                               countof(js_operators_funcs));
+    JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_Operators,
+                           obj,
+                           JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    /* add default operatorSets */
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BOOLEAN]);
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_NUMBER]);
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_STRING]);
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_INT]);
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT]);
+    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
+}
+
 /* BigInt */
 
 static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag;
-    BOOL is_legacy;
-    int ret;
 
-    is_legacy = is_bigint_mode(ctx) ^ 1;
  redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
     case JS_TAG_INT:
     case JS_TAG_BOOL:
-        if (is_legacy) {
-            bf_t r_s, *r = &r_s;
-            bf_init(ctx->bf_ctx, r);
-            bf_set_si(r, JS_VALUE_GET_INT(val));
-            val = JS_NewBigInt2(ctx, r, TRUE);
-        } else {
-            val = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
-        }
+        val = JS_NewBigInt64(ctx, JS_VALUE_GET_INT(val));
         break;
     case JS_TAG_BIG_INT:
         break;
     case JS_TAG_FLOAT64:
     case JS_TAG_BIG_FLOAT:
         {
-            bf_t *a, a_s, r_s, *r = &r_s;
+            bf_t *a, a_s;
+            
             a = JS_ToBigFloat(ctx, &a_s, val);
-            bf_init(ctx->bf_ctx, r);
             if (!bf_is_finite(a)) {
                 JS_FreeValue(ctx, val);
                 val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to bigint");
             } else {
-                bf_set(r, a);
-                ret = bf_rint(r, BF_RNDZ);
+                JSValue val1 = JS_NewBigInt(ctx);
+                bf_t *r;
+                int ret;
+                if (JS_IsException(val1)) {
+                    JS_FreeValue(ctx, val);
+                    return JS_EXCEPTION;
+                }
+                r = JS_GetBigInt(val1);
+                ret = bf_set(r, a);
+                ret |= bf_rint(r, BF_RNDZ);
                 JS_FreeValue(ctx, val);
-                if (is_legacy && (ret & BF_ST_INEXACT)) {
-                    bf_delete(r);
+                if (ret & BF_ST_MEM_ERROR) {
+                    JS_FreeValue(ctx, val1);
+                    val = JS_ThrowOutOfMemory(ctx);
+                } else if (ret & BF_ST_INEXACT) {
+                    JS_FreeValue(ctx, val1);
                     val = JS_ThrowRangeError(ctx, "cannot convert to bigint: not an integer");
                 } else {
-                    val = JS_NewBigInt2(ctx, r, is_legacy);
+                    val = JS_CompactBigInt(ctx, val1);
                 }
             }
             if (a == &a_s)
                 bf_delete(a);
         }
         break;
+    case JS_TAG_BIG_DECIMAL:
+        val = JS_ToStringFree(ctx, val);
+         if (JS_IsException(val))
+            break;
+        goto redo;
     case JS_TAG_STRING:
         val = JS_StringToBigIntErr(ctx, val);
         break;
     case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val,
-                                 is_legacy ? HINT_NUMBER : HINT_INTEGER);
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
         if (JS_IsException(val))
             break;
         goto redo;
@@ -47154,17 +47159,6 @@ static JSValue js_bigint_constructor(JSContext *ctx,
     return JS_ToBigIntCtorFree(ctx, JS_DupValue(ctx, argv[0]));
 }
 
-static inline BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
-{
-    int tag = JS_VALUE_GET_TAG(v);
-    if (tag == JS_TAG_BIG_INT)
-        return TRUE;
-    if (is_bigint_mode(ctx))
-        return tag == JS_TAG_INT;
-    else
-        return FALSE;
-}
-
 static JSValue js_thisBigIntValue(JSContext *ctx, JSValueConst this_val)
 {
     if (JS_IsBigInt(ctx, this_val))
@@ -47173,8 +47167,6 @@ static JSValue js_thisBigIntValue(JSContext *ctx, JSValueConst this_val)
     if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
         JSObject *p = JS_VALUE_GET_OBJ(this_val);
         if (p->class_id == JS_CLASS_BIG_INT) {
-            /* XXX: may relax the check in case the object comes from
-               bignum mode */
             if (JS_IsBigInt(ctx, p->u.object_data))
                 return JS_DupValue(ctx, p->u.object_data);
         }
@@ -47195,12 +47187,9 @@ static JSValue js_bigint_toString(JSContext *ctx, JSValueConst this_val,
     if (argc == 0 || JS_IsUndefined(argv[0])) {
         base = 10;
     } else {
-        if (JS_ToInt32Sat(ctx, &base, argv[0]))
+        base = js_get_radix(ctx, argv[0]);
+        if (base < 0)
             goto fail;
-        if (base < 2 || base > 36) {
-            JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
-            goto fail;
-        }
     }
     ret = js_bigint_to_string1(ctx, val, base);
     JS_FreeValue(ctx, val);
@@ -47220,72 +47209,96 @@ static JSValue js_bigint_div(JSContext *ctx,
                               JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
 {
-    bf_t a_s, b_s, *a, *b, r_s, *r = &r_s, q_s, *q = &q_s;
+    bf_t a_s, b_s, *a, *b, *r, *q;
     int status;
-
+    JSValue q_val, r_val;
+    
+    q_val = JS_NewBigInt(ctx);
+    if (JS_IsException(q_val))
+        return JS_EXCEPTION;
+    r_val = JS_NewBigInt(ctx);
+    if (JS_IsException(r_val))
+        goto fail;
     b = NULL;
     a = JS_ToBigInt(ctx, &a_s, argv[0]);
     if (!a)
-        return JS_EXCEPTION;
+        goto fail;
     b = JS_ToBigInt(ctx, &b_s, argv[1]);
     if (!b) {
         JS_FreeBigInt(ctx, a, &a_s);
-        return JS_EXCEPTION;
+        goto fail;
     }
-    bf_init(ctx->bf_ctx, q);
-    bf_init(ctx->bf_ctx, r);
+    q = JS_GetBigInt(q_val);
+    r = JS_GetBigInt(r_val);
     status = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, magic & 0xf);
     JS_FreeBigInt(ctx, a, &a_s);
     JS_FreeBigInt(ctx, b, &b_s);
     if (unlikely(status)) {
-        bf_delete(q);
-        bf_delete(r);
         throw_bf_exception(ctx, status);
-        return JS_EXCEPTION;
+        goto fail;
     }
+    q_val = JS_CompactBigInt(ctx, q_val);
     if (magic & 0x10) {
         JSValue ret;
-        /* XXX: handle exceptions */
         ret = JS_NewArray(ctx);
-        JS_SetPropertyUint32(ctx, ret, 0, JS_NewBigInt(ctx, q));
-        JS_SetPropertyUint32(ctx, ret, 1, JS_NewBigInt(ctx, r));
+        if (JS_IsException(ret))
+            goto fail;
+        JS_SetPropertyUint32(ctx, ret, 0, q_val);
+        JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, r_val));
         return ret;
     } else {
-        bf_delete(r);
-        return JS_NewBigInt(ctx, q);
+        JS_FreeValue(ctx, r_val);
+        return q_val;
     }
+ fail:
+    JS_FreeValue(ctx, q_val);
+    JS_FreeValue(ctx, r_val);
+    return JS_EXCEPTION;
 }
 
 static JSValue js_bigint_sqrt(JSContext *ctx,
                                JSValueConst this_val,
                                int argc, JSValueConst *argv, int magic)
 {
-    bf_t a_s, *a, r_s, *r = &r_s, rem_s, *rem = &rem_s;
+    bf_t a_s, *a, *r, *rem;
     int status;
+    JSValue r_val, rem_val;
+    
+    r_val = JS_NewBigInt(ctx);
+    if (JS_IsException(r_val))
+        return JS_EXCEPTION;
+    rem_val = JS_NewBigInt(ctx);
+    if (JS_IsException(rem_val))
+        return JS_EXCEPTION;
+    r = JS_GetBigInt(r_val);
+    rem = JS_GetBigInt(rem_val);
 
     a = JS_ToBigInt(ctx, &a_s, argv[0]);
     if (!a)
-        return JS_EXCEPTION;
-    bf_init(ctx->bf_ctx, r);
-    bf_init(ctx->bf_ctx, rem);
+        goto fail;
     status = bf_sqrtrem(r, rem, a);
     JS_FreeBigInt(ctx, a, &a_s);
     if (unlikely(status & ~BF_ST_INEXACT)) {
-        bf_delete(r);
-        bf_delete(rem);
-        return throw_bf_exception(ctx, status);
+        throw_bf_exception(ctx, status);
+        goto fail;
     }
+    r_val = JS_CompactBigInt(ctx, r_val);
     if (magic) {
         JSValue ret;
-        /* XXX: handle exceptions */
         ret = JS_NewArray(ctx);
-        JS_SetPropertyUint32(ctx, ret, 0, JS_NewBigInt(ctx, r));
-        JS_SetPropertyUint32(ctx, ret, 1, JS_NewBigInt(ctx, rem));
+        if (JS_IsException(ret))
+            goto fail;
+        JS_SetPropertyUint32(ctx, ret, 0, r_val);
+        JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, rem_val));
         return ret;
     } else {
-        bf_delete(rem);
-        return JS_NewBigInt(ctx, r);
+        JS_FreeValue(ctx, rem_val);
+        return r_val;
     }
+ fail:
+    JS_FreeValue(ctx, r_val);
+    JS_FreeValue(ctx, rem_val);
+    return JS_EXCEPTION;
 }
 
 static JSValue js_bigint_op1(JSContext *ctx,
@@ -47326,15 +47339,22 @@ static JSValue js_bigint_asUintN(JSContext *ctx,
                                   int argc, JSValueConst *argv, int asIntN)
 {
     uint64_t bits;
-    bf_t a_s, *a = &a_s, r_s, *r = &r_s, mask_s, *mask = &mask_s;
-
+    bf_t a_s, *a = &a_s, *r, mask_s, *mask = &mask_s;
+    JSValue res;
+    
     if (JS_ToIndex(ctx, &bits, argv[0]))
         return JS_EXCEPTION;
+    res = JS_NewBigInt(ctx);
+    if (JS_IsException(res))
+        return JS_EXCEPTION;
+    r = JS_GetBigInt(res);
     a = JS_ToBigInt(ctx, &a_s, argv[1]);
-    if (!a)
+    if (!a) {
+        JS_FreeValue(ctx, res);
         return JS_EXCEPTION;
+    }
     /* XXX: optimize */
-    bf_init(ctx->bf_ctx, r);
+    r = JS_GetBigInt(res);
     bf_init(ctx->bf_ctx, mask);
     bf_set_ui(mask, 1);
     bf_mul_2exp(mask, bits, BF_PREC_INF, BF_RNDZ);
@@ -47351,7 +47371,7 @@ static JSValue js_bigint_asUintN(JSContext *ctx,
     }
     bf_delete(mask);
     JS_FreeBigInt(ctx, a, &a_s);
-    return JS_NewBigInt(ctx, r);
+    return JS_CompactBigInt(ctx, res);
 }
 
 static const JSCFunctionListEntry js_bigint_funcs[] = {
@@ -47430,12 +47450,9 @@ static JSValue js_bigfloat_toString(JSContext *ctx, JSValueConst this_val,
     if (argc == 0 || JS_IsUndefined(argv[0])) {
         base = 10;
     } else {
-        if (JS_ToInt32Sat(ctx, &base, argv[0]))
-            goto fail;
-        if (base < 2 || base > 36) {
-            JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
+        base = js_get_radix(ctx, argv[0]);
+        if (base < 0)
             goto fail;
-        }
     }
     ret = js_ftoa(ctx, val, base, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
     JS_FreeValue(ctx, val);
@@ -47451,7 +47468,7 @@ static JSValue js_bigfloat_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisBigFloatValue(ctx, this_val);
 }
 
-static int get_rnd_mode(JSContext *ctx, JSValueConst val)
+static int bigfloat_get_rnd_mode(JSContext *ctx, JSValueConst val)
 {
     int rnd_mode;
     if (JS_ToInt32Sat(ctx, &rnd_mode, val))
@@ -47468,8 +47485,7 @@ static JSValue js_bigfloat_toFixed(JSContext *ctx, JSValueConst this_val,
 {
     JSValue val, ret;
     int64_t f;
-    int res, rnd_mode;
-    bf_t a_s, *a, b;
+    int rnd_mode, radix;
 
     val = js_thisBigFloatValue(ctx, this_val);
     if (JS_IsException(val))
@@ -47481,26 +47497,19 @@ static JSValue js_bigfloat_toFixed(JSContext *ctx, JSValueConst this_val,
         goto fail;
     }
     rnd_mode = BF_RNDNA;
+    radix = 10;
+    /* XXX: swap parameter order for rounding mode and radix */
     if (argc > 1) {
-        rnd_mode = get_rnd_mode(ctx, argv[1]);
+        rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
         if (rnd_mode < 0)
             goto fail;
     }
-
-    a = JS_ToBigFloat(ctx, &a_s, val);
-    if (!a)
-        goto fail;
-    bf_init(ctx->bf_ctx, &b);
-    bf_set_float64(&b, 1e21);
-    res = bf_cmpu(a, &b);
-    bf_delete(&b);
-    if (a == &a_s)
-        bf_delete(a);
-    if (res >= 0) {
-        ret = JS_ToString(ctx, val);
-    } else {
-        ret = js_ftoa(ctx, val, 10, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+    if (argc > 2) {
+        radix = js_get_radix(ctx, argv[2]);
+        if (radix < 0)
+            goto fail;
     }
+    ret = js_ftoa(ctx, val, radix, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
     JS_FreeValue(ctx, val);
     return ret;
  fail:
@@ -47533,7 +47542,7 @@ static JSValue js_bigfloat_toExponential(JSContext *ctx, JSValueConst this_val,
 {
     JSValue val, ret;
     int64_t f;
-    int rnd_mode;
+    int rnd_mode, radix;
 
     val = js_thisBigFloatValue(ctx, this_val);
     if (JS_IsException(val))
@@ -47551,12 +47560,18 @@ static JSValue js_bigfloat_toExponential(JSContext *ctx, JSValueConst this_val,
             goto fail;
         }
         rnd_mode = BF_RNDNA;
+        radix = 10;
         if (argc > 1) {
-            rnd_mode = get_rnd_mode(ctx, argv[1]);
+            rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
             if (rnd_mode < 0)
                 goto fail;
         }
-        ret = js_ftoa(ctx, val, 10, f + 1,
+        if (argc > 2) {
+            radix = js_get_radix(ctx, argv[2]);
+            if (radix < 0)
+                goto fail;
+        }
+        ret = js_ftoa(ctx, val, radix, f + 1,
                       rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
     }
     JS_FreeValue(ctx, val);
@@ -47571,7 +47586,7 @@ static JSValue js_bigfloat_toPrecision(JSContext *ctx, JSValueConst this_val,
 {
     JSValue val, ret;
     int64_t p;
-    int rnd_mode;
+    int rnd_mode, radix;
 
     val = js_thisBigFloatValue(ctx, this_val);
     if (JS_IsException(val))
@@ -47589,12 +47604,18 @@ static JSValue js_bigfloat_toPrecision(JSContext *ctx, JSValueConst this_val,
             goto fail;
         }
         rnd_mode = BF_RNDNA;
+        radix = 10;
         if (argc > 1) {
-            rnd_mode = get_rnd_mode(ctx, argv[1]);
+            rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
             if (rnd_mode < 0)
                 goto fail;
         }
-        ret = js_ftoa(ctx, val, 10, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
+        if (argc > 2) {
+            radix = js_get_radix(ctx, argv[2]);
+            if (radix < 0)
+                goto fail;
+        }
+        ret = js_ftoa(ctx, val, radix, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
     }
     JS_FreeValue(ctx, val);
     return ret;
@@ -47617,10 +47638,12 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
 {
     JSValue val;
     if (argc == 0) {
-        bf_t r_s, *r = &r_s;
-        bf_init(ctx->bf_ctx, r);
+        bf_t *r;
+        val = JS_NewBigFloat(ctx);
+        if (JS_IsException(val))
+            return val;
+        r = JS_GetBigFloat(val);
         bf_set_zero(r, 0);
-        val = JS_NewBigFloat(ctx, r);
     } else {
         val = JS_DupValue(ctx, argv[0]);
     redo:
@@ -47629,18 +47652,26 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
             break;
         case JS_TAG_FLOAT64:
             {
-                bf_t r_s, *r = &r_s;
-                bf_init(ctx->bf_ctx, r);
-                bf_set_float64(r, JS_VALUE_GET_FLOAT64(val));
-                val = JS_NewBigFloat(ctx, r);
+                bf_t *r;
+                double d = JS_VALUE_GET_FLOAT64(val);
+                val = JS_NewBigFloat(ctx);
+                if (JS_IsException(val))
+                    break;
+                r = JS_GetBigFloat(val);
+                if (bf_set_float64(r, d))
+                    goto fail;
             }
             break;
         case JS_TAG_INT:
             {
-                bf_t r_s, *r = &r_s;
-                bf_init(ctx->bf_ctx, r);
-                bf_set_si(r, JS_VALUE_GET_INT(val));
-                val = JS_NewBigFloat(ctx, r);
+                bf_t *r;
+                int32_t v = JS_VALUE_GET_INT(val);
+                val = JS_NewBigFloat(ctx);
+                if (JS_IsException(val))
+                    break;
+                r = JS_GetBigFloat(val);
+                if (bf_set_si(r, v))
+                    goto fail;
             }
             break;
         case JS_TAG_BIG_INT:
@@ -47650,6 +47681,11 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
                 val = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
             }
             break;
+        case JS_TAG_BIG_DECIMAL:
+            val = JS_ToStringFree(ctx, val);
+            if (JS_IsException(val))
+                break;
+            goto redo;
         case JS_TAG_STRING:
             {
                 const char *str, *p;
@@ -47663,10 +47699,12 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
                 p = str;
                 p += skip_spaces(p);
                 if ((p - str) == len) {
-                    bf_t r_s, *r = &r_s;
-                    bf_init(ctx->bf_ctx, r);
-                    bf_set_si(r, 0);
-                    val = JS_NewBigFloat(ctx, r);
+                    bf_t *r;
+                    val = JS_NewBigFloat(ctx);
+                    if (JS_IsException(val))
+                        break;
+                    r = JS_GetBigFloat(val);
+                    bf_set_zero(r, 0);
                     err = 0;
                 } else {
                     val = js_atof(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT |
@@ -47699,13 +47737,20 @@ static JSValue js_bigfloat_constructor(JSContext *ctx,
         }
     }
     return val;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
 }
 
 static JSValue js_bigfloat_get_const(JSContext *ctx,
-                                  JSValueConst this_val, int magic)
+                                     JSValueConst this_val, int magic)
 {
-    bf_t r_s, *r = &r_s;
-    bf_init(ctx->bf_ctx, r);
+    bf_t *r;
+    JSValue val;
+    val = JS_NewBigFloat(ctx);
+    if (JS_IsException(val))
+        return val;
+    r = JS_GetBigFloat(val);
     switch(magic) {
     case 0: /* PI */
         bf_const_pi(r, ctx->fp_env.prec, ctx->fp_env.flags);
@@ -47741,13 +47786,13 @@ static JSValue js_bigfloat_get_const(JSContext *ctx,
     default:
         abort();
     }
-    return JS_NewBigFloat(ctx, r);
+    return val;
 }
 
 static JSValue js_bigfloat_parseFloat(JSContext *ctx, JSValueConst this_val,
                                       int argc, JSValueConst *argv)
 {
-    bf_t a_s, *a = &a_s;
+    bf_t *a;
     const char *str;
     JSValue ret;
     int radix;
@@ -47771,10 +47816,13 @@ static JSValue js_bigfloat_parseFloat(JSContext *ctx, JSValueConst this_val,
         if (!fe)
             goto fail;
     }
-    bf_init(ctx->bf_ctx, a);
+    ret = JS_NewBigFloat(ctx);
+    if (JS_IsException(ret))
+        goto done;
+    a = JS_GetBigFloat(ret);
     /* XXX: use js_atof() */
     bf_atof(a, str, NULL, radix, fe->prec, fe->flags);
-    ret = JS_NewBigFloat(ctx, a);
+ done:
     JS_FreeCString(ctx, str);
     return ret;
 }
@@ -47800,7 +47848,201 @@ static JSValue js_bigfloat_isNaN(JSContext *ctx, JSValueConst this_val,
     if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
         return JS_FALSE;
     p = JS_VALUE_GET_PTR(val);
-    return JS_NewBool(ctx, bf_is_finite(&p->num));
+    return JS_NewBool(ctx, bf_is_nan(&p->num));
+}
+
+enum {
+    MATH_OP_ABS,
+    MATH_OP_FLOOR,
+    MATH_OP_CEIL,
+    MATH_OP_ROUND,
+    MATH_OP_TRUNC,
+    MATH_OP_SQRT,
+    MATH_OP_FPROUND,
+    MATH_OP_ACOS,
+    MATH_OP_ASIN,
+    MATH_OP_ATAN,
+    MATH_OP_ATAN2,
+    MATH_OP_COS,
+    MATH_OP_EXP,
+    MATH_OP_LOG,
+    MATH_OP_POW,
+    MATH_OP_SIN,
+    MATH_OP_TAN,
+    MATH_OP_FMOD,
+    MATH_OP_REM,
+    MATH_OP_SIGN,
+
+    MATH_OP_ADD,
+    MATH_OP_SUB,
+    MATH_OP_MUL,
+    MATH_OP_DIV,
+};
+
+static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv, int magic)
+{
+    bf_t a_s, *a, *r;
+    JSFloatEnv *fe;
+    int rnd_mode;
+    JSValue op1, res;
+
+    op1 = JS_ToNumeric(ctx, argv[0]);
+    if (JS_IsException(op1))
+        return op1;
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    fe = &ctx->fp_env;
+    if (argc > 1) {
+        fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
+        if (!fe)
+            goto fail;
+    }
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res)) {
+    fail:
+        if (a == &a_s)
+            bf_delete(a);
+        JS_FreeValue(ctx, op1);
+        return JS_EXCEPTION;
+    }
+    r = JS_GetBigFloat(res);
+    switch (magic) {
+    case MATH_OP_ABS:
+        bf_set(r, a);
+        r->sign = 0;
+        break;
+    case MATH_OP_FLOOR:
+        rnd_mode = BF_RNDD;
+        goto rint;
+    case MATH_OP_CEIL:
+        rnd_mode = BF_RNDU;
+        goto rint;
+    case MATH_OP_ROUND:
+        rnd_mode = BF_RNDNA;
+        goto rint;
+    case MATH_OP_TRUNC:
+        rnd_mode = BF_RNDZ;
+    rint:
+        bf_set(r, a);
+        fe->status |= bf_rint(r, rnd_mode);
+        break;
+    case MATH_OP_SQRT:
+        fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_FPROUND:
+        bf_set(r, a);
+        fe->status |= bf_round(r, fe->prec, fe->flags);
+        break;
+    case MATH_OP_ACOS:
+        fe->status |= bf_acos(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_ASIN:
+        fe->status |= bf_asin(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_ATAN:
+        fe->status |= bf_atan(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_COS:
+        fe->status |= bf_cos(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_EXP:
+        fe->status |= bf_exp(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_LOG:
+        fe->status |= bf_log(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_SIN:
+        fe->status |= bf_sin(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_TAN:
+        fe->status |= bf_tan(r, a, fe->prec, fe->flags);
+        break;
+    case MATH_OP_SIGN:
+        if (bf_is_nan(a) || bf_is_zero(a)) {
+            bf_set(r, a);
+        } else {
+            bf_set_si(r, 1 - 2 * a->sign);
+        }
+        break;
+    default:
+        abort();
+    }
+    if (a == &a_s)
+        bf_delete(a);
+    JS_FreeValue(ctx, op1);
+    return res;
+}
+
+static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv, int magic)
+{
+    bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
+    JSFloatEnv *fe;
+    JSValue op1, op2, res;
+
+    op1 = JS_ToNumeric(ctx, argv[0]);
+    if (JS_IsException(op1))
+        return op1;
+    op2 = JS_ToNumeric(ctx, argv[1]);
+    if (JS_IsException(op2)) {
+        JS_FreeValue(ctx, op1);
+        return op2;
+    }
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    b = JS_ToBigFloat(ctx, &b_s, op2);
+    fe = &ctx->fp_env;
+    if (argc > 2) {
+        fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
+        if (!fe)
+            goto fail;
+    }
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res)) {
+    fail:
+        if (a == &a_s)
+            bf_delete(a);
+        if (b == &b_s)
+            bf_delete(b);
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        return JS_EXCEPTION;
+    }
+    r = JS_GetBigFloat(res);
+    switch (magic) {
+    case MATH_OP_ATAN2:
+        fe->status |= bf_atan2(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_POW:
+        fe->status |= bf_pow(r, a, b, fe->prec, fe->flags | BF_POW_JS_QUIRKS);
+        break;
+    case MATH_OP_FMOD:
+        fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
+        break;
+    case MATH_OP_REM:
+        fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDN);
+        break;
+    case MATH_OP_ADD:
+        fe->status |= bf_add(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_SUB:
+        fe->status |= bf_sub(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_MUL:
+        fe->status |= bf_mul(r, a, b, fe->prec, fe->flags);
+        break;
+    case MATH_OP_DIV:
+        fe->status |= bf_div(r, a, b, fe->prec, fe->flags);
+        break;
+    default:
+        abort();
+    }
+    if (a == &a_s)
+        bf_delete(a);
+    if (b == &b_s)
+        bf_delete(b);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return res;
 }
 
 static const JSCFunctionListEntry js_bigfloat_funcs[] = {
@@ -47895,9 +48137,6 @@ static JSValue js_float_env_get_expBits(JSContext *ctx, JSValueConst this_val)
     return JS_NewInt32(ctx, bf_get_exp_bits(ctx->fp_env.flags));
 }
 
-/* temporary fix for string conversion overflows */
-#define BF_EXP_BITS_MAX1 (BF_EXP_BITS_MAX - 1)
-
 static JSValue js_float_env_setPrec(JSContext *ctx,
                                     JSValueConst this_val,
                                     int argc, JSValueConst *argv)
@@ -47913,18 +48152,16 @@ static JSValue js_float_env_setPrec(JSContext *ctx,
         return JS_EXCEPTION;
     if (prec < BF_PREC_MIN || prec > BF_PREC_MAX)
         return JS_ThrowRangeError(ctx, "invalid precision");
-    exp_bits = BF_EXP_BITS_MAX1;
+    exp_bits = BF_EXP_BITS_MAX;
 
     if (argc > 2 && !JS_IsUndefined(argv[2])) {
         if (JS_ToInt32Sat(ctx, &exp_bits, argv[2]))
             return JS_EXCEPTION;
-        if (exp_bits < BF_EXP_BITS_MIN || exp_bits > BF_EXP_BITS_MAX1)
+        if (exp_bits < BF_EXP_BITS_MIN || exp_bits > BF_EXP_BITS_MAX)
             return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
     }
 
-    flags = BF_RNDN | bf_set_exp_bits(exp_bits);
-    if (exp_bits != BF_EXP_BITS_MAX1)
-        flags |= BF_FLAG_SUBNORMAL;
+    flags = BF_RNDN | BF_FLAG_SUBNORMAL | bf_set_exp_bits(exp_bits);
 
     saved_prec = ctx->fp_env.prec;
     saved_flags = ctx->fp_env.flags;
@@ -47984,24 +48221,20 @@ static JSValue js_float_env_proto_set_status(JSContext *ctx, JSValueConst this_v
     case FE_EXP:
         if (JS_ToInt32Sat(ctx, &b, val))
             return JS_EXCEPTION;
-        if (b < BF_EXP_BITS_MIN || b > BF_EXP_BITS_MAX1)
+        if (b < BF_EXP_BITS_MIN || b > BF_EXP_BITS_MAX)
             return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
-        if (b == BF_EXP_BITS_MAX1)
-            fe->flags &= ~BF_FLAG_SUBNORMAL;
         fe->flags = (fe->flags & ~(BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)) |
             bf_set_exp_bits(b);
         break;
     case FE_RNDMODE:
-        b = get_rnd_mode(ctx, val);
+        b = bigfloat_get_rnd_mode(ctx, val);
         if (b < 0)
             return JS_EXCEPTION;
         fe->flags = (fe->flags & ~BF_RND_MASK) | b;
         break;
     case FE_SUBNORMAL:
         b = JS_ToBool(ctx, val);
-        if (bf_get_exp_bits(fe->flags) != BF_EXP_BITS_MAX1) {
-            fe->flags = (fe->flags & ~BF_FLAG_SUBNORMAL) | (b ? BF_FLAG_SUBNORMAL: 0);
-        }
+        fe->flags = (fe->flags & ~BF_FLAG_SUBNORMAL) | (b ? BF_FLAG_SUBNORMAL: 0);
         break;
     default:
         b = JS_ToBool(ctx, val);
@@ -48031,12 +48264,12 @@ static const JSCFunctionListEntry js_float_env_funcs[] = {
     JS_PROP_INT32_DEF("RNDU", BF_RNDU, 0 ),
     JS_PROP_INT32_DEF("RNDD", BF_RNDD, 0 ),
     JS_PROP_INT32_DEF("RNDNA", BF_RNDNA, 0 ),
-    JS_PROP_INT32_DEF("RNDNU", BF_RNDNU, 0 ),
+    JS_PROP_INT32_DEF("RNDA", BF_RNDA, 0 ),
     JS_PROP_INT32_DEF("RNDF", BF_RNDF, 0 ),
     JS_PROP_INT32_DEF("precMin", BF_PREC_MIN, 0 ),
     JS_PROP_INT64_DEF("precMax", BF_PREC_MAX, 0 ),
     JS_PROP_INT32_DEF("expBitsMin", BF_EXP_BITS_MIN, 0 ),
-    JS_PROP_INT32_DEF("expBitsMax", BF_EXP_BITS_MAX1, 0 ),
+    JS_PROP_INT32_DEF("expBitsMax", BF_EXP_BITS_MAX, 0 ),
 };
 
 static const JSCFunctionListEntry js_float_env_proto_funcs[] = {
@@ -48112,10 +48345,18 @@ static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
     case JS_TAG_BOOL:
     case JS_TAG_INT:
         {
-            bfdec_t r_s, *r = &r_s;
-            bfdec_init(ctx->bf_ctx, r);
-            bfdec_set_si(r, JS_VALUE_GET_INT(val));
-            val = JS_NewBigDecimal(ctx, r);
+            bfdec_t *r;
+            int32_t v = JS_VALUE_GET_INT(val);
+
+            val = JS_NewBigDecimal(ctx);
+            if (JS_IsException(val))
+                break;
+            r = JS_GetBigDecimal(val);
+            if (bfdec_set_si(r, v)) {
+                JS_FreeValue(ctx, val);
+                val = JS_EXCEPTION;
+                break;
+            }
         }
         break;
     case JS_TAG_FLOAT64:
@@ -48138,10 +48379,12 @@ static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
             p = str;
             p += skip_spaces(p);
             if ((p - str) == len) {
-                bfdec_t r_s, *r = &r_s;
-                bfdec_init(ctx->bf_ctx, r);
+                bfdec_t *r;
+                val = JS_NewBigDecimal(ctx);
+                if (JS_IsException(val))
+                    break;
+                r = JS_GetBigDecimal(val);
                 bfdec_set_zero(r, 0);
-                val = JS_NewBigDecimal(ctx, r);
                 err = 0;
             } else {
                 val = js_atof(ctx, p, &p, 0, ATOD_TYPE_BIG_DECIMAL);
@@ -48166,12 +48409,14 @@ static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
         goto redo;
     case JS_TAG_UNDEFINED:
         {
-            bfdec_t r_s, *r = &r_s;
+            bfdec_t *r;
             if (!allow_null_or_undefined)
                 goto fail;
-            bfdec_init(ctx->bf_ctx, r);
+            val = JS_NewBigDecimal(ctx);
+            if (JS_IsException(val))
+                break;
+            r = JS_GetBigDecimal(val);
             bfdec_set_nan(r);
-            val = JS_NewBigDecimal(ctx, r);
         }
         break;
     default:
@@ -48188,10 +48433,12 @@ static JSValue js_bigdecimal_constructor(JSContext *ctx,
 {
     JSValue val;
     if (argc == 0) {
-        bfdec_t r_s, *r = &r_s;
-        bfdec_init(ctx->bf_ctx, r);
+        bfdec_t *r;
+        val = JS_NewBigDecimal(ctx);
+        if (JS_IsException(val))
+            return val;
+        r = JS_GetBigDecimal(val);
         bfdec_set_zero(r, 0);
-        val = JS_NewBigDecimal(ctx, r);
     } else {
         val = JS_ToBigDecimalFree(ctx, JS_DupValue(ctx, argv[0]), FALSE);
     }
@@ -48230,6 +48477,39 @@ static JSValue js_bigdecimal_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisBigDecimalValue(ctx, this_val);
 }
 
+static int js_bigdecimal_get_rnd_mode(JSContext *ctx, JSValueConst obj)
+{
+    const char *str;
+    size_t size;
+    int rnd_mode;
+    
+    str = JS_ToCStringLen(ctx, &size, obj);
+    if (!str)
+        return -1;
+    if (strlen(str) != size)
+        goto invalid_rounding_mode;
+    if (!strcmp(str, "floor")) {
+        rnd_mode = BF_RNDD;
+    } else if (!strcmp(str, "ceiling")) {
+        rnd_mode = BF_RNDU;
+    } else if (!strcmp(str, "down")) {
+        rnd_mode = BF_RNDZ;
+    } else if (!strcmp(str, "up")) {
+        rnd_mode = BF_RNDA;
+    } else if (!strcmp(str, "half-even")) {
+        rnd_mode = BF_RNDN;
+    } else if (!strcmp(str, "half-up")) {
+        rnd_mode = BF_RNDNA;
+    } else {
+    invalid_rounding_mode:
+        JS_FreeCString(ctx, str);
+        JS_ThrowTypeError(ctx, "invalid rounding mode");
+        return -1;
+    }
+    JS_FreeCString(ctx, str);
+    return rnd_mode;
+}
+
 typedef struct {
     int64_t prec;
     bf_flags_t flags;
@@ -48239,10 +48519,9 @@ static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
                                  JSValueConst obj)
 {
     JSValue prop;
-    const char *str;
-    size_t size;
     int64_t val;
     BOOL has_prec;
+    int rnd_mode;
     
     if (!JS_IsObject(obj)) {
         JS_ThrowTypeErrorNotAnObject(ctx);
@@ -48251,29 +48530,11 @@ static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
     prop = JS_GetProperty(ctx, obj, JS_ATOM_roundingMode);
     if (JS_IsException(prop))
         return -1;
-    str = JS_ToCStringLen(ctx, &size, prop);
+    rnd_mode = js_bigdecimal_get_rnd_mode(ctx, prop);
     JS_FreeValue(ctx, prop);
-    if (!str)
-        return -1;
-    if (strlen(str) != size)
-        goto invalid_rounding_mode;
-    if (!strcmp(str, "floor")) {
-        fe->flags = BF_RNDD;
-    } else if (!strcmp(str, "ceiling")) {
-        fe->flags = BF_RNDU;
-    } else if (!strcmp(str, "down")) {
-        fe->flags = BF_RNDZ;
-    } else if (!strcmp(str, "half-even")) {
-        fe->flags = BF_RNDN;
-    } else if (!strcmp(str, "half-up")) {
-        fe->flags = BF_RNDNA;
-    } else {
-    invalid_rounding_mode:
-        JS_FreeCString(ctx, str);
-        JS_ThrowTypeError(ctx, "invalid rounding mode");
+    if (rnd_mode < 0)
         return -1;
-    }
-    JS_FreeCString(ctx, str);
+    fe->flags = rnd_mode;
     
     prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
     if (JS_IsException(prop))
@@ -48282,7 +48543,7 @@ static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
     if (!JS_IsUndefined(prop)) {
         if (JS_ToInt64SatFree(ctx, &val, prop))
             return -1;
-        if (val < 0 || val > BF_PREC_MAX)
+        if (val < 1 || val > BF_PREC_MAX)
             goto invalid_precision;
         fe->prec = val;
         has_prec = TRUE;
@@ -48320,7 +48581,7 @@ static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv, int magic)
 {
     bfdec_t *a, *b, r_s, *r = &r_s;
-    JSValue op1, op2;
+    JSValue op1, op2, res;
     BigDecimalEnv fe_s, *fe = &fe_s;
     int op_count, ret;
 
@@ -48354,21 +48615,18 @@ static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
     fe->flags = BF_RNDZ;
     fe->prec = BF_PREC_INF;
     if (op_count < argc) {
-        if (js_bigdecimal_get_env(ctx, fe, argv[op_count])) {
-        fail:
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            return JS_EXCEPTION;
-        }
-        if ((fe->flags & BF_FLAG_RADPNT_PREC) &&
-            magic != MATH_OP_DIV &&
-            magic != MATH_OP_ROUND) {
-            JS_ThrowTypeError(ctx, "maximumFractionDigits is not supported for this operation");
+        if (js_bigdecimal_get_env(ctx, fe, argv[op_count]))
             goto fail;
-        }
     }
 
-    bfdec_init(ctx->bf_ctx, r);
+    res = JS_NewBigDecimal(ctx);
+    if (JS_IsException(res)) {
+    fail:
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        return JS_EXCEPTION;
+    }
+    r = JS_GetBigDecimal(res);
     switch (magic) {
     case MATH_OP_ADD:
         ret = bfdec_add(r, a, b, fe->prec, fe->flags);
@@ -48382,6 +48640,9 @@ static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
     case MATH_OP_DIV:
         ret = bfdec_div(r, a, b, fe->prec, fe->flags);
         break;
+    case MATH_OP_FMOD:
+        ret = bfdec_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
+        break;
     case MATH_OP_SQRT:
         ret = bfdec_sqrt(r, a, fe->prec, fe->flags);
         break;
@@ -48398,16 +48659,119 @@ static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
     ret &= BF_ST_MEM_ERROR | BF_ST_DIVIDE_ZERO | BF_ST_INVALID_OP |
         BF_ST_OVERFLOW;
     if (ret != 0) {
-        bfdec_delete(r);
+        JS_FreeValue(ctx, res);
         return throw_bf_exception(ctx, ret);
     } else {
-        return JS_NewBigDecimal(ctx, r);
+        return res;
+    }
+}
+
+static JSValue js_bigdecimal_toFixed(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t f;
+    int rnd_mode;
+
+    val = js_thisBigDecimalValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_ToInt64Sat(ctx, &f, argv[0]))
+        goto fail;
+    if (f < 0 || f > BF_PREC_MAX) {
+        JS_ThrowRangeError(ctx, "invalid number of digits");
+        goto fail;
+    }
+    rnd_mode = BF_RNDNA;
+    if (argc > 1) {
+        rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+        if (rnd_mode < 0)
+            goto fail;
+    }
+    ret = js_bigdecimal_to_string1(ctx, val, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_bigdecimal_toExponential(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t f;
+    int rnd_mode;
+
+    val = js_thisBigDecimalValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_ToInt64Sat(ctx, &f, argv[0]))
+        goto fail;
+    if (JS_IsUndefined(argv[0])) {
+        ret = js_bigdecimal_to_string1(ctx, val, 0,
+                  BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
+    } else {
+        if (f < 0 || f > BF_PREC_MAX) {
+            JS_ThrowRangeError(ctx, "invalid number of digits");
+            goto fail;
+        }
+        rnd_mode = BF_RNDNA;
+        if (argc > 1) {
+            rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+            if (rnd_mode < 0)
+                goto fail;
+        }
+        ret = js_bigdecimal_to_string1(ctx, val, f + 1,
+                      rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
+    }
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_bigdecimal_toPrecision(JSContext *ctx, JSValueConst this_val,
+                                     int argc, JSValueConst *argv)
+{
+    JSValue val, ret;
+    int64_t p;
+    int rnd_mode;
+
+    val = js_thisBigDecimalValue(ctx, this_val);
+    if (JS_IsException(val))
+        return val;
+    if (JS_IsUndefined(argv[0])) {
+        return JS_ToStringFree(ctx, val);
+    }
+    if (JS_ToInt64Sat(ctx, &p, argv[0]))
+        goto fail;
+    if (p < 1 || p > BF_PREC_MAX) {
+        JS_ThrowRangeError(ctx, "invalid number of digits");
+        goto fail;
+    }
+    rnd_mode = BF_RNDNA;
+    if (argc > 1) {
+        rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
+        if (rnd_mode < 0)
+            goto fail;
     }
+    ret = js_bigdecimal_to_string1(ctx, val, p,
+                                   rnd_mode | BF_FTOA_FORMAT_FIXED);
+    JS_FreeValue(ctx, val);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
 }
 
 static const JSCFunctionListEntry js_bigdecimal_proto_funcs[] = {
     JS_CFUNC_DEF("toString", 0, js_bigdecimal_toString ),
     JS_CFUNC_DEF("valueOf", 0, js_bigdecimal_valueOf ),
+    JS_CFUNC_DEF("toPrecision", 1, js_bigdecimal_toPrecision ),
+    JS_CFUNC_DEF("toFixed", 1, js_bigdecimal_toFixed ),
+    JS_CFUNC_DEF("toExponential", 1, js_bigdecimal_toExponential ),
 };
 
 static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
@@ -48415,6 +48779,7 @@ static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
     JS_CFUNC_MAGIC_DEF("sub", 2, js_bigdecimal_fop, MATH_OP_SUB ),
     JS_CFUNC_MAGIC_DEF("mul", 2, js_bigdecimal_fop, MATH_OP_MUL ),
     JS_CFUNC_MAGIC_DEF("div", 2, js_bigdecimal_fop, MATH_OP_DIV ),
+    JS_CFUNC_MAGIC_DEF("mod", 2, js_bigdecimal_fop, MATH_OP_FMOD ),
     JS_CFUNC_MAGIC_DEF("round", 1, js_bigdecimal_fop, MATH_OP_ROUND ),
     JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigdecimal_fop, MATH_OP_SQRT ),
 };
@@ -49512,6 +49877,8 @@ static JSValue js_typed_array_copyWithin(JSContext *ctx, JSValueConst this_val,
     count = min_int(final - from, len - to);
     if (count > 0) {
         p = JS_VALUE_GET_OBJ(this_val);
+        if (typed_array_is_detached(ctx, p))
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
         shift = typed_array_size_log2(p->class_id);
         memmove(p->u.array.u.uint8_ptr + (to << shift),
                 p->u.array.u.uint8_ptr + (from << shift),
@@ -49579,6 +49946,9 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
             return JS_EXCEPTION;
     }
 
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    
     shift = typed_array_size_log2(p->class_id);
     switch(shift) {
     case 0:
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 8fcd7e5c7f..57eded89f8 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -53,7 +53,7 @@ typedef struct JSClass JSClass;
 typedef uint32_t JSClassID;
 typedef uint32_t JSAtom;
 
-#if defined(__x86_64__) || defined(__aarch64__)
+#if INTPTR_MAX >= INT64_MAX
 #define JS_PTR64
 #define JS_PTR64_DEF(a) a
 #else
@@ -366,7 +366,9 @@ void JS_AddIntrinsicPromise(JSContext *ctx);
 void JS_AddIntrinsicBigInt(JSContext *ctx);
 void JS_AddIntrinsicBigFloat(JSContext *ctx);
 void JS_AddIntrinsicBigDecimal(JSContext *ctx);
-/* enable "use bigint", "use math" and operator overloading */
+/* enable operator overloading */
+void JS_AddIntrinsicOperators(JSContext *ctx);
+/* enable "use math" */
 void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
 
 JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
@@ -531,12 +533,16 @@ static js_force_inline JSValue JS_NewFloat64(JSContext *ctx, double d)
     return v;
 }
 
-JS_BOOL JS_IsNumber(JSValueConst v);
+static inline JS_BOOL JS_IsNumber(JSValueConst v)
+{
+    int tag = JS_VALUE_GET_TAG(v);
+    return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);
+}
 
-static inline JS_BOOL JS_IsInteger(JSValueConst v)
+static inline JS_BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
 {
     int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_INT || tag == JS_TAG_BIG_INT;
+    return tag == JS_TAG_BIG_INT;
 }
 
 static inline JS_BOOL JS_IsBigFloat(JSValueConst v)

From c2e6eb5992698f13963c0298c332f9130f2d3fd8 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 30 Jan 2020 12:41:21 +0300
Subject: [PATCH 046/185] update github CI action

---
 .github/workflows/cxx.yml | 43 +++++++++++++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index aca66f8a39..c50ac915d8 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -7,23 +7,48 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest]
-        compiler: [native, second] # second - clang for linux, mingw gcc for win
+        compiler: [linux-gcc, linux-clang, linux-gcc8, linux-clang8, windows-gcc]
         include:
-          - os: ubuntu-latest
-            compiler: second
+          - compiler: linux-gcc
+            os: ubuntu-latest
+
+          - compiler: linux-clang
+            os: ubuntu-latest
             cmake_opts: -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
-          - os: windows-latest
-            compiler: second
+
+          - compiler: linux-gcc8
+            os: ubuntu-18.04
+            preconfigure: sudo apt-get install -y gcc-8 g++-8
+            cmake_opts: -DCMAKE_C_COMPILER=gcc-8 -DCMAKE_CXX_COMPILER=g++-8
+
+          - compiler: linux-clang8
+            os: ubuntu-18.04
+            preconfigure: sudo apt-get install -y clang-8
+            cmake_opts: -DCMAKE_C_COMPILER=clang-8 -DCMAKE_CXX_COMPILER=clang++-8
+
+          - compiler: windows-msvs
+            os: windows-latest
+
+          - compiler: windows-gcc
+            os: windows-2019
             cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
-        exclude: # msvs
-          - os: windows-latest
-            compiler: native
+
+          - compiler: windows-clang
+            os: windows-2019
+            preconfigure: choco install llvm 
+            cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+
     steps:
     - uses: actions/checkout@v1
+    - name: preconfigure
+      run: ${{ matrix.preconfigure }}
     - name: configure
       run: cmake . -Wdev ${{ matrix.cmake_opts }}
     - name: build
       run: cmake --build . # --verbose
     - name: test
       run: ctest --extra-verbose
+#    - uses: actions/upload-artifact@master
+#      with:
+#        name: main
+#        path: main

From 81e50365c6671d7910f6d3052275f2d948e3e100 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 30 Jan 2020 16:16:59 +0300
Subject: [PATCH 047/185] fromJSON, toJSON, vector fix

---
 quickjspp.hpp | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index ca4fc0889e..4aae5a8b9f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -874,6 +874,14 @@ class Value
         return *this;
     }
 
+    std::string toJSON(const Value& replacer = Value{nullptr, JS_UNDEFINED}, const Value& space = Value{nullptr, JS_UNDEFINED})
+    {
+        assert(ctx);
+        assert(!replacer.ctx || ctx == replacer.ctx);
+        assert(!space.ctx || ctx == space.ctx);
+        JSValue json = JS_JSONStringify(ctx, v, replacer.v, space.v);
+        return (std::string)Value{ctx, json};
+    }
 
 };
 
@@ -1165,6 +1173,13 @@ class Context
         return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, eval_flags);
     }
 
+    Value fromJSON(std::string_view buffer, const char * filename = "<fromJSON>")
+    {
+        assert(buffer.data()[buffer.size()] == '\0' && "fromJSON buffer is not null-terminated"); // JS_ParseJSON requirement
+        JSValue v = JS_ParseJSON(ctx, buffer.data(), buffer.size(), filename);
+        return Value{ctx, v};
+    }
+
     /** Get qjs::Context from JSContext opaque pointer */
     static Context& get(JSContext * ctx)
     {
@@ -1249,7 +1264,10 @@ struct js_traits<std::vector<T>>
 
     static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)
     {
-        if(!JS_IsArray(ctx, jsarr))
+        int e = JS_IsArray(ctx, jsarr);
+        if(e == 0)
+            JS_ThrowTypeError(ctx, "js_traits<std::vector<T>>::unwrap expects array");
+        if(e <= 0)
             throw exception{};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
         std::vector<T> arr;

From 68595062bd72fc73730f7841a3f5c941b914217c Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 31 Jan 2020 15:51:47 +0300
Subject: [PATCH 048/185] unwrap to const char *

---
 quickjspp.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 4aae5a8b9f..f3bc373ecf 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -185,6 +185,10 @@ class js_string : public std::string_view
 
     js_string(const js_string& other) = delete;
 
+    operator const char * () const {
+        return this->data();
+    }
+
     ~js_string()
     {
         if(ctx)
@@ -236,6 +240,10 @@ struct js_traits<const char *>
     {
         return JS_NewString(ctx, str);
     }
+    static detail::js_string unwrap(JSContext * ctx, JSValueConst v)
+    {
+        return js_traits<std::string_view>::unwrap(ctx, v);
+    }
 };
 
 

From 8936f4788eeef77f558457700369d3b7396d968f Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 3 Feb 2020 13:44:47 +0300
Subject: [PATCH 049/185] try to have stronger exception guarantees

---
 quickjspp.hpp | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f3bc373ecf..b2e503607d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -69,11 +69,12 @@ struct js_traits
     /** Create an object of C++ type R given JSValue v and JSContext.
      * This function is intentionally not implemented. User should implement this function for their own type.
      * @param v This value is passed as JSValueConst so it should be freed by the caller.
+     * @throws exception in case of conversion error
      */
     static R unwrap(JSContext * ctx, JSValueConst v);
     /** Create JSValue from an object of type R and JSContext.
      * This function is intentionally not implemented. User should implement this function for their own type.
-     * @return Returns JSValue which should be freed by the caller.
+     * @return Returns JSValue which should be freed by the caller or JS_EXCEPTION in case of error.
      */
     static JSValue wrap(JSContext * ctx, R value);
 };
@@ -499,12 +500,15 @@ struct js_traits<std::shared_ptr<T>>
 
     /** Create a JSValue from std::shared_ptr<T>.
      * Creates an object with class if #QJSClassId and sets its opaque pointer to a new copy of #ptr.
-     * @throws exception if class T is not registered or error on object creation
      */
     static JSValue wrap(JSContext * ctx, std::shared_ptr<T> ptr)
     {
         if(QJSClassId == 0) // not registered
-            throw exception{};
+        {
+            register_class(ctx, typeid(T).name());
+            //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
+            //return JS_EXCEPTION;
+        }
         auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
         if(JS_IsException(jsobj))
         {
@@ -537,7 +541,11 @@ struct js_traits<T *>
     static JSValue wrap(JSContext * ctx, T * ptr)
     {
         if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
-            throw exception{};
+        {
+            js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
+            //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
+            //return JS_EXCEPTION;
+        }
         auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
         if(JS_IsException(jsobj))
         {
@@ -1240,6 +1248,7 @@ struct js_traits<std::function<R(Args...)>>
     static JSValue wrap(JSContext * ctx, Functor&& functor)
     {
         using detail::function;
+        assert(js_traits<function>::QJSClassId);
         auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
         if(JS_IsException(obj))
             return JS_EXCEPTION;
@@ -1258,15 +1267,21 @@ struct js_traits<std::function<R(Args...)>>
 template <class T>
 struct js_traits<std::vector<T>>
 {
-    static JSValue wrap(JSContext * ctx, const std::vector<T>& arr)
+    static JSValue wrap(JSContext * ctx, const std::vector<T>& arr) noexcept
     {
         auto jsarray = Value{ctx, JS_NewArray(ctx)};
         if(JS_IsException(jsarray.v))
-            throw exception{};
-
-        for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
-            jsarray[i] = arr[i];
+            return jsarray.v;
 
+        try
+        {
+            for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
+                jsarray[i] = arr[i];
+        }
+        catch(exception)
+        {
+            return JS_EXCEPTION;
+        }
         return std::move(jsarray);
     }
 

From c5d89b8e329cce1e14c91556f0ec8c18242be1b9 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 7 Feb 2020 19:18:01 +0300
Subject: [PATCH 050/185] call JS_SetConstructor

---
 quickjspp.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index b2e503607d..d6624d8a4d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1070,7 +1070,9 @@ class Context
             {
                 if(!name)
                     name = this->name;
-                module.add(name, qjs::ctor_wrapper<T, Args...>{name});
+                Value ctor = context.newValue(qjs::ctor_wrapper<T, Args...>{name});
+                JS_SetConstructor(context.ctx, ctor.v, prototype.v);
+                module.add(name, std::move(ctor));
                 return *this;
             }
 

From efbb6186ad21687a23b386e8253300588edb0012 Mon Sep 17 00:00:00 2001
From: i404788 <50617709+i404788@users.noreply.github.com>
Date: Sat, 8 Feb 2020 01:47:07 +0000
Subject: [PATCH 051/185] Fix Operator overload

(and other prototype issues, see https://github.com/ldarren/QuickJS/blob/a4053a8fa13b0103fbf9c73c81429269411b9b69/examples/point.c#L60)
---
 quickjspp.hpp | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d6624d8a4d..6195d354a3 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -443,7 +443,34 @@ struct js_traits<ctor_wrapper<T, Args...>>
     {
         return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                         JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
+            
+            std::shared_ptr<T> ptr =  std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
+            
+            if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
+            {
+                js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
+                //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
+                //return JS_EXCEPTION;
+            }
+            
+            auto proto = JS_GetPropertyStr(ctx, this_value, "prototype");
+            if (JS_IsException(proto))
+                return proto;
+            auto jsobj = JS_NewObjectProtoClass(ctx, proto, js_traits<std::shared_ptr<T>>::QJSClassId);
+            JS_FreeValue(ctx, proto);
+            if (JS_IsException(jsobj))
+                return jsobj;
+                
+            //auto pptr = new std::shared_ptr<T>(std::move(ptr));
+            auto alloc = allocator<std::shared_ptr<T>>{ctx};
+            using atraits = std::allocator_traits<decltype(alloc)>;
+            auto pptr = atraits::allocate(alloc, 1);
+            atraits::construct(alloc, pptr, std::move(ptr));
+
+            JS_SetOpaque(jsobj, pptr);
+            return jsobj;
+            
+            // return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
         }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
     }
 };

From b43c1ddd554fc25bb732a7b3c08d1a9d18bf5888 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 7 Feb 2020 17:11:58 +0300
Subject: [PATCH 052/185] js traits for any integer type, added SFINAE template
 argument to js_traits

---
 quickjspp.hpp | 47 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 17 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 6195d354a3..1202aed07f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -61,9 +61,9 @@ struct allocator
 class exception {};
 
 /** Javascript conversion traits.
- * Describes how to convert type R to/from JSValue.
+ * Describes how to convert type R to/from JSValue. Second template argument can be used for SFINAE/enable_if type filters.
  */
-template <typename R>
+template <typename R, typename /*_SFINAE*/ = void>
 struct js_traits
 {
     /** Create an object of C++ type R given JSValue v and JSContext.
@@ -95,24 +95,37 @@ struct js_traits<JSValue>
     }
 };
 
-/** Conversion traits for int32.
+/** Conversion traits for integers.
  */
-template <>
-struct js_traits<int32_t>
+template <typename Int>
+struct js_traits<Int, std::enable_if_t<std::is_integral_v<Int> && sizeof(Int) <= sizeof(int64_t)>>
 {
 
     /// @throws exception
-    static int32_t unwrap(JSContext * ctx, JSValueConst v)
+    static Int unwrap(JSContext * ctx, JSValueConst v)
     {
-        int32_t r;
-        if(JS_ToInt32(ctx, &r, v))
-            throw exception{};
-        return r;
+        if constexpr (sizeof(Int) > sizeof(int32_t))
+        {
+            int64_t r;
+            if(JS_ToInt64(ctx, &r, v))
+                throw exception{};
+            return static_cast<Int>(r);
+        }
+        else
+        {
+            int32_t r;
+            if(JS_ToInt32(ctx, &r, v))
+                throw exception{};
+            return static_cast<Int>(r);
+        }
     }
 
-    static JSValue wrap(JSContext * ctx, int32_t i) noexcept
+    static JSValue wrap(JSContext * ctx, Int i) noexcept
     {
-        return JS_NewInt32(ctx, i);
+        if constexpr (std::is_same_v<Int, uint32_t> || sizeof(Int) > sizeof(int32_t))
+            return JS_NewInt64(ctx, static_cast<Int>(i));
+        else
+            return JS_NewInt32(ctx, static_cast<Int>(i));
     }
 };
 
@@ -443,16 +456,16 @@ struct js_traits<ctor_wrapper<T, Args...>>
     {
         return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                         JSValueConst * argv) noexcept -> JSValue {
-            
+
             std::shared_ptr<T> ptr =  std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
-            
+
             if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
             {
                 js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
                 //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
                 //return JS_EXCEPTION;
             }
-            
+
             auto proto = JS_GetPropertyStr(ctx, this_value, "prototype");
             if (JS_IsException(proto))
                 return proto;
@@ -460,7 +473,7 @@ struct js_traits<ctor_wrapper<T, Args...>>
             JS_FreeValue(ctx, proto);
             if (JS_IsException(jsobj))
                 return jsobj;
-                
+
             //auto pptr = new std::shared_ptr<T>(std::move(ptr));
             auto alloc = allocator<std::shared_ptr<T>>{ctx};
             using atraits = std::allocator_traits<decltype(alloc)>;
@@ -469,7 +482,7 @@ struct js_traits<ctor_wrapper<T, Args...>>
 
             JS_SetOpaque(jsobj, pptr);
             return jsobj;
-            
+
             // return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
         }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
     }

From d9121ee33798c0f8e73aaaf537e405437e8f417c Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 7 Feb 2020 17:12:39 +0300
Subject: [PATCH 053/185] add conversions test

---
 test/CMakeLists.txt  |  2 +-
 test/conversions.cpp | 64 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 1 deletion(-)
 create mode 100644 test/conversions.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 0555c50f83..406996e99c 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext
+        value class exception example multicontext conversions
         )
 make_test(${test})
 endforeach()
diff --git a/test/conversions.cpp b/test/conversions.cpp
new file mode 100644
index 0000000000..3ad82cca8b
--- /dev/null
+++ b/test/conversions.cpp
@@ -0,0 +1,64 @@
+#include "quickjspp.hpp"
+#include <iostream>
+#include <numeric>
+
+template <typename T>
+void test_conv(qjs::Context& context, T x)
+{
+    auto jsx = context.newValue(x);
+
+    auto x2 = static_cast<T>(jsx);
+
+    if(!(x2 == x))
+        throw std::exception();
+
+    if constexpr (std::is_integral_v<T> && !std::is_same_v<T, uint64_t>)
+    {
+        auto x3 = static_cast<int64_t>(jsx);
+        if(!(x3 == x))
+            throw std::exception();
+    }
+}
+
+template <typename T>
+void test_num(qjs::Context& context)
+{
+    test_conv(context, std::numeric_limits<T>::min()+1);
+    test_conv(context, std::numeric_limits<T>::max()-1);
+    test_conv(context, std::numeric_limits<T>::min());
+    test_conv(context, std::numeric_limits<T>::max());
+
+}
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    try
+    {
+        test_num<int16_t>(context);
+        test_num<int32_t>(context);
+        test_num<uint32_t>(context);
+
+        // int64 is represented as double...
+        test_conv<int64_t>(context, -(1ll << 52));
+        test_conv<int64_t>(context, -(1ll << 52) + 1);
+        test_conv<int64_t>(context, (1ll << 52));
+        test_conv<int64_t>(context, (1ll << 52) - 1);
+        test_conv<uint64_t>(context, (1ll << 52));
+        test_conv<uint64_t>(context, (1ll << 52) - 1);
+
+
+        test_num<double>(context);
+        //test_num<float>(context);
+
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}
\ No newline at end of file

From 8890bb620506889ea5a00d8ebeaa374d9c620db0 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 18 Feb 2020 12:14:33 +0300
Subject: [PATCH 054/185] add point class example

---
 test/CMakeLists.txt |  2 +-
 test/point.cpp      | 82 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 test/point.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 406996e99c..71edfc2131 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions
+        value class exception example multicontext conversions point
         )
 make_test(${test})
 endforeach()
diff --git a/test/point.cpp b/test/point.cpp
new file mode 100644
index 0000000000..e42a606e32
--- /dev/null
+++ b/test/point.cpp
@@ -0,0 +1,82 @@
+#include "quickjspp.hpp"
+#include <iostream>
+#include <cmath>
+
+class Point
+{
+public:
+    int x, y;
+    Point(int x, int y) : x(x), y(y) {}
+
+    double norm() const
+    {
+        return std::sqrt((double)x * x + double(y) * y);
+    }
+};
+
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    try
+    {
+        // export classes as a module
+        auto& module = context.addModule("MyModule");
+        module.class_<Point>("Point")
+                .constructor<int, int>()
+                .fun<&Point::x>("x")
+                .fun<&Point::y>("y")
+                .fun<&Point::norm>("norm");
+        // import module
+        context.eval(R"xxx(
+import { Point } from "MyModule";
+
+function assert(b, str)
+{
+    if (b) {
+        return;
+    } else {
+        throw Error("assertion failed: " + str);
+    }
+}
+
+class ColorPoint extends Point {
+    constructor(x, y, color) {
+        super(x, y);
+        this.color = color;
+    }
+    get_color() {
+        return this.color;
+    }
+};
+
+function main()
+{
+    var pt, pt2;
+
+    pt = new Point(2, 3);
+    assert(pt.x === 2);
+    assert(pt.y === 3);
+    pt.x = 4;
+    assert(pt.x === 4);
+    assert(pt.norm() == 5);
+
+    pt2 = new ColorPoint(2, 3, 0xffffff);
+    assert(pt2.x === 2);
+    assert(pt2.color === 0xffffff);
+    assert(pt2.get_color() === 0xffffff);
+}
+
+main();
+)xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}
\ No newline at end of file

From f2947b91715199162e6430cbb33afb1a0dc0be95 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 18 Feb 2020 12:20:32 +0300
Subject: [PATCH 055/185] update github workflows

---
 .github/workflows/cxx.yml        | 57 +++++++++++++++++++++-----------
 .github/workflows/doxygen.yml    | 17 +++++-----
 .github/workflows/quickjsdll.yml | 34 +++++++++++++++++++
 3 files changed, 80 insertions(+), 28 deletions(-)
 create mode 100644 .github/workflows/quickjsdll.yml

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index c50ac915d8..bddf1e08d0 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -1,13 +1,15 @@
 name: CMake C/C++ CI
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        compiler: [linux-gcc, linux-clang, linux-gcc8, linux-clang8, windows-gcc]
+        compiler: [linux-gcc, linux-clang, linux-gcc9, linux-clang9, windows-gcc, linux-gcc-ubsan, linux-gcc-asan, linux-gcc-32, linux-gcc-x32]
+        build_type: [Debug]
         include:
           - compiler: linux-gcc
             os: ubuntu-latest
@@ -16,15 +18,34 @@ jobs:
             os: ubuntu-latest
             cmake_opts: -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
 
-          - compiler: linux-gcc8
+          - compiler: linux-gcc9
             os: ubuntu-18.04
-            preconfigure: sudo apt-get install -y gcc-8 g++-8
-            cmake_opts: -DCMAKE_C_COMPILER=gcc-8 -DCMAKE_CXX_COMPILER=g++-8
+            preconfigure: sudo apt-get update && sudo apt-get install -y gcc-9 g++-9
+            cmake_opts: -DCMAKE_C_COMPILER=gcc-9 -DCMAKE_CXX_COMPILER=g++-9
 
-          - compiler: linux-clang8
+          - compiler: linux-gcc-ubsan
+            os: ubuntu-latest
+            cflags: -fsanitize=undefined
+
+          - compiler: linux-gcc-asan
+            os: ubuntu-latest
+            cflags: -fsanitize=address -fsanitize-address-use-after-scope
+
+          - compiler: linux-gcc-32
+            os: ubuntu-latest
+            preconfigure: sudo apt-get update && sudo apt-get install gcc-multilib g++-multilib
+            cflags: -m32
+            
+          - compiler: linux-gcc-x32
+            os: ubuntu-latest
+            preconfigure: sudo apt-get update && sudo apt-get install gcc-multilib g++-multilib
+            cflags: -mx32
+
+          - compiler: linux-clang9
             os: ubuntu-18.04
-            preconfigure: sudo apt-get install -y clang-8
-            cmake_opts: -DCMAKE_C_COMPILER=clang-8 -DCMAKE_CXX_COMPILER=clang++-8
+            preconfigure: sudo apt-get update && sudo apt-get install -y clang-9 libc++-9-dev libc++abi-9-dev
+            cmake_opts: -DCMAKE_C_COMPILER=clang-9 -DCMAKE_CXX_COMPILER=clang++-9
+            #cflags: -stdlib=libc++
 
           - compiler: windows-msvs
             os: windows-latest
@@ -33,22 +54,20 @@ jobs:
             os: windows-2019
             cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
 
-          - compiler: windows-clang
-            os: windows-2019
-            preconfigure: choco install llvm 
-            cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+          - compiler: macos-clang
+            os: macos-latest
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: preconfigure
       run: ${{ matrix.preconfigure }}
     - name: configure
-      run: cmake . -Wdev ${{ matrix.cmake_opts }}
+      run: cmake -S . -B build_dir -Wdev -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_C_FLAGS="${{ matrix.cflags }}" -DCMAKE_CXX_FLAGS="${{ matrix.cflags }}" -DCMAKE_EXE_LINKER_FLAGS="${{ matrix.cflags }}" ${{ matrix.cmake_opts }}
     - name: build
-      run: cmake --build . # --verbose
+      run: cmake --build build_dir --verbose
     - name: test
       run: ctest --extra-verbose
-#    - uses: actions/upload-artifact@master
-#      with:
-#        name: main
-#        path: main
+      working-directory: build_dir
+      env:
+        # extra options for address sanitizer
+        ASAN_OPTIONS: strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1
\ No newline at end of file
diff --git a/.github/workflows/doxygen.yml b/.github/workflows/doxygen.yml
index 03de2e5c9c..e89f8dc13c 100644
--- a/.github/workflows/doxygen.yml
+++ b/.github/workflows/doxygen.yml
@@ -1,4 +1,4 @@
-name: Doxygen gh-pages
+name: Doxygen
 on:
   push:
     branches:
@@ -8,16 +8,15 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: Doxygen install
       run: sudo apt-get install -y doxygen graphviz 
     - name: Doxygen
       run: doxygen
-    - name: Deploy to gh-pages
-      uses: peaceiris/actions-gh-pages@v2.3.2
-      env:
-        PERSONAL_TOKEN: ${{ secrets.TOKEN }}
-        PUBLISH_BRANCH: gh-pages
-        PUBLISH_DIR: ./html
+    - name: Deploy
+      uses: peaceiris/actions-gh-pages@v3
       with:
-        emptyCommits: false
+        personal_token: ${{ secrets.TOKEN }}
+        publish_dir: ./html
+        publish_branch: gh-pages
+        force_orphan: true
\ No newline at end of file
diff --git a/.github/workflows/quickjsdll.yml b/.github/workflows/quickjsdll.yml
new file mode 100644
index 0000000000..cf4fc6fc66
--- /dev/null
+++ b/.github/workflows/quickjsdll.yml
@@ -0,0 +1,34 @@
+name: QuickJS MinGW DLL build
+
+on: 
+  push:
+    paths:
+      - 'quickjs/**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        cflags: [ "-flto -O2", "-flto -Os", "-flto -O3" ]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: install mingw
+      run: sudo apt-get update ; sudo apt-get install -y mingw-w64
+    - name: build dlls
+      run: |
+        mkdir -p bin
+        # generate def file
+        gcc -shared  quickjs/*.c -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -D_GNU_SOURCE=1 -fPIC -o libquickjs.so
+        # export only symbols with "js" in them
+        echo 'EXPORTS' > bin/libquickjs.def
+        nm  -D --defined-only -f posix libquickjs.so | grep -i js | awk '{print $1}' >> bin/libquickjs.def
+        i686-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -o bin/libquickjs32.dll  -Wl,--out-implib,bin/libquickjs32.a -pthread -s ${{ matrix.cflags }}
+        x86_64-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -o bin/libquickjs64.dll  -Wl,--out-implib,bin/libquickjs64.a -pthread -s ${{ matrix.cflags }}
+      shell: bash
+    - uses: actions/upload-artifact@v1
+      with:
+        name: dlls ${{matrix.cflags}}
+        path: bin
\ No newline at end of file

From df0549c4e768b8ee966839c6d1e5346d39873f1a Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Wed, 1 Apr 2020 14:02:49 +0300
Subject: [PATCH 056/185] updated quickjs to 2020-03-16

---
 quickjs/VERSION            |    2 +-
 quickjs/libbf.c            |   47 +-
 quickjs/libbf.h            |    1 +
 quickjs/libregexp.c        |   92 +-
 quickjs/libunicode-table.h | 3183 ++++++++++++++++++------------------
 quickjs/quickjs-libc.c     |  388 +++--
 quickjs/quickjs-opcode.h   |    1 -
 quickjs/quickjs.c          |  204 ++-
 quickjs/quickjs.h          |   28 +-
 9 files changed, 2094 insertions(+), 1852 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index ceac556894..81b7bb9c01 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-01-19
+2020-03-16
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 829d8031c1..14aff8f7fd 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -2526,19 +2526,18 @@ int bf_set_float64(bf_t *a, double d)
     return BF_ST_MEM_ERROR;
 }
 
-/* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
+/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
    is an overflow and 0 otherwise. */
 int bf_get_int32(int *pres, const bf_t *a, int flags)
 {
     uint32_t v;
     int ret;
     if (a->expn >= BF_EXP_INF) {
-        ret = 0;
+        ret = BF_ST_INVALID_OP;
         if (flags & BF_GET_INT_MOD) {
             v = 0;
         } else if (a->expn == BF_EXP_INF) {
             v = (uint32_t)INT32_MAX + a->sign;
-            /* XXX: return overflow ? */
         } else {
             v = INT32_MAX;
         }
@@ -2551,7 +2550,7 @@ int bf_get_int32(int *pres, const bf_t *a, int flags)
             v = -v;
         ret = 0;
     } else if (!(flags & BF_GET_INT_MOD)) {
-        ret = BF_ST_OVERFLOW;
+        ret = BF_ST_INVALID_OP;
         if (a->sign) {
             v = (uint32_t)INT32_MAX + 1;
             if (a->expn == 32 && 
@@ -2571,14 +2570,14 @@ int bf_get_int32(int *pres, const bf_t *a, int flags)
     return ret;
 }
 
-/* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
+/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
    is an overflow and 0 otherwise. */
 int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
 {
     uint64_t v;
     int ret;
     if (a->expn >= BF_EXP_INF) {
-        ret = 0;
+        ret = BF_ST_INVALID_OP;
         if (flags & BF_GET_INT_MOD) {
             v = 0;
         } else if (a->expn == BF_EXP_INF) {
@@ -2603,7 +2602,7 @@ int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
             v = -v;
         ret = 0;
     } else if (!(flags & BF_GET_INT_MOD)) {
-        ret = BF_ST_OVERFLOW;
+        ret = BF_ST_INVALID_OP;
         if (a->sign) {
             uint64_t v1;
             v = (uint64_t)INT64_MAX + 1;
@@ -2632,6 +2631,40 @@ int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
     return ret;
 }
 
+/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
+   is an overflow and 0 otherwise. */
+int bf_get_uint64(uint64_t *pres, const bf_t *a)
+{
+    uint64_t v;
+    int ret;
+    if (a->expn == BF_EXP_NAN) {
+        goto overflow;
+    } else if (a->expn <= 0) {
+        v = 0;
+        ret = 0;
+    } else if (a->sign) {
+        v = 0;
+        ret = BF_ST_INVALID_OP;
+    } else if (a->expn <= 64) {
+#if LIMB_BITS == 32
+        if (a->expn <= 32)
+            v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
+        else
+            v = (((uint64_t)a->tab[a->len - 1] << 32) |
+                 get_limbz(a, a->len - 2)) >> (64 - a->expn);
+#else
+        v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
+#endif
+        ret = 0;
+    } else {
+    overflow:
+        v = UINT64_MAX;
+        ret = BF_ST_INVALID_OP;
+    }
+    *pres = v;
+    return ret;
+}
+
 /* base conversion from radix */
 
 static const uint8_t digits_per_limb_table[BF_RADIX_MAX - 1] = {
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index 60439dcac1..6749b35c69 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -376,6 +376,7 @@ char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
 #define BF_GET_INT_MOD (1 << 0) 
 int bf_get_int32(int *pres, const bf_t *a, int flags);
 int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
+int bf_get_uint64(uint64_t *pres, const bf_t *a);
 
 /* the following functions are exported for testing only. */
 void mp_print_str(const char *str, const limb_t *tab, limb_t n);
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index 4425ce55b8..7f6eef42a8 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -434,8 +434,9 @@ static int __attribute__((format(printf, 2, 3))) re_parse_error(REParseState *s,
     return -1;
 }
 
-/* Return -1 in case of overflow */
-static int parse_digits(const uint8_t **pp)
+/* If allow_overflow is false, return -1 in case of
+   overflow. Otherwise return INT32_MAX. */
+static int parse_digits(const uint8_t **pp, BOOL allow_overflow)
 {
     const uint8_t *p;
     uint64_t v;
@@ -448,8 +449,12 @@ static int parse_digits(const uint8_t **pp)
         if (c < '0' || c > '9')
             break;
         v = v * 10 + c - '0';
-        if (v >= INT32_MAX)
-            return -1;
+        if (v >= INT32_MAX) {
+            if (allow_overflow)
+                v = INT32_MAX;
+            else
+                return -1;
+        }
         p++;
     }
     *pp = p;
@@ -1225,14 +1230,27 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             re_emit_op(s, REOP_prev);
         break;
     case '{':
-        /* As an extension (see ES6 annex B), we accept '{' not
-           followed by digits as a normal atom */
-        if (!is_digit(p[1])) {
-            if (s->is_utf16)
-                goto invalid_quant_count;
+        if (s->is_utf16) {
+            return re_parse_error(s, "syntax error");
+        } else if (!is_digit(p[1])) {
+            /* Annex B: we accept '{' not followed by digits as a
+               normal atom */
             goto parse_class_atom;
+        } else {
+            const uint8_t *p1 = p + 1;
+            /* Annex B: error if it is like a repetition count */
+            parse_digits(&p1, TRUE);
+            if (*p1 == ',') {
+                p1++;
+                if (is_digit(*p1)) {
+                    parse_digits(&p1, TRUE);
+                }
+            }
+            if (*p1 != '}') {
+                goto parse_class_atom;
+            }
         }
-        /* fall tru */
+        /* fall thru */
     case '*':
     case '+':
     case '?':
@@ -1387,7 +1405,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             {
                 const uint8_t *q = ++p;
                 
-                c = parse_digits(&p);
+                c = parse_digits(&p, FALSE);
                 if (c < 0 || (c >= s->capture_count && c >= re_count_captures(s))) {
                     if (!s->is_utf16) {
                         /* Annex B.1.4: accept legacy octal */
@@ -1484,32 +1502,38 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             quant_max = 1;
             goto quantifier;
         case '{':
-            /* As an extension (see ES6 annex B), we accept '{' not
-               followed by digits as a normal atom */
-            if (!is_digit(p[1])) {
-                if (s->is_utf16)
-                    goto invalid_quant_count;
-                break;
-            }
-            p++;
-            quant_min = parse_digits(&p);
-            if (quant_min < 0) {
-            invalid_quant_count:
-                return re_parse_error(s, "invalid repetition count");
-            }
-            quant_max = quant_min;
-            if (*p == ',') {
-                p++;
-                if (is_digit(*p)) {
-                    quant_max = parse_digits(&p);
-                    if (quant_max < 0 || quant_max < quant_min)
+            {
+                const uint8_t *p1 = p;
+                /* As an extension (see ES6 annex B), we accept '{' not
+                   followed by digits as a normal atom */
+                if (!is_digit(p[1])) {
+                    if (s->is_utf16)
                         goto invalid_quant_count;
-                } else {
-                    quant_max = INT32_MAX; /* infinity */
+                    break;
+                }
+                p++;
+                quant_min = parse_digits(&p, TRUE);
+                quant_max = quant_min;
+                if (*p == ',') {
+                    p++;
+                    if (is_digit(*p)) {
+                        quant_max = parse_digits(&p, TRUE);
+                        if (quant_max < quant_min) {
+                        invalid_quant_count:
+                            return re_parse_error(s, "invalid repetition count");
+                        }
+                    } else {
+                        quant_max = INT32_MAX; /* infinity */
+                    }
                 }
+                if (*p != '}' && !s->is_utf16) {
+                    /* Annex B: normal atom if invalid '{' syntax */
+                    p = p1;
+                    break;
+                }
+                if (re_parse_expect(s, &p, '}'))
+                    return -1;
             }
-            if (re_parse_expect(s, &p, '}'))
-                return -1;
         quantifier:
             greedy = TRUE;
             if (*p == '?') {
diff --git a/quickjs/libunicode-table.h b/quickjs/libunicode-table.h
index 521f2f3190..0ef2113560 100644
--- a/quickjs/libunicode-table.h
+++ b/quickjs/libunicode-table.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-static const uint32_t case_conv_table1[359] = {
+static const uint32_t case_conv_table1[361] = {
     0x00209a30, 0x00309a00, 0x005a8173, 0x00601730,
     0x006c0730, 0x006f81b3, 0x00701700, 0x007c0700,
     0x007f8100, 0x00803040, 0x009801c3, 0x00988190,
@@ -86,17 +86,18 @@ static const uint32_t case_conv_table1[359] = {
     0x53cb1440, 0x53d50130, 0x53d58130, 0x53d60130,
     0x53d68130, 0x53d70130, 0x53d80130, 0x53d88130,
     0x53d90130, 0x53d98131, 0x53da0c40, 0x53e10240,
-    0x53e20131, 0x53e28130, 0x53e30130, 0x55a98101,
-    0x55b85020, 0x7d8001b2, 0x7d8081b2, 0x7d8101b2,
-    0x7d8181da, 0x7d8201da, 0x7d8281b3, 0x7d8301b3,
-    0x7d8981bb, 0x7d8a01bb, 0x7d8a81bb, 0x7d8b01bc,
-    0x7d8b81bb, 0x7f909a31, 0x7fa09a01, 0x82002831,
-    0x82142801, 0x82582431, 0x826c2401, 0x86403331,
-    0x86603301, 0x8c502031, 0x8c602001, 0xb7202031,
-    0xb7302001, 0xf4802231, 0xf4912201,
+    0x53e20131, 0x53e28130, 0x53e30130, 0x53e38440,
+    0x53fa8240, 0x55a98101, 0x55b85020, 0x7d8001b2,
+    0x7d8081b2, 0x7d8101b2, 0x7d8181da, 0x7d8201da,
+    0x7d8281b3, 0x7d8301b3, 0x7d8981bb, 0x7d8a01bb,
+    0x7d8a81bb, 0x7d8b01bc, 0x7d8b81bb, 0x7f909a31,
+    0x7fa09a01, 0x82002831, 0x82142801, 0x82582431,
+    0x826c2401, 0x86403331, 0x86603301, 0x8c502031,
+    0x8c602001, 0xb7202031, 0xb7302001, 0xf4802231,
+    0xf4912201,
 };
 
-static const uint8_t case_conv_table2[359] = {
+static const uint8_t case_conv_table2[361] = {
     0x01, 0x00, 0x9c, 0x06, 0x07, 0x4d, 0x03, 0x04,
     0x10, 0x00, 0x8f, 0x0b, 0x00, 0x00, 0x11, 0x00,
     0x08, 0x00, 0x53, 0x4a, 0x51, 0x00, 0x52, 0x00,
@@ -118,7 +119,7 @@ static const uint8_t case_conv_table2[359] = {
     0x33, 0x95, 0x00, 0x8e, 0x00, 0x74, 0x99, 0x98,
     0x97, 0x96, 0x00, 0x00, 0x9e, 0x00, 0x9c, 0x00,
     0xa1, 0xa0, 0x15, 0x2e, 0x2f, 0x30, 0xb4, 0xb5,
-    0x4c, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
+    0x4e, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
     0x22, 0x2a, 0x34, 0x35, 0xa6, 0xa7, 0x36, 0x1f,
     0x4a, 0x00, 0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d,
     0x36, 0x05, 0x00, 0xc4, 0xc3, 0xc6, 0xc5, 0xc8,
@@ -137,11 +138,12 @@ static const uint8_t case_conv_table2[359] = {
     0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0xa3, 0xa4,
     0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0x00,
     0x00, 0x5a, 0x00, 0x48, 0x00, 0x5b, 0x56, 0x58,
-    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4b, 0x00, 0x00,
-    0x3b, 0x67, 0xb8, 0x45, 0xa8, 0x8a, 0x8b, 0x8c,
-    0xab, 0xac, 0x58, 0x58, 0xaf, 0x94, 0xb0, 0x6f,
-    0xb2, 0x5a, 0x59, 0x5c, 0x5b, 0x5e, 0x5d, 0x60,
-    0x5f, 0x62, 0x61, 0x64, 0x63, 0x66, 0x65,
+    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4d, 0x00, 0x00,
+    0x3b, 0x67, 0xb8, 0x00, 0x00, 0x45, 0xa8, 0x8a,
+    0x8b, 0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf, 0x94,
+    0xb0, 0x6f, 0xb2, 0x5c, 0x5b, 0x5e, 0x5d, 0x60,
+    0x5f, 0x62, 0x61, 0x64, 0x63, 0x66, 0x65, 0x68,
+    0x67,
 };
 
 static const uint16_t case_conv_ext[58] = {
@@ -170,7 +172,7 @@ static const uint8_t unicode_prop_Cased1_table[172] = {
     0x26, 0x01, 0x01, 0x86, 0xe5, 0x80, 0x60, 0x79,
     0xb6, 0x81, 0x40, 0x91, 0x81, 0xbd, 0x88, 0x94,
     0x05, 0x80, 0x98, 0x80, 0xc7, 0x82, 0x43, 0x34,
-    0xa2, 0x06, 0x80, 0x8b, 0x61, 0x28, 0x97, 0xd4,
+    0xa2, 0x06, 0x80, 0x8c, 0x61, 0x28, 0x96, 0xd4,
     0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b,
     0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80,
     0x9b, 0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53,
@@ -186,107 +188,109 @@ static const uint8_t unicode_prop_Cased1_index[18] = {
     0xf1, 0x01,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_table[678] = {
+static const uint8_t unicode_prop_Case_Ignorable_table[692] = {
     0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80,
     0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
     0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40,
-    0xfa, 0x86, 0x40, 0xce, 0x80, 0xb6, 0xac, 0x00,
-    0x01, 0x01, 0x00, 0xab, 0x80, 0x8a, 0x85, 0x89,
-    0x8a, 0x00, 0xa2, 0x80, 0x89, 0x94, 0x8f, 0x80,
-    0xe4, 0x38, 0x89, 0x03, 0xa0, 0x00, 0x80, 0x9d,
-    0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0x18, 0x08, 0x97,
-    0x97, 0xaa, 0x82, 0xf6, 0xaf, 0xb6, 0x00, 0x03,
-    0x3b, 0x02, 0x86, 0x89, 0x81, 0x8c, 0x80, 0x8e,
-    0x80, 0xb9, 0x03, 0x1f, 0x80, 0x93, 0x81, 0x99,
-    0x01, 0x81, 0xb8, 0x03, 0x0b, 0x09, 0x12, 0x80,
-    0x9d, 0x0a, 0x80, 0x8a, 0x81, 0xb8, 0x03, 0x20,
-    0x0b, 0x80, 0x93, 0x81, 0x95, 0x28, 0x80, 0xb9,
-    0x01, 0x00, 0x1f, 0x07, 0x80, 0x8a, 0x81, 0x9d,
-    0x80, 0xbc, 0x80, 0x8b, 0x80, 0xb1, 0x02, 0x80,
-    0xb8, 0x14, 0x10, 0x1e, 0x81, 0x8a, 0x81, 0x9c,
-    0x80, 0xb9, 0x01, 0x05, 0x04, 0x81, 0x93, 0x81,
-    0x9b, 0x81, 0xb8, 0x0b, 0x1f, 0x80, 0x93, 0x81,
-    0xe5, 0x06, 0x10, 0x80, 0xd9, 0x01, 0x86, 0x8a,
-    0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x85, 0xc9,
-    0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d, 0x04,
-    0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe5,
-    0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82, 0x8f,
-    0x83, 0x8c, 0x01, 0x0d, 0x80, 0x8e, 0x80, 0xdd,
-    0x80, 0x42, 0x5f, 0x82, 0x43, 0xb1, 0x82, 0x9c,
-    0x82, 0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x08, 0x37,
-    0x01, 0x8a, 0x10, 0x20, 0xac, 0x83, 0xb3, 0x80,
-    0xc0, 0x81, 0xa1, 0x80, 0xf5, 0x13, 0x81, 0x88,
-    0x05, 0x82, 0x40, 0xda, 0x09, 0x80, 0xb9, 0x00,
-    0x30, 0x00, 0x01, 0x3d, 0x89, 0x08, 0xa6, 0x07,
-    0x8e, 0xc0, 0x83, 0xaf, 0x00, 0x20, 0x04, 0x80,
-    0xa7, 0x88, 0x8b, 0x81, 0x9f, 0x19, 0x08, 0x82,
-    0xb7, 0x00, 0x0a, 0x00, 0x82, 0xb9, 0x39, 0x81,
-    0xbf, 0x85, 0xd1, 0x10, 0x8c, 0x06, 0x18, 0x28,
-    0x11, 0xb1, 0xbe, 0x8c, 0x80, 0xa1, 0xde, 0x04,
-    0x41, 0xbc, 0x00, 0x82, 0x8a, 0x82, 0x8c, 0x82,
-    0x8c, 0x82, 0x8c, 0x81, 0x8b, 0x27, 0x81, 0x89,
-    0x01, 0x01, 0x84, 0xb0, 0x20, 0x89, 0x00, 0x8c,
-    0x80, 0x8f, 0x8c, 0xb2, 0xa0, 0x4b, 0x8a, 0x81,
-    0xf0, 0x82, 0xfc, 0x80, 0x8e, 0x80, 0xdf, 0x9f,
-    0xae, 0x80, 0x41, 0xd4, 0x80, 0xa3, 0x1a, 0x24,
-    0x80, 0xdc, 0x85, 0xdc, 0x82, 0x60, 0x6f, 0x15,
-    0x80, 0x44, 0xe1, 0x85, 0x41, 0x0d, 0x80, 0xe1,
-    0x18, 0x89, 0x00, 0x9b, 0x83, 0xcf, 0x81, 0x8d,
-    0xa1, 0xcd, 0x80, 0x96, 0x82, 0xec, 0x0f, 0x02,
-    0x03, 0x80, 0x98, 0x81, 0x40, 0x9c, 0x81, 0x99,
-    0x91, 0x8c, 0x80, 0xa5, 0x87, 0x98, 0x8a, 0xad,
-    0x82, 0xaf, 0x01, 0x19, 0x81, 0x90, 0x80, 0x94,
-    0x81, 0xc1, 0x29, 0x09, 0x81, 0x8b, 0x07, 0x80,
-    0xa2, 0x80, 0x8a, 0x80, 0xb2, 0x00, 0x11, 0x0c,
-    0x08, 0x80, 0x9a, 0x80, 0x8d, 0x0c, 0x08, 0x80,
-    0xe3, 0x84, 0x40, 0x84, 0x01, 0x03, 0x80, 0x60,
-    0x4f, 0x2f, 0x80, 0x40, 0x92, 0x8f, 0x42, 0x3d,
-    0x8f, 0x10, 0x8b, 0x8f, 0xa1, 0x01, 0x80, 0x40,
-    0xa8, 0x06, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00,
-    0x80, 0xae, 0x80, 0xac, 0x81, 0xc2, 0x80, 0x94,
-    0x82, 0x42, 0x00, 0x80, 0x40, 0xe1, 0x80, 0x40,
-    0x94, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0xa7,
-    0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x83,
-    0x42, 0x1d, 0x8a, 0x40, 0xaf, 0x80, 0xb5, 0x8e,
+    0xfa, 0x86, 0x40, 0xce, 0x04, 0x80, 0xb0, 0xac,
+    0x00, 0x01, 0x01, 0x00, 0xab, 0x80, 0x8a, 0x85,
+    0x89, 0x8a, 0x00, 0xa2, 0x80, 0x89, 0x94, 0x8f,
+    0x80, 0xe4, 0x38, 0x89, 0x03, 0xa0, 0x00, 0x80,
+    0x9d, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0x18, 0x08,
+    0x97, 0x97, 0xaa, 0x82, 0xf6, 0xaf, 0xb6, 0x00,
+    0x03, 0x3b, 0x02, 0x86, 0x89, 0x81, 0x8c, 0x80,
+    0x8e, 0x80, 0xb9, 0x03, 0x1f, 0x80, 0x93, 0x81,
+    0x99, 0x01, 0x81, 0xb8, 0x03, 0x0b, 0x09, 0x12,
+    0x80, 0x9d, 0x0a, 0x80, 0x8a, 0x81, 0xb8, 0x03,
+    0x20, 0x0b, 0x80, 0x93, 0x81, 0x95, 0x28, 0x80,
+    0xb9, 0x01, 0x00, 0x1f, 0x06, 0x81, 0x8a, 0x81,
+    0x9d, 0x80, 0xbc, 0x80, 0x8b, 0x80, 0xb1, 0x02,
+    0x80, 0xb8, 0x14, 0x10, 0x1e, 0x81, 0x8a, 0x81,
+    0x9c, 0x80, 0xb9, 0x01, 0x05, 0x04, 0x81, 0x93,
+    0x81, 0x9b, 0x81, 0xb8, 0x0b, 0x1f, 0x80, 0x93,
+    0x81, 0x9c, 0x80, 0xc7, 0x06, 0x10, 0x80, 0xd9,
+    0x01, 0x86, 0x8a, 0x88, 0xe1, 0x01, 0x88, 0x88,
+    0x00, 0x85, 0xc9, 0x81, 0x9a, 0x00, 0x00, 0x80,
+    0xb6, 0x8d, 0x04, 0x01, 0x84, 0x8a, 0x80, 0xa3,
+    0x88, 0x80, 0xe5, 0x18, 0x28, 0x09, 0x81, 0x98,
+    0x0b, 0x82, 0x8f, 0x83, 0x8c, 0x01, 0x0d, 0x80,
+    0x8e, 0x80, 0xdd, 0x80, 0x42, 0x5f, 0x82, 0x43,
+    0xb1, 0x82, 0x9c, 0x82, 0x9c, 0x81, 0x9d, 0x81,
+    0xbf, 0x08, 0x37, 0x01, 0x8a, 0x10, 0x20, 0xac,
+    0x83, 0xb3, 0x80, 0xc0, 0x81, 0xa1, 0x80, 0xf5,
+    0x13, 0x81, 0x88, 0x05, 0x82, 0x40, 0xda, 0x09,
+    0x80, 0xb9, 0x00, 0x30, 0x00, 0x01, 0x3d, 0x89,
+    0x08, 0xa6, 0x07, 0x90, 0xbe, 0x83, 0xaf, 0x00,
+    0x20, 0x04, 0x80, 0xa7, 0x88, 0x8b, 0x81, 0x9f,
+    0x19, 0x08, 0x82, 0xb7, 0x00, 0x0a, 0x00, 0x82,
+    0xb9, 0x39, 0x81, 0xbf, 0x85, 0xd1, 0x10, 0x8c,
+    0x06, 0x18, 0x28, 0x11, 0xb1, 0xbe, 0x8c, 0x80,
+    0xa1, 0xde, 0x04, 0x41, 0xbc, 0x00, 0x82, 0x8a,
+    0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81, 0x8b,
+    0x27, 0x81, 0x89, 0x01, 0x01, 0x84, 0xb0, 0x20,
+    0x89, 0x00, 0x8c, 0x80, 0x8f, 0x8c, 0xb2, 0xa0,
+    0x4b, 0x8a, 0x81, 0xf0, 0x82, 0xfc, 0x80, 0x8e,
+    0x80, 0xdf, 0x9f, 0xae, 0x80, 0x41, 0xd4, 0x80,
+    0xa3, 0x1a, 0x24, 0x80, 0xdc, 0x85, 0xdc, 0x82,
+    0x60, 0x6f, 0x15, 0x80, 0x44, 0xe1, 0x85, 0x41,
+    0x0d, 0x80, 0xe1, 0x18, 0x89, 0x00, 0x9b, 0x83,
+    0xcf, 0x81, 0x8d, 0xa1, 0xcd, 0x80, 0x96, 0x82,
+    0xec, 0x0f, 0x02, 0x03, 0x80, 0x98, 0x0c, 0x80,
+    0x40, 0x96, 0x81, 0x99, 0x91, 0x8c, 0x80, 0xa5,
+    0x87, 0x98, 0x8a, 0xad, 0x82, 0xaf, 0x01, 0x19,
+    0x81, 0x90, 0x80, 0x94, 0x81, 0xc1, 0x29, 0x09,
+    0x81, 0x8b, 0x07, 0x80, 0xa2, 0x80, 0x8a, 0x80,
+    0xb2, 0x00, 0x11, 0x0c, 0x08, 0x80, 0x9a, 0x80,
+    0x8d, 0x0c, 0x08, 0x80, 0xe3, 0x84, 0x88, 0x82,
+    0xf8, 0x01, 0x03, 0x80, 0x60, 0x4f, 0x2f, 0x80,
+    0x40, 0x92, 0x8f, 0x42, 0x3d, 0x8f, 0x10, 0x8b,
+    0x8f, 0xa1, 0x01, 0x80, 0x40, 0xa8, 0x06, 0x05,
+    0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80, 0xae, 0x80,
+    0xac, 0x81, 0xc2, 0x80, 0x94, 0x82, 0x42, 0x00,
+    0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x46,
+    0x85, 0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40,
+    0xa4, 0x81, 0x42, 0x3c, 0x83, 0x41, 0x82, 0x81,
+    0x40, 0x98, 0x8a, 0x40, 0xaf, 0x80, 0xb5, 0x8e,
     0xb7, 0x82, 0xb0, 0x19, 0x09, 0x80, 0x8e, 0x80,
     0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b,
-    0x81, 0xb3, 0x88, 0x89, 0x83, 0xe1, 0x11, 0x00,
-    0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94, 0x81,
-    0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0x40, 0xc2,
-    0x39, 0x10, 0x80, 0x96, 0x80, 0xd3, 0x28, 0x03,
-    0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81, 0x9a,
-    0x81, 0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00, 0x01,
-    0x28, 0x80, 0xe4, 0x11, 0x18, 0x84, 0x41, 0x02,
-    0x88, 0x01, 0x41, 0x98, 0x19, 0x0b, 0x80, 0x9f,
-    0x89, 0xa7, 0x29, 0x1f, 0x80, 0x88, 0x29, 0x82,
-    0xad, 0x8c, 0x01, 0x41, 0x95, 0x30, 0x28, 0x80,
-    0xd1, 0x95, 0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00,
-    0x08, 0x30, 0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41,
-    0x5a, 0x81, 0x55, 0x3a, 0x88, 0x60, 0x36, 0xb6,
-    0x84, 0xba, 0x86, 0x88, 0x83, 0x44, 0x0a, 0x80,
-    0xbe, 0x90, 0xbf, 0x08, 0x80, 0x60, 0x4c, 0xb8,
-    0x08, 0x83, 0x54, 0xc2, 0x82, 0x88, 0x8f, 0x0e,
-    0x9d, 0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6,
-    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
-    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x41,
-    0x04, 0x8d, 0x41, 0xad, 0x83, 0x45, 0xdf, 0x86,
-    0xec, 0x87, 0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00,
-    0x80, 0x9d, 0xdf, 0xff, 0x40, 0xef,
+    0x81, 0xb3, 0x88, 0x89, 0x19, 0x80, 0xde, 0x11,
+    0x00, 0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94,
+    0x81, 0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0x40,
+    0xc2, 0x39, 0x10, 0x80, 0x96, 0x80, 0xd3, 0x28,
+    0x03, 0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81,
+    0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00,
+    0x01, 0x28, 0x80, 0xe4, 0x11, 0x18, 0x84, 0x41,
+    0x02, 0x88, 0x01, 0x40, 0xff, 0x08, 0x03, 0x80,
+    0x40, 0x8f, 0x19, 0x0b, 0x80, 0x9f, 0x89, 0xa7,
+    0x29, 0x1f, 0x80, 0x88, 0x29, 0x82, 0xad, 0x8c,
+    0x01, 0x41, 0x95, 0x30, 0x28, 0x80, 0xd1, 0x95,
+    0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00, 0x08, 0x30,
+    0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41, 0x5a, 0x81,
+    0x55, 0x3a, 0x88, 0x60, 0x36, 0xb6, 0x84, 0xba,
+    0x86, 0x88, 0x83, 0x44, 0x0a, 0x80, 0xbe, 0x90,
+    0xbf, 0x08, 0x81, 0x60, 0x4c, 0xb7, 0x08, 0x83,
+    0x54, 0xc2, 0x82, 0x88, 0x8f, 0x0e, 0x9d, 0x83,
+    0x40, 0x93, 0x82, 0x47, 0xba, 0xb6, 0x83, 0xb1,
+    0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f,
+    0x30, 0x90, 0x0e, 0x01, 0x04, 0x41, 0x04, 0x8d,
+    0x41, 0xad, 0x83, 0x45, 0xdf, 0x86, 0xec, 0x87,
+    0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00, 0x80, 0x9d,
+    0xdf, 0xff, 0x40, 0xef,
 };
 
 static const uint8_t unicode_prop_Case_Ignorable_index[66] = {
-    0xc0, 0x05, 0x00, 0x2e, 0x08, 0x20, 0x52, 0x0a,
-    0x00, 0x05, 0x0c, 0x00, 0x4f, 0x0e, 0x20, 0x75,
-    0x10, 0x20, 0x44, 0x18, 0x00, 0x43, 0x1b, 0x00,
-    0x00, 0x1e, 0x00, 0x7e, 0x2c, 0x00, 0x7e, 0xa6,
-    0x40, 0x83, 0xa9, 0x20, 0xf7, 0xaa, 0x00, 0x41,
-    0xff, 0x20, 0x28, 0x0d, 0x01, 0x3f, 0x12, 0x41,
-    0xde, 0x15, 0x21, 0x5c, 0x1a, 0x01, 0xf5, 0x6a,
-    0x21, 0x37, 0xda, 0x01, 0x02, 0x00, 0x2e, 0xf0,
+    0xbe, 0x05, 0x00, 0xfe, 0x07, 0x00, 0x52, 0x0a,
+    0x20, 0x05, 0x0c, 0x20, 0x3b, 0x0e, 0x40, 0x61,
+    0x10, 0x40, 0x0f, 0x18, 0x20, 0x43, 0x1b, 0x60,
+    0x79, 0x1d, 0x00, 0xf1, 0x20, 0x00, 0x0d, 0xa6,
+    0x40, 0x2e, 0xa9, 0x20, 0xde, 0xaa, 0x00, 0x0f,
+    0xff, 0x20, 0xe7, 0x0a, 0x41, 0x82, 0x11, 0x21,
+    0xc4, 0x14, 0x61, 0x44, 0x19, 0x01, 0x48, 0x1d,
+    0x21, 0xa4, 0xbc, 0x01, 0x3e, 0xe1, 0x01, 0xf0,
     0x01, 0x0e,
 };
 
-static const uint8_t unicode_prop_ID_Start_table[1024] = {
+static const uint8_t unicode_prop_ID_Start_table[1045] = {
     0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03,
     0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
     0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20,
@@ -297,142 +301,146 @@ static const uint8_t unicode_prop_ID_Start_table[1024] = {
     0x89, 0x11, 0x80, 0x8f, 0x00, 0x9d, 0x9c, 0xd8,
     0x8a, 0x80, 0x97, 0xa0, 0x88, 0x0b, 0x04, 0x95,
     0x18, 0x88, 0x02, 0x80, 0x96, 0x98, 0x86, 0x8a,
-    0xb4, 0x94, 0x07, 0xc5, 0xb5, 0x10, 0x91, 0x06,
-    0x89, 0x8e, 0x8f, 0x1f, 0x09, 0x81, 0x95, 0x06,
-    0x00, 0x13, 0x10, 0x8f, 0x80, 0x8c, 0x08, 0x82,
-    0x8d, 0x81, 0x89, 0x07, 0x2b, 0x09, 0x95, 0x06,
-    0x01, 0x01, 0x01, 0x9e, 0x18, 0x80, 0x92, 0x82,
-    0x8f, 0x88, 0x02, 0x80, 0x95, 0x06, 0x01, 0x04,
-    0x10, 0x91, 0x80, 0x8e, 0x81, 0x96, 0x80, 0x8a,
-    0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10, 0x9d,
-    0x08, 0x82, 0x8e, 0x80, 0x90, 0x00, 0x2a, 0x10,
-    0x1a, 0x08, 0x00, 0x0a, 0x0a, 0x12, 0x8b, 0x95,
-    0x80, 0xb3, 0x38, 0x10, 0x96, 0x80, 0x8f, 0x10,
-    0x99, 0x14, 0x81, 0x9d, 0x03, 0x38, 0x10, 0x96,
-    0x80, 0x89, 0x04, 0x10, 0x9f, 0x00, 0x81, 0x8e,
-    0x81, 0x91, 0x38, 0x10, 0xa8, 0x08, 0x8f, 0x04,
-    0x17, 0x82, 0x97, 0x2c, 0x91, 0x82, 0x97, 0x80,
-    0x88, 0x00, 0x0e, 0xb9, 0xaf, 0x01, 0x8b, 0x86,
-    0xb9, 0x08, 0x00, 0x20, 0x97, 0x00, 0x80, 0x89,
-    0x01, 0x88, 0x01, 0x20, 0x80, 0x94, 0x83, 0x9f,
-    0x80, 0xbe, 0x38, 0xa3, 0x9a, 0x84, 0xf2, 0xaa,
-    0x93, 0x80, 0x8f, 0x2b, 0x1a, 0x02, 0x0e, 0x13,
-    0x8c, 0x8b, 0x80, 0x90, 0xa5, 0x00, 0x20, 0x81,
-    0xaa, 0x80, 0x41, 0x4c, 0x03, 0x0e, 0x00, 0x03,
-    0x81, 0xa8, 0x03, 0x81, 0xa0, 0x03, 0x0e, 0x00,
-    0x03, 0x81, 0x8e, 0x80, 0xb8, 0x03, 0x81, 0xc2,
-    0xa4, 0x8f, 0x8f, 0xd5, 0x0d, 0x82, 0x42, 0x6b,
-    0x81, 0x90, 0x80, 0x99, 0x84, 0xca, 0x82, 0x8a,
-    0x86, 0x8c, 0x03, 0x8d, 0x91, 0x8d, 0x91, 0x8d,
-    0x8c, 0x02, 0x8e, 0xb3, 0xa2, 0x03, 0x80, 0xc2,
-    0xd8, 0x86, 0xa8, 0x00, 0x84, 0xc5, 0x89, 0x9e,
-    0xb0, 0x9d, 0x0c, 0x8a, 0xab, 0x83, 0x99, 0xb5,
-    0x96, 0x88, 0xb4, 0xd1, 0x80, 0xdc, 0xae, 0x90,
-    0x86, 0xb6, 0x9d, 0x8c, 0x81, 0x89, 0xab, 0x99,
-    0xa3, 0xa8, 0x82, 0x89, 0xa3, 0x81, 0x88, 0x86,
-    0xaa, 0x0a, 0xa8, 0x18, 0x28, 0x0a, 0x04, 0x40,
-    0xbf, 0xbf, 0x41, 0x15, 0x0d, 0x81, 0xa5, 0x0d,
-    0x0f, 0x00, 0x00, 0x00, 0x80, 0x9e, 0x81, 0xb4,
-    0x06, 0x00, 0x12, 0x06, 0x13, 0x0d, 0x83, 0x8c,
-    0x22, 0x06, 0xf3, 0x80, 0x8c, 0x80, 0x8f, 0x8c,
-    0xe4, 0x03, 0x01, 0x89, 0x00, 0x0d, 0x28, 0x00,
-    0x00, 0x80, 0x8f, 0x0b, 0x24, 0x18, 0x90, 0xa8,
-    0x4a, 0x76, 0xae, 0x80, 0xae, 0x80, 0x40, 0x84,
-    0x2b, 0x11, 0x8b, 0xa5, 0x00, 0x20, 0x81, 0xb7,
-    0x30, 0x8f, 0x96, 0x88, 0x30, 0x30, 0x30, 0x30,
-    0x30, 0x30, 0x30, 0x86, 0x42, 0x25, 0x82, 0x98,
-    0x88, 0x34, 0x0c, 0x83, 0xd5, 0x1c, 0x80, 0xd9,
-    0x03, 0x84, 0xaa, 0x80, 0xdd, 0x90, 0x9a, 0xb4,
-    0x8f, 0x41, 0xff, 0x59, 0xb5, 0xc9, 0x60, 0x51,
-    0xef, 0x8f, 0x44, 0x8c, 0xc2, 0xad, 0x81, 0x41,
-    0x0c, 0x82, 0x8f, 0x89, 0x81, 0x93, 0xae, 0x8f,
-    0x9e, 0x81, 0xcf, 0xa6, 0x88, 0x81, 0xe6, 0x81,
-    0xb4, 0x0c, 0xaf, 0x8a, 0x02, 0x03, 0x80, 0x96,
-    0x9c, 0xb3, 0x8d, 0xb1, 0xbd, 0x2a, 0x00, 0x81,
-    0x8a, 0x9b, 0x89, 0x96, 0x98, 0x9c, 0x86, 0xae,
-    0x9b, 0x80, 0x8f, 0x20, 0x89, 0x89, 0x20, 0xa8,
-    0x96, 0x10, 0x87, 0x93, 0x96, 0x10, 0x82, 0xb1,
-    0x00, 0x11, 0x0c, 0x08, 0x00, 0x97, 0x11, 0x8a,
-    0x32, 0x8b, 0x29, 0x29, 0x85, 0x88, 0x30, 0x30,
-    0xaa, 0x80, 0x8b, 0x87, 0xf2, 0x9c, 0x60, 0x2b,
-    0xa3, 0x8b, 0x96, 0x83, 0xb0, 0x60, 0x21, 0x03,
-    0x41, 0x6d, 0x81, 0xe9, 0xa5, 0x86, 0x8b, 0x24,
-    0x00, 0x89, 0x80, 0x8c, 0x04, 0x00, 0x01, 0x01,
-    0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81,
-    0xb5, 0xa7, 0x8b, 0xf3, 0x20, 0x40, 0x86, 0xa3,
-    0x99, 0x85, 0x99, 0x8a, 0xd8, 0x15, 0x0d, 0x0d,
-    0x0a, 0xa2, 0x8b, 0x80, 0x99, 0x80, 0x92, 0x01,
-    0x80, 0x8e, 0x81, 0x8d, 0xa1, 0xfa, 0xc4, 0xb4,
-    0x41, 0x0a, 0x9c, 0x82, 0xb0, 0xae, 0x9f, 0x8c,
-    0x9d, 0x84, 0xa5, 0x89, 0x9d, 0x81, 0xa3, 0x1f,
-    0x04, 0xa9, 0x40, 0x9d, 0x91, 0xa3, 0x83, 0xa3,
-    0x83, 0xa7, 0x87, 0xb3, 0x40, 0x9b, 0x41, 0x36,
-    0x88, 0x95, 0x89, 0x87, 0x40, 0x97, 0x29, 0x00,
-    0xab, 0x01, 0x10, 0x81, 0x96, 0x89, 0x96, 0x88,
-    0x9e, 0xc0, 0x92, 0x01, 0x89, 0x95, 0x89, 0x99,
-    0xc5, 0xb7, 0x29, 0xbf, 0x80, 0x8e, 0x18, 0x10,
-    0x9c, 0xa9, 0x9c, 0x82, 0x9c, 0xa2, 0x38, 0x9b,
-    0x9a, 0xb5, 0x89, 0x95, 0x89, 0x92, 0x8c, 0x91,
-    0xed, 0xc8, 0xb6, 0xb2, 0x8c, 0xb2, 0x8c, 0xa3,
-    0x41, 0xdb, 0x9c, 0x89, 0x07, 0x95, 0x40, 0x99,
-    0x96, 0x8b, 0xb4, 0xca, 0xac, 0x9f, 0x98, 0x99,
-    0xa3, 0x9c, 0x80, 0x8a, 0xa2, 0x10, 0x8b, 0xaf,
-    0x8d, 0x83, 0x94, 0x00, 0x80, 0xa2, 0x91, 0x80,
-    0x98, 0xd3, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89,
-    0x86, 0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01,
-    0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d,
-    0xb4, 0x91, 0x83, 0x93, 0x80, 0x9f, 0xaf, 0x93,
-    0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3,
-    0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6,
-    0x9a, 0x40, 0xe4, 0xab, 0xf3, 0xbf, 0x9e, 0x80,
-    0x40, 0x9f, 0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b,
-    0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad,
-    0x92, 0x80, 0xa1, 0xb8, 0x41, 0x06, 0x88, 0x80,
-    0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08,
-    0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d,
-    0x80, 0x41, 0x46, 0x92, 0x41, 0x0c, 0x43, 0x99,
-    0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0xbb, 0x44,
-    0x2e, 0x4f, 0xd0, 0x42, 0x46, 0x60, 0x21, 0xb8,
-    0x42, 0x38, 0x86, 0x9e, 0xf0, 0x9d, 0x91, 0xaf,
-    0x8f, 0x83, 0x9e, 0x94, 0x84, 0x92, 0x42, 0xaf,
-    0xbf, 0xff, 0xca, 0x20, 0xc1, 0x8c, 0xbf, 0x08,
-    0x80, 0x9b, 0x57, 0xf7, 0x87, 0x42, 0xf2, 0x60,
-    0x25, 0x0c, 0x41, 0x1e, 0xb0, 0x82, 0x90, 0x1f,
-    0x41, 0x8b, 0x49, 0x03, 0xea, 0x84, 0x8c, 0x82,
-    0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80, 0xc6,
-    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
-    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
-    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x98,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x07, 0x49, 0x33, 0xac, 0x89, 0x86,
-    0x8f, 0x80, 0x41, 0x70, 0xab, 0x45, 0x13, 0x40,
-    0xc4, 0xba, 0xc3, 0x30, 0x44, 0xb3, 0x18, 0x9a,
-    0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00,
-    0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06,
-    0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22,
-    0x04, 0x80, 0x90, 0x51, 0x43, 0x60, 0xa6, 0xd6,
-    0xa8, 0x50, 0x34, 0x8a, 0x40, 0xdd, 0x81, 0x56,
-    0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d,
+    0xb4, 0x94, 0x80, 0x91, 0xbb, 0xb5, 0x10, 0x91,
+    0x06, 0x89, 0x8e, 0x8f, 0x1f, 0x09, 0x81, 0x95,
+    0x06, 0x00, 0x13, 0x10, 0x8f, 0x80, 0x8c, 0x08,
+    0x82, 0x8d, 0x81, 0x89, 0x07, 0x2b, 0x09, 0x95,
+    0x06, 0x01, 0x01, 0x01, 0x9e, 0x18, 0x80, 0x92,
+    0x82, 0x8f, 0x88, 0x02, 0x80, 0x95, 0x06, 0x01,
+    0x04, 0x10, 0x91, 0x80, 0x8e, 0x81, 0x96, 0x80,
+    0x8a, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10,
+    0x9d, 0x08, 0x82, 0x8e, 0x80, 0x90, 0x00, 0x2a,
+    0x10, 0x1a, 0x08, 0x00, 0x0a, 0x0a, 0x12, 0x8b,
+    0x95, 0x80, 0xb3, 0x38, 0x10, 0x96, 0x80, 0x8f,
+    0x10, 0x99, 0x14, 0x81, 0x9d, 0x03, 0x38, 0x10,
+    0x96, 0x80, 0x89, 0x04, 0x10, 0x9f, 0x00, 0x81,
+    0x8e, 0x81, 0x90, 0x88, 0x02, 0x80, 0xa8, 0x08,
+    0x8f, 0x04, 0x17, 0x82, 0x97, 0x2c, 0x91, 0x82,
+    0x97, 0x80, 0x88, 0x00, 0x0e, 0xb9, 0xaf, 0x01,
+    0x8b, 0x86, 0xb9, 0x08, 0x00, 0x20, 0x97, 0x00,
+    0x80, 0x89, 0x01, 0x88, 0x01, 0x20, 0x80, 0x94,
+    0x83, 0x9f, 0x80, 0xbe, 0x38, 0xa3, 0x9a, 0x84,
+    0xf2, 0xaa, 0x93, 0x80, 0x8f, 0x2b, 0x1a, 0x02,
+    0x0e, 0x13, 0x8c, 0x8b, 0x80, 0x90, 0xa5, 0x00,
+    0x20, 0x81, 0xaa, 0x80, 0x41, 0x4c, 0x03, 0x0e,
+    0x00, 0x03, 0x81, 0xa8, 0x03, 0x81, 0xa0, 0x03,
+    0x0e, 0x00, 0x03, 0x81, 0x8e, 0x80, 0xb8, 0x03,
+    0x81, 0xc2, 0xa4, 0x8f, 0x8f, 0xd5, 0x0d, 0x82,
+    0x42, 0x6b, 0x81, 0x90, 0x80, 0x99, 0x84, 0xca,
+    0x82, 0x8a, 0x86, 0x8c, 0x03, 0x8d, 0x91, 0x8d,
+    0x91, 0x8d, 0x8c, 0x02, 0x8e, 0xb3, 0xa2, 0x03,
+    0x80, 0xc2, 0xd8, 0x86, 0xa8, 0x00, 0x84, 0xc5,
+    0x89, 0x9e, 0xb0, 0x9d, 0x0c, 0x8a, 0xab, 0x83,
+    0x99, 0xb5, 0x96, 0x88, 0xb4, 0xd1, 0x80, 0xdc,
+    0xae, 0x90, 0x86, 0xb6, 0x9d, 0x8c, 0x81, 0x89,
+    0xab, 0x99, 0xa3, 0xa8, 0x82, 0x89, 0xa3, 0x81,
+    0x88, 0x86, 0xaa, 0x0a, 0xa8, 0x18, 0x28, 0x0a,
+    0x04, 0x40, 0xbf, 0xbf, 0x41, 0x15, 0x0d, 0x81,
+    0xa5, 0x0d, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x9e,
+    0x81, 0xb4, 0x06, 0x00, 0x12, 0x06, 0x13, 0x0d,
+    0x83, 0x8c, 0x22, 0x06, 0xf3, 0x80, 0x8c, 0x80,
+    0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x0d,
+    0x28, 0x00, 0x00, 0x80, 0x8f, 0x0b, 0x24, 0x18,
+    0x90, 0xa8, 0x4a, 0x76, 0xae, 0x80, 0xae, 0x80,
+    0x40, 0x84, 0x2b, 0x11, 0x8b, 0xa5, 0x00, 0x20,
+    0x81, 0xb7, 0x30, 0x8f, 0x96, 0x88, 0x30, 0x30,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x86, 0x42, 0x25,
+    0x82, 0x98, 0x88, 0x34, 0x0c, 0x83, 0xd5, 0x1c,
+    0x80, 0xd9, 0x03, 0x84, 0xaa, 0x80, 0xdd, 0x90,
+    0x9f, 0xaf, 0x8f, 0x41, 0xff, 0x59, 0xbf, 0xbf,
+    0x60, 0x51, 0xfc, 0x82, 0x44, 0x8c, 0xc2, 0xad,
+    0x81, 0x41, 0x0c, 0x82, 0x8f, 0x89, 0x81, 0x93,
+    0xae, 0x8f, 0x9e, 0x81, 0xcf, 0xa6, 0x88, 0x81,
+    0xe6, 0x81, 0xb4, 0x81, 0x88, 0xa9, 0x8c, 0x02,
+    0x03, 0x80, 0x96, 0x9c, 0xb3, 0x8d, 0xb1, 0xbd,
+    0x2a, 0x00, 0x81, 0x8a, 0x9b, 0x89, 0x96, 0x98,
+    0x9c, 0x86, 0xae, 0x9b, 0x80, 0x8f, 0x20, 0x89,
+    0x89, 0x20, 0xa8, 0x96, 0x10, 0x87, 0x93, 0x96,
+    0x10, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x00,
+    0x97, 0x11, 0x8a, 0x32, 0x8b, 0x29, 0x29, 0x85,
+    0x88, 0x30, 0x30, 0xaa, 0x80, 0x8d, 0x85, 0xf2,
+    0x9c, 0x60, 0x2b, 0xa3, 0x8b, 0x96, 0x83, 0xb0,
+    0x60, 0x21, 0x03, 0x41, 0x6d, 0x81, 0xe9, 0xa5,
+    0x86, 0x8b, 0x24, 0x00, 0x89, 0x80, 0x8c, 0x04,
+    0x00, 0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a,
+    0x91, 0xbf, 0x81, 0xb5, 0xa7, 0x8b, 0xf3, 0x20,
+    0x40, 0x86, 0xa3, 0x99, 0x85, 0x99, 0x8a, 0xd8,
+    0x15, 0x0d, 0x0d, 0x0a, 0xa2, 0x8b, 0x80, 0x99,
+    0x80, 0x92, 0x01, 0x80, 0x8e, 0x81, 0x8d, 0xa1,
+    0xfa, 0xc4, 0xb4, 0x41, 0x0a, 0x9c, 0x82, 0xb0,
+    0xae, 0x9f, 0x8c, 0x9d, 0x84, 0xa5, 0x89, 0x9d,
+    0x81, 0xa3, 0x1f, 0x04, 0xa9, 0x40, 0x9d, 0x91,
+    0xa3, 0x83, 0xa3, 0x83, 0xa7, 0x87, 0xb3, 0x40,
+    0x9b, 0x41, 0x36, 0x88, 0x95, 0x89, 0x87, 0x40,
+    0x97, 0x29, 0x00, 0xab, 0x01, 0x10, 0x81, 0x96,
+    0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92, 0x01, 0x89,
+    0x95, 0x89, 0x99, 0xc5, 0xb7, 0x29, 0xbf, 0x80,
+    0x8e, 0x18, 0x10, 0x9c, 0xa9, 0x9c, 0x82, 0x9c,
+    0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89, 0x95, 0x89,
+    0x92, 0x8c, 0x91, 0xed, 0xc8, 0xb6, 0xb2, 0x8c,
+    0xb2, 0x8c, 0xa3, 0x41, 0x5b, 0xa9, 0x29, 0xcd,
+    0x9c, 0x89, 0x07, 0x95, 0xe9, 0x94, 0x9a, 0x96,
+    0x8b, 0xb4, 0xca, 0xac, 0x9f, 0x98, 0x99, 0xa3,
+    0x9c, 0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d,
+    0x83, 0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98,
+    0xd3, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89, 0x86,
+    0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04,
+    0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d, 0xb4,
+    0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93, 0x08,
+    0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3, 0xaf,
+    0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6, 0x9a,
+    0x40, 0xe4, 0xab, 0xf3, 0xbf, 0x9e, 0x39, 0x01,
+    0x38, 0x08, 0x97, 0x8e, 0x00, 0x80, 0xdd, 0x39,
+    0xa6, 0x8f, 0x00, 0x80, 0x9b, 0x80, 0x89, 0xa7,
+    0x30, 0x94, 0x80, 0x8a, 0xad, 0x92, 0x80, 0xa1,
+    0xb8, 0x41, 0x06, 0x88, 0x80, 0xa4, 0x90, 0x80,
+    0xb0, 0x9d, 0xef, 0x30, 0x08, 0xa5, 0x94, 0x80,
+    0x98, 0x28, 0x08, 0x9f, 0x8d, 0x80, 0x41, 0x46,
+    0x92, 0x40, 0xbc, 0x80, 0xce, 0x43, 0x99, 0xe5,
+    0xee, 0x90, 0x40, 0xc3, 0x4a, 0xbb, 0x44, 0x2e,
+    0x4f, 0xd0, 0x42, 0x46, 0x60, 0x21, 0xb8, 0x42,
+    0x38, 0x86, 0x9e, 0xf0, 0x9d, 0x91, 0xaf, 0x8f,
+    0x83, 0x9e, 0x94, 0x84, 0x92, 0x42, 0xaf, 0xbf,
+    0xff, 0xca, 0x20, 0xc1, 0x8c, 0xbf, 0x08, 0x80,
+    0x9b, 0x57, 0xf7, 0x87, 0x44, 0xd5, 0xa9, 0x88,
+    0x60, 0x22, 0xf6, 0x41, 0x1e, 0xb0, 0x82, 0x90,
+    0x1f, 0x41, 0x8b, 0x49, 0x03, 0xea, 0x84, 0x8c,
+    0x82, 0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80,
+    0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00,
+    0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b,
+    0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81,
+    0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
+    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
+    0x9e, 0x80, 0x98, 0x07, 0x49, 0x33, 0xac, 0x89,
+    0x86, 0x8f, 0x80, 0x41, 0x70, 0xab, 0x45, 0x13,
+    0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44, 0xb3, 0x18,
+    0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00,
+    0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b,
+    0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90,
+    0x22, 0x04, 0x80, 0x90, 0x51, 0x43, 0x60, 0xa6,
+    0xdd, 0xa1, 0x50, 0x34, 0x8a, 0x40, 0xdd, 0x81,
+    0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e, 0x42,
+    0x1d, 0x45, 0xe1, 0x53, 0x4a,
 };
 
-static const uint8_t unicode_prop_ID_Start_index[96] = {
-    0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xb1, 0x09,
-    0x00, 0xba, 0x0a, 0x00, 0xd1, 0x0b, 0x20, 0x62,
-    0x0d, 0x40, 0x01, 0x0f, 0x20, 0x5e, 0x12, 0x00,
-    0xf9, 0x16, 0x00, 0x17, 0x1a, 0x20, 0xc0, 0x1d,
-    0x20, 0x9d, 0x20, 0x00, 0x68, 0x2d, 0x00, 0x00,
-    0x32, 0x20, 0xc0, 0xa7, 0x20, 0x29, 0xaa, 0x00,
-    0xa4, 0xd7, 0x20, 0xc8, 0xfd, 0x20, 0x75, 0x01,
-    0x01, 0x37, 0x07, 0x01, 0x36, 0x0a, 0x21, 0xf7,
-    0x0f, 0x21, 0xa9, 0x12, 0x01, 0x30, 0x16, 0x21,
-    0x8a, 0x1a, 0x01, 0x9a, 0x23, 0x01, 0x80, 0x6e,
-    0x21, 0x89, 0xbc, 0x21, 0xc1, 0xd6, 0x01, 0xc5,
-    0xe8, 0x21, 0x73, 0xee, 0x01, 0x1e, 0xfa, 0x02,
+static const uint8_t unicode_prop_ID_Start_index[99] = {
+    0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xa9, 0x09,
+    0x00, 0xb4, 0x0a, 0x00, 0xba, 0x0b, 0x00, 0x3e,
+    0x0d, 0x00, 0xe0, 0x0e, 0x20, 0x57, 0x12, 0x00,
+    0xeb, 0x16, 0x00, 0xca, 0x19, 0x20, 0xc0, 0x1d,
+    0x60, 0x80, 0x20, 0x00, 0x2e, 0x2d, 0x00, 0xc0,
+    0x31, 0x20, 0x89, 0xa7, 0x20, 0xf0, 0xa9, 0x00,
+    0xe3, 0xab, 0x00, 0x3e, 0xfd, 0x00, 0xfb, 0x00,
+    0x21, 0x37, 0x07, 0x61, 0x01, 0x0a, 0x01, 0x1d,
+    0x0f, 0x21, 0x2c, 0x12, 0x01, 0xc8, 0x14, 0x21,
+    0xd1, 0x19, 0x21, 0x47, 0x1d, 0x01, 0x39, 0x6a,
+    0x21, 0x09, 0x8d, 0x01, 0xbc, 0xd4, 0x01, 0xa9,
+    0xd7, 0x21, 0x3a, 0xee, 0x01, 0xde, 0xa6, 0x22,
+    0x4b, 0x13, 0x03,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_table[607] = {
+static const uint8_t unicode_prop_ID_Continue1_table[626] = {
     0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47,
     0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
     0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf,
@@ -445,14 +453,14 @@ static const uint8_t unicode_prop_ID_Continue1_table[607] = {
     0x09, 0x89, 0x8d, 0x01, 0x82, 0xb7, 0x00, 0x23,
     0x09, 0x12, 0x80, 0x93, 0x8b, 0x10, 0x8a, 0x82,
     0xb7, 0x00, 0x38, 0x10, 0x82, 0x93, 0x09, 0x89,
-    0x89, 0x28, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x17,
-    0x81, 0x89, 0x09, 0x89, 0x91, 0x80, 0xba, 0x22,
+    0x89, 0x28, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x16,
+    0x82, 0x89, 0x09, 0x89, 0x91, 0x80, 0xba, 0x22,
     0x10, 0x83, 0x88, 0x80, 0x8d, 0x89, 0x8f, 0x84,
     0xb8, 0x30, 0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89,
     0x90, 0x82, 0xb7, 0x00, 0x30, 0x10, 0x1e, 0x81,
     0x8a, 0x09, 0x89, 0x8f, 0x83, 0xb6, 0x08, 0x30,
-    0x10, 0x83, 0x88, 0x80, 0x89, 0x09, 0x89, 0x91,
-    0x81, 0xc5, 0x03, 0x28, 0x00, 0x3d, 0x89, 0x09,
+    0x10, 0x83, 0x88, 0x80, 0x89, 0x09, 0x89, 0x90,
+    0x82, 0xc5, 0x03, 0x28, 0x00, 0x3d, 0x89, 0x09,
     0xbc, 0x01, 0x86, 0x8b, 0x38, 0x89, 0xd6, 0x01,
     0x88, 0x8a, 0x29, 0x89, 0xbd, 0x0d, 0x89, 0x8a,
     0x00, 0x00, 0x03, 0x81, 0xb0, 0x93, 0x01, 0x84,
@@ -464,67 +472,70 @@ static const uint8_t unicode_prop_ID_Continue1_table[607] = {
     0x89, 0x40, 0x8e, 0x80, 0xf5, 0x8b, 0x83, 0x8b,
     0x89, 0x89, 0xff, 0x8a, 0xbb, 0x84, 0xb8, 0x89,
     0x80, 0x9c, 0x81, 0x8a, 0x85, 0x89, 0x95, 0x8d,
-    0xc1, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90, 0x88,
-    0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab, 0x8d,
-    0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5, 0x10,
-    0x94, 0x18, 0x28, 0x0a, 0x40, 0xc5, 0xb9, 0x04,
-    0x42, 0x3e, 0x81, 0x92, 0x80, 0xfa, 0x8c, 0x18,
-    0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c, 0x80,
-    0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81, 0x60,
-    0x75, 0x84, 0x89, 0xc4, 0x03, 0x89, 0x9f, 0x81,
-    0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80, 0x96,
-    0x84, 0xd7, 0x81, 0xb1, 0x91, 0x89, 0x89, 0x85,
-    0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98, 0x8c, 0xab,
-    0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a, 0x80, 0x89,
-    0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09, 0x89, 0xa0,
-    0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x80, 0xa8,
-    0x24, 0x81, 0x40, 0xeb, 0x38, 0x09, 0x89, 0x60,
-    0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f, 0x8f, 0x8f,
-    0x11, 0x97, 0x82, 0x40, 0xbf, 0x89, 0xa4, 0x80,
-    0x42, 0xbc, 0x80, 0x40, 0xe1, 0x80, 0x40, 0x94,
-    0x84, 0x41, 0x24, 0x89, 0x45, 0x56, 0x10, 0x0c,
-    0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4, 0x81, 0x42,
-    0x3c, 0x1f, 0x89, 0x42, 0x0b, 0x8a, 0x40, 0xae,
-    0x82, 0xb4, 0x8e, 0x9e, 0x89, 0x8e, 0x83, 0xac,
-    0x8a, 0xb4, 0x89, 0x2a, 0xa3, 0x8d, 0x80, 0x89,
-    0x21, 0xab, 0x80, 0x8b, 0x82, 0xaf, 0x8d, 0x3b,
-    0x82, 0x89, 0xd1, 0x8b, 0x28, 0x40, 0x9f, 0x8b,
-    0x84, 0x89, 0x2b, 0xb6, 0x08, 0x31, 0x09, 0x82,
-    0x88, 0x80, 0x89, 0x09, 0x32, 0x84, 0x40, 0xbf,
-    0x91, 0x88, 0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89,
-    0x40, 0xd4, 0x31, 0x88, 0x9a, 0x81, 0xd1, 0x90,
-    0x8e, 0x89, 0xd0, 0x8c, 0x87, 0x89, 0xd2, 0x8e,
-    0x83, 0x89, 0x40, 0xf1, 0x8e, 0x40, 0xa4, 0x89,
-    0x40, 0xe6, 0x31, 0x32, 0x80, 0x9b, 0x89, 0xa7,
-    0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad, 0x8f, 0x41,
-    0x94, 0x38, 0x87, 0x8f, 0x89, 0xb7, 0x95, 0x80,
-    0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x07, 0x89,
-    0xaf, 0x20, 0x08, 0x27, 0x89, 0x41, 0x48, 0x83,
-    0x60, 0x4b, 0x68, 0x89, 0x40, 0x85, 0x84, 0xba,
-    0x86, 0x98, 0x89, 0x43, 0xf4, 0x00, 0xb6, 0x33,
-    0x60, 0x4d, 0x09, 0x81, 0x54, 0xc5, 0x22, 0x2f,
+    0x01, 0xbe, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90,
+    0x88, 0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab,
+    0x8d, 0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5,
+    0x10, 0x94, 0x18, 0x28, 0x0a, 0x40, 0xc5, 0xb9,
+    0x04, 0x42, 0x3e, 0x81, 0x92, 0x80, 0xfa, 0x8c,
+    0x18, 0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c,
+    0x80, 0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81,
+    0x60, 0x75, 0x84, 0x89, 0xc4, 0x03, 0x89, 0x9f,
+    0x81, 0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80,
+    0x96, 0x23, 0x80, 0xd2, 0x81, 0xb1, 0x91, 0x89,
+    0x89, 0x85, 0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98,
+    0x8c, 0xab, 0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a,
+    0x80, 0x89, 0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09,
+    0x89, 0xa0, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08,
+    0x80, 0xa8, 0x24, 0x81, 0x40, 0xeb, 0x38, 0x09,
+    0x89, 0x60, 0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f,
+    0x8f, 0x8f, 0x11, 0x97, 0x82, 0x40, 0xbf, 0x89,
+    0xa4, 0x80, 0x42, 0xbc, 0x80, 0x40, 0xe1, 0x80,
+    0x40, 0x94, 0x84, 0x41, 0x24, 0x89, 0x45, 0x56,
+    0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4,
+    0x81, 0x42, 0x3c, 0x1f, 0x89, 0x41, 0x70, 0x81,
+    0x40, 0x98, 0x8a, 0x40, 0xae, 0x82, 0xb4, 0x8e,
+    0x9e, 0x89, 0x8e, 0x83, 0xac, 0x8a, 0xb4, 0x89,
+    0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21, 0xab, 0x80,
+    0x8b, 0x82, 0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1,
+    0x8b, 0x28, 0x40, 0x9f, 0x8b, 0x84, 0x89, 0x2b,
+    0xb6, 0x08, 0x31, 0x09, 0x82, 0x88, 0x80, 0x89,
+    0x09, 0x32, 0x84, 0x40, 0xbf, 0x91, 0x88, 0x89,
+    0x18, 0xd0, 0x93, 0x8b, 0x89, 0x40, 0xd4, 0x31,
+    0x88, 0x9a, 0x81, 0xd1, 0x90, 0x8e, 0x89, 0xd0,
+    0x8c, 0x87, 0x89, 0xd2, 0x8e, 0x83, 0x89, 0x40,
+    0xf1, 0x8e, 0x40, 0xa4, 0x89, 0xc5, 0x28, 0x09,
+    0x18, 0x00, 0x81, 0x8b, 0x89, 0xf6, 0x31, 0x32,
+    0x80, 0x9b, 0x89, 0xa7, 0x30, 0x1f, 0x80, 0x88,
+    0x8a, 0xad, 0x8f, 0x41, 0x94, 0x38, 0x87, 0x8f,
+    0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00,
+    0x08, 0x30, 0x07, 0x89, 0xaf, 0x20, 0x08, 0x27,
+    0x89, 0x41, 0x48, 0x83, 0x60, 0x4b, 0x68, 0x89,
+    0x40, 0x85, 0x84, 0xba, 0x86, 0x98, 0x89, 0x43,
+    0xf4, 0x00, 0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81,
+    0x60, 0x4c, 0xaa, 0x81, 0x54, 0xc5, 0x22, 0x2f,
     0x39, 0x86, 0x9d, 0x83, 0x40, 0x93, 0x82, 0x45,
     0x88, 0xb1, 0x41, 0xff, 0xb6, 0x83, 0xb1, 0x38,
     0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f, 0x30,
     0x90, 0x0e, 0x01, 0x04, 0x41, 0x04, 0x86, 0x88,
     0x89, 0x41, 0xa1, 0x8d, 0x45, 0xd5, 0x86, 0xec,
-    0x34, 0x89, 0x6c, 0x17, 0xa5, 0x40, 0xef,
+    0x34, 0x89, 0x52, 0x95, 0x89, 0x6c, 0x05, 0x05,
+    0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_index[57] = {
+static const uint8_t unicode_prop_ID_Continue1_index[60] = {
     0xfa, 0x06, 0x00, 0x84, 0x09, 0x00, 0xf0, 0x0a,
     0x00, 0x70, 0x0c, 0x00, 0xf4, 0x0d, 0x00, 0x4a,
-    0x10, 0x20, 0x1a, 0x18, 0x20, 0x74, 0x1b, 0x00,
-    0xe2, 0x20, 0x00, 0x28, 0xa8, 0x20, 0x7e, 0xaa,
-    0x20, 0x40, 0xff, 0x00, 0x03, 0x10, 0x21, 0xeb,
-    0x12, 0x01, 0x41, 0x16, 0x01, 0x40, 0x1c, 0x61,
-    0x37, 0x6b, 0x21, 0x76, 0xda, 0x01, 0xf0, 0x01,
-    0x0e,
+    0x10, 0x20, 0x1a, 0x18, 0x20, 0x74, 0x1b, 0x20,
+    0xdd, 0x20, 0x00, 0x0c, 0xa8, 0x00, 0x5a, 0xaa,
+    0x20, 0x1a, 0xff, 0x00, 0xad, 0x0e, 0x01, 0x38,
+    0x12, 0x21, 0xc1, 0x15, 0x21, 0xe5, 0x19, 0x21,
+    0xaa, 0x1d, 0x21, 0x8c, 0xd1, 0x41, 0x4a, 0xe1,
+    0x21, 0xf0, 0x01, 0x0e,
 };
 
 #ifdef CONFIG_ALL_UNICODE
 
-static const uint8_t unicode_cc_table[831] = {
+static const uint8_t unicode_cc_table[851] = {
     0xb2, 0xcf, 0xd4, 0x00, 0xe8, 0x03, 0xdc, 0x00,
     0xe8, 0x00, 0xd8, 0x04, 0xdc, 0x01, 0xca, 0x03,
     0xdc, 0x01, 0xca, 0x0a, 0xdc, 0x04, 0x01, 0x03,
@@ -574,77 +585,81 @@ static const uint8_t unicode_cc_table[831] = {
     0x9a, 0x00, 0xe4, 0xb0, 0x5e, 0x00, 0xde, 0xc0,
     0x00, 0xdc, 0xb0, 0xaa, 0xc0, 0x00, 0xdc, 0xb0,
     0x16, 0x00, 0x09, 0x93, 0xc7, 0x81, 0x00, 0xdc,
-    0xaf, 0xc4, 0x05, 0xdc, 0xc1, 0x00, 0xdc, 0xb0,
-    0x45, 0x00, 0x07, 0x8e, 0x00, 0x09, 0xa5, 0xc0,
-    0x00, 0xdc, 0xc6, 0xb0, 0x05, 0x01, 0x09, 0xb0,
-    0x09, 0x00, 0x07, 0x8a, 0x01, 0x09, 0xb0, 0x12,
-    0x00, 0x07, 0xb0, 0x67, 0xc2, 0x41, 0x00, 0x04,
-    0xdc, 0xc1, 0x03, 0xdc, 0xc0, 0x41, 0x00, 0x05,
-    0x01, 0x83, 0x00, 0xdc, 0x85, 0xc0, 0x82, 0xc1,
-    0xb0, 0x95, 0xc1, 0x00, 0xdc, 0xc6, 0x00, 0xdc,
-    0xc1, 0x00, 0xea, 0x00, 0xd6, 0x00, 0xdc, 0x00,
-    0xca, 0xe4, 0x00, 0xe8, 0x01, 0xe4, 0x00, 0xdc,
-    0x80, 0xc0, 0x00, 0xe9, 0x00, 0xdc, 0xc0, 0x00,
-    0xdc, 0xb2, 0x9f, 0xc1, 0x01, 0x01, 0xc3, 0x02,
-    0x01, 0xc1, 0x83, 0xc0, 0x82, 0x01, 0x01, 0xc0,
-    0x00, 0xdc, 0xc0, 0x01, 0x01, 0x03, 0xdc, 0xc0,
-    0xb8, 0x03, 0xcd, 0xc2, 0xb0, 0x5c, 0x00, 0x09,
-    0xb0, 0x2f, 0xdf, 0xb1, 0xf9, 0x00, 0xda, 0x00,
-    0xe4, 0x00, 0xe8, 0x00, 0xde, 0x01, 0xe0, 0xb0,
-    0x38, 0x01, 0x08, 0xb8, 0x6d, 0xa3, 0xc0, 0x83,
-    0xc9, 0x9f, 0xc1, 0xb0, 0x1f, 0xc1, 0xb0, 0xe3,
-    0x00, 0x09, 0xb0, 0x8c, 0x00, 0x09, 0x9a, 0xd1,
-    0xb0, 0x08, 0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0,
-    0x2e, 0x00, 0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe,
-    0xc0, 0x80, 0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84,
-    0xc1, 0x80, 0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0,
-    0xc5, 0x00, 0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a,
-    0xb2, 0xd0, 0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c,
-    0x00, 0xdc, 0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64,
-    0xc4, 0xb6, 0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7,
-    0xc0, 0x00, 0x01, 0x00, 0xdc, 0x83, 0x00, 0x09,
-    0xb0, 0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3,
-    0xb1, 0xed, 0x01, 0xdc, 0xc2, 0x00, 0xdc, 0xc0,
-    0x03, 0xdc, 0xb0, 0xc4, 0x00, 0x09, 0xb0, 0x07,
-    0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00, 0x07,
-    0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0, 0x0d,
-    0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88, 0x00,
-    0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f, 0x01,
-    0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82, 0xc4,
-    0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07, 0x96,
-    0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00,
-    0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00,
-    0x07, 0xb1, 0x74, 0x00, 0x09, 0xb0, 0x22, 0x00,
+    0xaf, 0xc4, 0x05, 0xdc, 0xc1, 0x00, 0xdc, 0x80,
+    0x01, 0xdc, 0xb0, 0x42, 0x00, 0x07, 0x8e, 0x00,
+    0x09, 0xa5, 0xc0, 0x00, 0xdc, 0xc6, 0xb0, 0x05,
+    0x01, 0x09, 0xb0, 0x09, 0x00, 0x07, 0x8a, 0x01,
+    0x09, 0xb0, 0x12, 0x00, 0x07, 0xb0, 0x67, 0xc2,
+    0x41, 0x00, 0x04, 0xdc, 0xc1, 0x03, 0xdc, 0xc0,
+    0x41, 0x00, 0x05, 0x01, 0x83, 0x00, 0xdc, 0x85,
+    0xc0, 0x82, 0xc1, 0xb0, 0x95, 0xc1, 0x00, 0xdc,
+    0xc6, 0x00, 0xdc, 0xc1, 0x00, 0xea, 0x00, 0xd6,
+    0x00, 0xdc, 0x00, 0xca, 0xe4, 0x00, 0xe8, 0x01,
+    0xe4, 0x00, 0xdc, 0x80, 0xc0, 0x00, 0xe9, 0x00,
+    0xdc, 0xc0, 0x00, 0xdc, 0xb2, 0x9f, 0xc1, 0x01,
+    0x01, 0xc3, 0x02, 0x01, 0xc1, 0x83, 0xc0, 0x82,
+    0x01, 0x01, 0xc0, 0x00, 0xdc, 0xc0, 0x01, 0x01,
+    0x03, 0xdc, 0xc0, 0xb8, 0x03, 0xcd, 0xc2, 0xb0,
+    0x5c, 0x00, 0x09, 0xb0, 0x2f, 0xdf, 0xb1, 0xf9,
+    0x00, 0xda, 0x00, 0xe4, 0x00, 0xe8, 0x00, 0xde,
+    0x01, 0xe0, 0xb0, 0x38, 0x01, 0x08, 0xb8, 0x6d,
+    0xa3, 0xc0, 0x83, 0xc9, 0x9f, 0xc1, 0xb0, 0x1f,
+    0xc1, 0xb0, 0xe3, 0x00, 0x09, 0xa4, 0x00, 0x09,
+    0xb0, 0x66, 0x00, 0x09, 0x9a, 0xd1, 0xb0, 0x08,
+    0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0, 0x2e, 0x00,
+    0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe, 0xc0, 0x80,
+    0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84, 0xc1, 0x80,
+    0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0, 0xc5, 0x00,
+    0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a, 0xb2, 0xd0,
+    0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c, 0x00, 0xdc,
+    0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64, 0xc4, 0xb6,
+    0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0, 0x00,
+    0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0, 0x74,
+    0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1, 0x52,
+    0xc1, 0xb0, 0x68, 0x01, 0xdc, 0xc2, 0x00, 0xdc,
+    0xc0, 0x03, 0xdc, 0xb0, 0xc4, 0x00, 0x09, 0xb0,
+    0x07, 0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00,
+    0x07, 0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0,
+    0x0d, 0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88,
+    0x00, 0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f,
+    0x01, 0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82,
+    0xc4, 0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07,
+    0x96, 0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d,
+    0x00, 0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09,
+    0x00, 0x07, 0xb0, 0xd1, 0x01, 0x09, 0x83, 0x00,
+    0x07, 0xb0, 0x6b, 0x00, 0x09, 0xb0, 0x22, 0x00,
     0x09, 0x91, 0x00, 0x09, 0xb0, 0x20, 0x00, 0x09,
     0xb1, 0x74, 0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07,
     0x80, 0x01, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb8,
-    0x45, 0x27, 0x04, 0x01, 0xb0, 0x0a, 0xc6, 0xb8,
-    0x49, 0x36, 0x00, 0x01, 0xb8, 0x0c, 0x95, 0x01,
-    0xd8, 0x02, 0x01, 0x82, 0x00, 0xe2, 0x04, 0xd8,
-    0x87, 0x07, 0xdc, 0x81, 0xc4, 0x01, 0xdc, 0x9d,
-    0xc3, 0xb0, 0x63, 0xc2, 0xb8, 0x05, 0x8a, 0xc6,
-    0x80, 0xd0, 0x81, 0xc6, 0x80, 0xc1, 0x80, 0xc4,
-    0xb0, 0xd4, 0xc6, 0xb1, 0x84, 0xc3, 0xb5, 0xaf,
-    0x06, 0xdc, 0xb0, 0x3c, 0xc5, 0x00, 0x07,
+    0x45, 0x27, 0x04, 0x01, 0xb0, 0x0a, 0xc6, 0xb4,
+    0x88, 0x01, 0x06, 0xb8, 0x44, 0x7b, 0x00, 0x01,
+    0xb8, 0x0c, 0x95, 0x01, 0xd8, 0x02, 0x01, 0x82,
+    0x00, 0xe2, 0x04, 0xd8, 0x87, 0x07, 0xdc, 0x81,
+    0xc4, 0x01, 0xdc, 0x9d, 0xc3, 0xb0, 0x63, 0xc2,
+    0xb8, 0x05, 0x8a, 0xc6, 0x80, 0xd0, 0x81, 0xc6,
+    0x80, 0xc1, 0x80, 0xc4, 0xb0, 0xd4, 0xc6, 0xb1,
+    0x84, 0xc3, 0xb5, 0xaf, 0x06, 0xdc, 0xb0, 0x3c,
+    0xc5, 0x00, 0x07,
 };
 
-static const uint8_t unicode_cc_index[78] = {
+static const uint8_t unicode_cc_index[81] = {
     0x4d, 0x03, 0x00, 0x97, 0x05, 0x20, 0xc6, 0x05,
     0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0xe2,
     0x08, 0x00, 0x53, 0x09, 0x00, 0xcd, 0x0b, 0x20,
     0x38, 0x0e, 0x00, 0x73, 0x0f, 0x20, 0x5d, 0x13,
-    0x20, 0x60, 0x1a, 0x20, 0xe6, 0x1b, 0x20, 0xfa,
-    0x1c, 0x00, 0x00, 0x1e, 0x20, 0x80, 0x2d, 0x00,
-    0x06, 0xa8, 0x00, 0xbe, 0xaa, 0x00, 0x76, 0x03,
-    0x01, 0x4d, 0x0f, 0x01, 0xcb, 0x11, 0x21, 0x5e,
-    0x14, 0x01, 0x3b, 0x18, 0x21, 0xf0, 0x6a, 0x41,
-    0xaa, 0xd1, 0x01, 0x4b, 0xe9, 0x01,
+    0x20, 0x60, 0x1a, 0x20, 0xaa, 0x1b, 0x00, 0xf4,
+    0x1c, 0x00, 0xfe, 0x1d, 0x20, 0x7f, 0x2d, 0x20,
+    0xf0, 0xa6, 0x00, 0xb2, 0xaa, 0x00, 0xfe, 0x01,
+    0x01, 0xab, 0x0e, 0x01, 0x73, 0x11, 0x21, 0x70,
+    0x13, 0x01, 0xb8, 0x16, 0x01, 0x9a, 0x1a, 0x01,
+    0x9f, 0xbc, 0x01, 0x22, 0xe0, 0x01, 0x4b, 0xe9,
+    0x01,
 };
 
-static const uint32_t unicode_decomp_table1[687] = {
+static const uint32_t unicode_decomp_table1[690] = {
     0x00280081, 0x002a0097, 0x002a8081, 0x002bc097,
     0x002c8115, 0x002d0097, 0x002d4081, 0x002e0097,
     0x002e4115, 0x002f0199, 0x00302016, 0x00400842,
@@ -771,55 +786,56 @@ static const uint32_t unicode_decomp_table1[687] = {
     0x0cf54119, 0x0cf5c097, 0x0cf6009b, 0x0cf64099,
     0x0cf68217, 0x0cf78119, 0x0cf804a1, 0x0cfa4525,
     0x0cfcc525, 0x0cff4125, 0x0cffc099, 0x29a70103,
-    0x29dc0081, 0x29fe0103, 0x2ad70203, 0x3e401482,
-    0x3e4a7f82, 0x3e6a3f82, 0x3e8aa102, 0x3e9b0110,
-    0x3e9c2f82, 0x3eb3c590, 0x3ec00197, 0x3ec0c119,
-    0x3ec1413f, 0x3ec4c2af, 0x3ec74184, 0x3ec804ad,
-    0x3eca4081, 0x3eca8304, 0x3ecc03a0, 0x3ece02a0,
-    0x3ecf8084, 0x3ed00120, 0x3ed0c120, 0x3ed184ae,
-    0x3ed3c085, 0x3ed4312d, 0x3ef4cbad, 0x3efa892f,
-    0x3eff022d, 0x3f002f2f, 0x3f1782a5, 0x3f18c0b1,
-    0x3f1907af, 0x3f1cffaf, 0x3f3c81a5, 0x3f3d64af,
-    0x3f542031, 0x3f649b31, 0x3f7c0131, 0x3f7c83b3,
-    0x3f7e40b1, 0x3f7e80bd, 0x3f7ec0bb, 0x3f7f00b3,
-    0x3f840503, 0x3f8c01ad, 0x3f8cc315, 0x3f8e462d,
-    0x3f91cc03, 0x3f97c695, 0x3f9c01af, 0x3f9d0085,
-    0x3f9d852f, 0x3fa03aad, 0x3fbd442f, 0x3fc06f1f,
-    0x3fd7c11f, 0x3fd85fad, 0x3fe80081, 0x3fe84f1f,
-    0x3ff0831f, 0x3ff2831f, 0x3ff4831f, 0x3ff6819f,
-    0x3ff80783, 0x44268192, 0x442ac092, 0x444b8112,
-    0x44d2c112, 0x452ec212, 0x456e8112, 0x74578392,
-    0x746ec312, 0x75000d1f, 0x75068d1f, 0x750d0d1f,
-    0x7513839f, 0x7515891f, 0x751a0d1f, 0x75208d1f,
-    0x75271015, 0x752f439f, 0x7531459f, 0x75340d1f,
-    0x753a8d1f, 0x75410395, 0x7543441f, 0x7545839f,
-    0x75478d1f, 0x754e0795, 0x7552839f, 0x75548d1f,
-    0x755b0d1f, 0x75618d1f, 0x75680d1f, 0x756e8d1f,
-    0x75750d1f, 0x757b8d1f, 0x75820d1f, 0x75888d1f,
-    0x758f0d1f, 0x75958d1f, 0x759c0d1f, 0x75a28d1f,
-    0x75a90103, 0x75aa089f, 0x75ae4081, 0x75ae839f,
-    0x75b04081, 0x75b08c9f, 0x75b6c081, 0x75b7032d,
-    0x75b8889f, 0x75bcc081, 0x75bd039f, 0x75bec081,
-    0x75bf0c9f, 0x75c54081, 0x75c5832d, 0x75c7089f,
-    0x75cb4081, 0x75cb839f, 0x75cd4081, 0x75cd8c9f,
-    0x75d3c081, 0x75d4032d, 0x75d5889f, 0x75d9c081,
-    0x75da039f, 0x75dbc081, 0x75dc0c9f, 0x75e24081,
-    0x75e2832d, 0x75e4089f, 0x75e84081, 0x75e8839f,
-    0x75ea4081, 0x75ea8c9f, 0x75f0c081, 0x75f1042d,
-    0x75f3851f, 0x75f6051f, 0x75f8851f, 0x75fb051f,
-    0x75fd851f, 0x7b80022d, 0x7b814dad, 0x7b884203,
-    0x7b89c081, 0x7b8a452d, 0x7b8d0403, 0x7b908081,
-    0x7b91dc03, 0x7ba0052d, 0x7ba2c8ad, 0x7ba84483,
-    0x7baac8ad, 0x7c400097, 0x7c404521, 0x7c440d25,
-    0x7c4a8087, 0x7c4ac115, 0x7c4b4117, 0x7c4c0d1f,
-    0x7c528217, 0x7c538099, 0x7c53c097, 0x7c5a8197,
-    0x7c640097, 0x7c80012f, 0x7c808081, 0x7c841603,
-    0x7c9004c1, 0x7c940103, 0xbe0001ac, 0xbe00d110,
-    0xbe0947ac, 0xbe0d3910, 0xbe29872c, 0xbe2d022c,
-    0xbe2e3790, 0xbe49ff90, 0xbe69bc10,
+    0x29dc0081, 0x29fe0103, 0x2ad70203, 0x2ada4081,
+    0x3e401482, 0x3e4a7f82, 0x3e6a3f82, 0x3e8aa102,
+    0x3e9b0110, 0x3e9c2f82, 0x3eb3c590, 0x3ec00197,
+    0x3ec0c119, 0x3ec1413f, 0x3ec4c2af, 0x3ec74184,
+    0x3ec804ad, 0x3eca4081, 0x3eca8304, 0x3ecc03a0,
+    0x3ece02a0, 0x3ecf8084, 0x3ed00120, 0x3ed0c120,
+    0x3ed184ae, 0x3ed3c085, 0x3ed4312d, 0x3ef4cbad,
+    0x3efa892f, 0x3eff022d, 0x3f002f2f, 0x3f1782a5,
+    0x3f18c0b1, 0x3f1907af, 0x3f1cffaf, 0x3f3c81a5,
+    0x3f3d64af, 0x3f542031, 0x3f649b31, 0x3f7c0131,
+    0x3f7c83b3, 0x3f7e40b1, 0x3f7e80bd, 0x3f7ec0bb,
+    0x3f7f00b3, 0x3f840503, 0x3f8c01ad, 0x3f8cc315,
+    0x3f8e462d, 0x3f91cc03, 0x3f97c695, 0x3f9c01af,
+    0x3f9d0085, 0x3f9d852f, 0x3fa03aad, 0x3fbd442f,
+    0x3fc06f1f, 0x3fd7c11f, 0x3fd85fad, 0x3fe80081,
+    0x3fe84f1f, 0x3ff0831f, 0x3ff2831f, 0x3ff4831f,
+    0x3ff6819f, 0x3ff80783, 0x44268192, 0x442ac092,
+    0x444b8112, 0x44d2c112, 0x452ec212, 0x456e8112,
+    0x464e0092, 0x74578392, 0x746ec312, 0x75000d1f,
+    0x75068d1f, 0x750d0d1f, 0x7513839f, 0x7515891f,
+    0x751a0d1f, 0x75208d1f, 0x75271015, 0x752f439f,
+    0x7531459f, 0x75340d1f, 0x753a8d1f, 0x75410395,
+    0x7543441f, 0x7545839f, 0x75478d1f, 0x754e0795,
+    0x7552839f, 0x75548d1f, 0x755b0d1f, 0x75618d1f,
+    0x75680d1f, 0x756e8d1f, 0x75750d1f, 0x757b8d1f,
+    0x75820d1f, 0x75888d1f, 0x758f0d1f, 0x75958d1f,
+    0x759c0d1f, 0x75a28d1f, 0x75a90103, 0x75aa089f,
+    0x75ae4081, 0x75ae839f, 0x75b04081, 0x75b08c9f,
+    0x75b6c081, 0x75b7032d, 0x75b8889f, 0x75bcc081,
+    0x75bd039f, 0x75bec081, 0x75bf0c9f, 0x75c54081,
+    0x75c5832d, 0x75c7089f, 0x75cb4081, 0x75cb839f,
+    0x75cd4081, 0x75cd8c9f, 0x75d3c081, 0x75d4032d,
+    0x75d5889f, 0x75d9c081, 0x75da039f, 0x75dbc081,
+    0x75dc0c9f, 0x75e24081, 0x75e2832d, 0x75e4089f,
+    0x75e84081, 0x75e8839f, 0x75ea4081, 0x75ea8c9f,
+    0x75f0c081, 0x75f1042d, 0x75f3851f, 0x75f6051f,
+    0x75f8851f, 0x75fb051f, 0x75fd851f, 0x7b80022d,
+    0x7b814dad, 0x7b884203, 0x7b89c081, 0x7b8a452d,
+    0x7b8d0403, 0x7b908081, 0x7b91dc03, 0x7ba0052d,
+    0x7ba2c8ad, 0x7ba84483, 0x7baac8ad, 0x7c400097,
+    0x7c404521, 0x7c440d25, 0x7c4a8087, 0x7c4ac115,
+    0x7c4b4117, 0x7c4c0d1f, 0x7c528217, 0x7c538099,
+    0x7c53c097, 0x7c5a8197, 0x7c640097, 0x7c80012f,
+    0x7c808081, 0x7c841603, 0x7c9004c1, 0x7c940103,
+    0x7efc051f, 0xbe0001ac, 0xbe00d110, 0xbe0947ac,
+    0xbe0d3910, 0xbe29872c, 0xbe2d022c, 0xbe2e3790,
+    0xbe49ff90, 0xbe69bc10,
 };
 
-static const uint16_t unicode_decomp_table2[687] = {
+static const uint16_t unicode_decomp_table2[690] = {
     0x0020, 0x0000, 0x0061, 0x0002, 0x0004, 0x0006, 0x03bc, 0x0008,
     0x000a, 0x000c, 0x0015, 0x0095, 0x00a5, 0x00b9, 0x00c1, 0x00c3,
     0x00c7, 0x00cb, 0x00d1, 0x00d7, 0x00dd, 0x00e0, 0x00e6, 0x00f8,
@@ -883,32 +899,33 @@ static const uint16_t unicode_decomp_table2[687] = {
     0x10f4, 0x1100, 0x1105, 0x1111, 0x1141, 0x1149, 0x114d, 0x1153,
     0x1157, 0x115a, 0x116e, 0x1171, 0x1175, 0x117b, 0x117d, 0x1181,
     0x1184, 0x118c, 0x1192, 0x1196, 0x119c, 0x11a2, 0x11a8, 0x11ab,
-    0xa76f, 0x11af, 0x11b3, 0x11bb, 0x120d, 0x130b, 0x1409, 0x148d,
-    0x1492, 0x1550, 0x1569, 0x156f, 0x1575, 0x157b, 0x1587, 0x1593,
-    0x002b, 0x159e, 0x15b6, 0x15ba, 0x15be, 0x15c2, 0x15c6, 0x15ca,
-    0x15de, 0x15e2, 0x1646, 0x165f, 0x1685, 0x168b, 0x1749, 0x174f,
-    0x1754, 0x1774, 0x1874, 0x187a, 0x190e, 0x19d0, 0x1a74, 0x1a7c,
-    0x1a9a, 0x1a9f, 0x1ab3, 0x1abd, 0x1ac3, 0x1ad7, 0x1adc, 0x1ae2,
-    0x1af0, 0x1b20, 0x1b2d, 0x1b35, 0x1b39, 0x1b4f, 0x1bc6, 0x1bd8,
-    0x1bda, 0x1bdc, 0x3164, 0x1c1d, 0x1c1f, 0x1c21, 0x1c23, 0x1c25,
-    0x1c27, 0x1c45, 0x1c53, 0x1c58, 0x1c61, 0x1c6a, 0x1c7c, 0x1c85,
-    0x1ca5, 0x1cc0, 0x1cc2, 0x1cc4, 0x1cc6, 0x1cc8, 0x1cca, 0x1ccc,
-    0x1cce, 0x1cee, 0x1cf0, 0x1cf2, 0x1cf4, 0x1cf6, 0x1cfd, 0x1cff,
-    0x1d01, 0x1d03, 0x1d12, 0x1d14, 0x1d16, 0x1d18, 0x1d1a, 0x1d1c,
-    0x1d1e, 0x1d20, 0x1d22, 0x1d24, 0x1d26, 0x1d28, 0x1d2a, 0x1d2c,
-    0x1d2e, 0x1d32, 0x03f4, 0x1d34, 0x2207, 0x1d36, 0x2202, 0x1d38,
-    0x1d40, 0x03f4, 0x1d42, 0x2207, 0x1d44, 0x2202, 0x1d46, 0x1d4e,
-    0x03f4, 0x1d50, 0x2207, 0x1d52, 0x2202, 0x1d54, 0x1d5c, 0x03f4,
-    0x1d5e, 0x2207, 0x1d60, 0x2202, 0x1d62, 0x1d6a, 0x03f4, 0x1d6c,
-    0x2207, 0x1d6e, 0x2202, 0x1d70, 0x1d7a, 0x1d7c, 0x1d7e, 0x1d80,
-    0x1d82, 0x1d84, 0x1d8a, 0x1da7, 0x062d, 0x1daf, 0x1dbb, 0x062c,
-    0x1dcb, 0x1e3b, 0x1e47, 0x1e5a, 0x1e6c, 0x1e7f, 0x1e81, 0x1e85,
-    0x1e8b, 0x1e91, 0x1e93, 0x1e97, 0x1e99, 0x1ea1, 0x1ea4, 0x1ea6,
-    0x1eac, 0x1eae, 0x30b5, 0x1eb4, 0x1f0c, 0x1f22, 0x1f26, 0x1f2b,
-    0x1f78, 0x1f89, 0x208a, 0x209a, 0x20a0, 0x219a, 0x22b8,
+    0xa76f, 0x11af, 0x11b3, 0x028d, 0x11bb, 0x120d, 0x130b, 0x1409,
+    0x148d, 0x1492, 0x1550, 0x1569, 0x156f, 0x1575, 0x157b, 0x1587,
+    0x1593, 0x002b, 0x159e, 0x15b6, 0x15ba, 0x15be, 0x15c2, 0x15c6,
+    0x15ca, 0x15de, 0x15e2, 0x1646, 0x165f, 0x1685, 0x168b, 0x1749,
+    0x174f, 0x1754, 0x1774, 0x1874, 0x187a, 0x190e, 0x19d0, 0x1a74,
+    0x1a7c, 0x1a9a, 0x1a9f, 0x1ab3, 0x1abd, 0x1ac3, 0x1ad7, 0x1adc,
+    0x1ae2, 0x1af0, 0x1b20, 0x1b2d, 0x1b35, 0x1b39, 0x1b4f, 0x1bc6,
+    0x1bd8, 0x1bda, 0x1bdc, 0x3164, 0x1c1d, 0x1c1f, 0x1c21, 0x1c23,
+    0x1c25, 0x1c27, 0x1c45, 0x1c53, 0x1c58, 0x1c61, 0x1c6a, 0x1c7c,
+    0x1c85, 0x1c8a, 0x1caa, 0x1cc5, 0x1cc7, 0x1cc9, 0x1ccb, 0x1ccd,
+    0x1ccf, 0x1cd1, 0x1cd3, 0x1cf3, 0x1cf5, 0x1cf7, 0x1cf9, 0x1cfb,
+    0x1d02, 0x1d04, 0x1d06, 0x1d08, 0x1d17, 0x1d19, 0x1d1b, 0x1d1d,
+    0x1d1f, 0x1d21, 0x1d23, 0x1d25, 0x1d27, 0x1d29, 0x1d2b, 0x1d2d,
+    0x1d2f, 0x1d31, 0x1d33, 0x1d37, 0x03f4, 0x1d39, 0x2207, 0x1d3b,
+    0x2202, 0x1d3d, 0x1d45, 0x03f4, 0x1d47, 0x2207, 0x1d49, 0x2202,
+    0x1d4b, 0x1d53, 0x03f4, 0x1d55, 0x2207, 0x1d57, 0x2202, 0x1d59,
+    0x1d61, 0x03f4, 0x1d63, 0x2207, 0x1d65, 0x2202, 0x1d67, 0x1d6f,
+    0x03f4, 0x1d71, 0x2207, 0x1d73, 0x2202, 0x1d75, 0x1d7f, 0x1d81,
+    0x1d83, 0x1d85, 0x1d87, 0x1d89, 0x1d8f, 0x1dac, 0x062d, 0x1db4,
+    0x1dc0, 0x062c, 0x1dd0, 0x1e40, 0x1e4c, 0x1e5f, 0x1e71, 0x1e84,
+    0x1e86, 0x1e8a, 0x1e90, 0x1e96, 0x1e98, 0x1e9c, 0x1e9e, 0x1ea6,
+    0x1ea9, 0x1eab, 0x1eb1, 0x1eb3, 0x30b5, 0x1eb9, 0x1f11, 0x1f27,
+    0x1f2b, 0x1f2d, 0x1f32, 0x1f7f, 0x1f90, 0x2091, 0x20a1, 0x20a7,
+    0x21a1, 0x22bf,
 };
 
-static const uint8_t unicode_decomp_data[9158] = {
+static const uint8_t unicode_decomp_data[9165] = {
     0x20, 0x88, 0x20, 0x84, 0x32, 0x33, 0x20, 0x81,
     0x20, 0xa7, 0x31, 0x6f, 0x31, 0xd0, 0x34, 0x31,
     0xd0, 0x32, 0x33, 0xd0, 0x34, 0x41, 0x80, 0x41,
@@ -1821,242 +1838,243 @@ static const uint8_t unicode_decomp_data[9158] = {
     0x13, 0x55, 0xb9, 0x14, 0xba, 0x14, 0xb9, 0x14,
     0xb0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x14,
     0xbd, 0x14, 0x55, 0x50, 0xb8, 0x15, 0xaf, 0x15,
-    0xb9, 0x15, 0xaf, 0x15, 0x55, 0x57, 0xd1, 0x65,
-    0xd1, 0x58, 0xd1, 0x65, 0xd1, 0x5f, 0xd1, 0x6e,
-    0xd1, 0x5f, 0xd1, 0x6f, 0xd1, 0x5f, 0xd1, 0x70,
-    0xd1, 0x5f, 0xd1, 0x71, 0xd1, 0x5f, 0xd1, 0x72,
-    0xd1, 0x55, 0x55, 0x55, 0x05, 0xb9, 0xd1, 0x65,
-    0xd1, 0xba, 0xd1, 0x65, 0xd1, 0xbb, 0xd1, 0x6e,
-    0xd1, 0xbc, 0xd1, 0x6e, 0xd1, 0xbb, 0xd1, 0x6f,
-    0xd1, 0xbc, 0xd1, 0x6f, 0xd1, 0x55, 0x55, 0x55,
-    0x41, 0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00,
-    0x69, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x43, 0x44, 0x00, 0x00, 0x47, 0x00, 0x00, 0x4a,
-    0x4b, 0x00, 0x00, 0x4e, 0x4f, 0x50, 0x51, 0x00,
-    0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
-    0x61, 0x62, 0x63, 0x64, 0x00, 0x66, 0x68, 0x00,
-    0x70, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x42,
-    0x00, 0x44, 0x45, 0x46, 0x47, 0x4a, 0x00, 0x53,
+    0xb9, 0x15, 0xaf, 0x15, 0x55, 0x35, 0x19, 0x30,
+    0x19, 0x05, 0x57, 0xd1, 0x65, 0xd1, 0x58, 0xd1,
+    0x65, 0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f, 0xd1,
+    0x6f, 0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f, 0xd1,
+    0x71, 0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55, 0x55,
+    0x55, 0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba, 0xd1,
+    0x65, 0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc, 0xd1,
+    0x6e, 0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc, 0xd1,
+    0x6f, 0xd1, 0x55, 0x55, 0x55, 0x41, 0x00, 0x61,
+    0x00, 0x41, 0x00, 0x61, 0x00, 0x69, 0x00, 0x41,
+    0x00, 0x61, 0x00, 0x41, 0x00, 0x43, 0x44, 0x00,
+    0x00, 0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00, 0x00,
+    0x4e, 0x4f, 0x50, 0x51, 0x00, 0x53, 0x54, 0x55,
+    0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63,
+    0x64, 0x00, 0x66, 0x68, 0x00, 0x70, 0x00, 0x41,
     0x00, 0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45,
-    0x46, 0x47, 0x00, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
-    0x00, 0x4f, 0x53, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x31, 0x01,
-    0x37, 0x02, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
-    0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
-    0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
-    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
-    0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
-    0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03,
-    0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04,
-    0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
-    0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
-    0x0b, 0x0c, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
-    0x30, 0x00, 0x30, 0x00, 0x27, 0x06, 0x00, 0x01,
-    0x05, 0x08, 0x2a, 0x06, 0x1e, 0x08, 0x03, 0x0d,
-    0x20, 0x19, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
-    0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06,
-    0x0c, 0x0e, 0x10, 0x44, 0x90, 0x77, 0x45, 0x28,
-    0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06, 0x33,
-    0x06, 0x17, 0x10, 0x11, 0x12, 0x13, 0x00, 0x06,
-    0x0e, 0x02, 0x0f, 0x34, 0x06, 0x2a, 0x06, 0x2b,
-    0x06, 0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x00,
-    0x00, 0x3a, 0x06, 0x2d, 0x06, 0x00, 0x00, 0x4a,
-    0x06, 0x00, 0x00, 0x44, 0x06, 0x00, 0x00, 0x46,
-    0x06, 0x33, 0x06, 0x39, 0x06, 0x00, 0x00, 0x35,
-    0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06, 0x00,
-    0x00, 0x00, 0x00, 0x2e, 0x06, 0x00, 0x00, 0x36,
-    0x06, 0x00, 0x00, 0x3a, 0x06, 0x00, 0x00, 0xba,
-    0x06, 0x00, 0x00, 0x6f, 0x06, 0x00, 0x00, 0x28,
-    0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06, 0x00,
-    0x00, 0x00, 0x00, 0x2d, 0x06, 0x37, 0x06, 0x4a,
-    0x06, 0x43, 0x06, 0x00, 0x00, 0x45, 0x06, 0x46,
-    0x06, 0x33, 0x06, 0x39, 0x06, 0x41, 0x06, 0x35,
-    0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06, 0x2a,
-    0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00, 0x36,
-    0x06, 0x38, 0x06, 0x3a, 0x06, 0x6e, 0x06, 0x00,
-    0x00, 0xa1, 0x06, 0x27, 0x06, 0x00, 0x01, 0x05,
-    0x08, 0x20, 0x21, 0x0b, 0x06, 0x10, 0x23, 0x2a,
-    0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b,
-    0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c,
-    0x0e, 0x10, 0x28, 0x06, 0x2c, 0x06, 0x2f, 0x06,
-    0x00, 0x00, 0x48, 0x06, 0x32, 0x06, 0x2d, 0x06,
-    0x37, 0x06, 0x4a, 0x06, 0x2a, 0x06, 0x1a, 0x1b,
+    0x46, 0x47, 0x4a, 0x00, 0x53, 0x00, 0x61, 0x00,
+    0x41, 0x42, 0x00, 0x44, 0x45, 0x46, 0x47, 0x00,
+    0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f, 0x53,
+    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
+    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
+    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
+    0x00, 0x61, 0x00, 0x31, 0x01, 0x37, 0x02, 0x91,
+    0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24,
+    0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3,
+    0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f,
+    0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1,
+    0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20,
+    0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1,
+    0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91,
+    0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24,
+    0x00, 0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30,
+    0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30,
+    0x00, 0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x2a,
+    0x06, 0x1e, 0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a,
+    0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07,
+    0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10,
+    0x44, 0x90, 0x77, 0x45, 0x28, 0x06, 0x2c, 0x06,
+    0x00, 0x00, 0x47, 0x06, 0x33, 0x06, 0x17, 0x10,
+    0x11, 0x12, 0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f,
+    0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06,
+    0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06,
+    0x2d, 0x06, 0x00, 0x00, 0x4a, 0x06, 0x00, 0x00,
+    0x44, 0x06, 0x00, 0x00, 0x46, 0x06, 0x33, 0x06,
+    0x39, 0x06, 0x00, 0x00, 0x35, 0x06, 0x42, 0x06,
+    0x00, 0x00, 0x34, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00,
+    0x3a, 0x06, 0x00, 0x00, 0xba, 0x06, 0x00, 0x00,
+    0x6f, 0x06, 0x00, 0x00, 0x28, 0x06, 0x2c, 0x06,
+    0x00, 0x00, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06, 0x43, 0x06,
+    0x00, 0x00, 0x45, 0x06, 0x46, 0x06, 0x33, 0x06,
+    0x39, 0x06, 0x41, 0x06, 0x35, 0x06, 0x42, 0x06,
+    0x00, 0x00, 0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06,
+    0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x38, 0x06,
+    0x3a, 0x06, 0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06,
+    0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x20, 0x21,
+    0x0b, 0x06, 0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b,
     0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a,
-    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x30,
-    0x2e, 0x30, 0x00, 0x2c, 0x00, 0x28, 0x00, 0x41,
-    0x00, 0x29, 0x00, 0x14, 0x30, 0x53, 0x00, 0x15,
-    0x30, 0x43, 0x52, 0x43, 0x44, 0x57, 0x5a, 0x41,
-    0x00, 0x48, 0x56, 0x4d, 0x56, 0x53, 0x44, 0x53,
-    0x53, 0x50, 0x50, 0x56, 0x57, 0x43, 0x4d, 0x43,
-    0x4d, 0x44, 0x4d, 0x52, 0x44, 0x4a, 0x4b, 0x30,
-    0x30, 0x00, 0x68, 0x68, 0x4b, 0x62, 0x57, 0x5b,
-    0xcc, 0x53, 0xc7, 0x30, 0x8c, 0x4e, 0x1a, 0x59,
-    0xe3, 0x89, 0x29, 0x59, 0xa4, 0x4e, 0x20, 0x66,
-    0x21, 0x71, 0x99, 0x65, 0x4d, 0x52, 0x8c, 0x5f,
-    0x8d, 0x51, 0xb0, 0x65, 0x1d, 0x52, 0x42, 0x7d,
-    0x1f, 0x75, 0xa9, 0x8c, 0xf0, 0x58, 0x39, 0x54,
-    0x14, 0x6f, 0x95, 0x62, 0x55, 0x63, 0x00, 0x4e,
-    0x09, 0x4e, 0x4a, 0x90, 0xe6, 0x5d, 0x2d, 0x4e,
-    0xf3, 0x53, 0x07, 0x63, 0x70, 0x8d, 0x53, 0x62,
-    0x81, 0x79, 0x7a, 0x7a, 0x08, 0x54, 0x80, 0x6e,
-    0x09, 0x67, 0x08, 0x67, 0x33, 0x75, 0x72, 0x52,
-    0xb6, 0x55, 0x4d, 0x91, 0x14, 0x30, 0x15, 0x30,
-    0x2c, 0x67, 0x09, 0x4e, 0x8c, 0x4e, 0x89, 0x5b,
-    0xb9, 0x70, 0x53, 0x62, 0xd7, 0x76, 0xdd, 0x52,
-    0x57, 0x65, 0x97, 0x5f, 0xef, 0x53, 0x38, 0x4e,
-    0x05, 0x00, 0x09, 0x22, 0x01, 0x60, 0x4f, 0xae,
-    0x4f, 0xbb, 0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99,
-    0x50, 0xe7, 0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a,
-    0x06, 0x4d, 0x51, 0x54, 0x51, 0x64, 0x51, 0x77,
-    0x51, 0x1c, 0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d,
-    0x51, 0x4b, 0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc,
-    0x4e, 0xac, 0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5,
-    0x51, 0x03, 0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46,
-    0x52, 0x72, 0x52, 0x77, 0x52, 0x15, 0x35, 0x02,
-    0x00, 0x20, 0x80, 0x80, 0x00, 0x08, 0x00, 0x00,
-    0xc7, 0x52, 0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f,
-    0x50, 0x82, 0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8,
-    0xb8, 0x2c, 0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf,
-    0x53, 0x63, 0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06,
-    0x54, 0x9e, 0x54, 0x38, 0x54, 0x48, 0x54, 0x68,
-    0x54, 0xa2, 0x54, 0xf6, 0x54, 0x10, 0x55, 0x53,
-    0x55, 0x63, 0x55, 0x84, 0x55, 0x84, 0x55, 0x99,
-    0x55, 0xab, 0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16,
-    0x57, 0x06, 0x56, 0x17, 0x57, 0x51, 0x56, 0x74,
-    0x56, 0x07, 0x52, 0xee, 0x58, 0xce, 0x57, 0xf4,
-    0x57, 0x0d, 0x58, 0x8b, 0x57, 0x32, 0x58, 0x31,
-    0x58, 0xac, 0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7,
-    0x58, 0x06, 0x59, 0x1a, 0x59, 0x22, 0x59, 0x62,
-    0x59, 0xa8, 0x16, 0xea, 0x16, 0xec, 0x59, 0x1b,
-    0x5a, 0x27, 0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee,
-    0x36, 0xfc, 0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e,
-    0x5b, 0xc8, 0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7,
-    0x5b, 0xf3, 0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06,
-    0x5c, 0x53, 0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60,
-    0x5c, 0x6e, 0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4,
-    0x1d, 0x43, 0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b,
-    0x5d, 0x7c, 0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f,
-    0x38, 0xfd, 0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69,
-    0x5e, 0x62, 0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0,
-    0x5e, 0xb3, 0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92,
-    0xa3, 0xfe, 0x5e, 0x31, 0x23, 0x31, 0x23, 0x01,
-    0x82, 0x22, 0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8,
-    0x32, 0xda, 0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3,
-    0x38, 0x9a, 0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9,
-    0x5f, 0x81, 0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94,
-    0x60, 0xd4, 0x26, 0xc7, 0x60, 0x02, 0x02, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
-    0x0a, 0x00, 0x00, 0x02, 0x08, 0x00, 0x80, 0x08,
-    0x00, 0x00, 0x08, 0x80, 0x28, 0x80, 0x02, 0x00,
-    0x00, 0x02, 0x48, 0x61, 0x00, 0x04, 0x06, 0x04,
-    0x32, 0x46, 0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae,
-    0xc8, 0xd3, 0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3,
-    0x0c, 0x2b, 0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63,
-    0x83, 0x63, 0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64,
-    0xc5, 0x63, 0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64,
-    0x7e, 0x64, 0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a,
-    0x4f, 0x65, 0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65,
-    0xf8, 0x66, 0x49, 0x66, 0x19, 0x3b, 0x91, 0x66,
-    0x08, 0x3b, 0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51,
-    0x00, 0x67, 0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43,
-    0x17, 0x67, 0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67,
-    0x53, 0x67, 0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67,
-    0x85, 0x67, 0x52, 0x68, 0x85, 0x68, 0x6d, 0x34,
-    0x8e, 0x68, 0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b,
-    0x42, 0x69, 0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a,
-    0xa3, 0x36, 0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b,
-    0xa7, 0x38, 0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b,
-    0x9f, 0x6b, 0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a,
-    0x0b, 0x1d, 0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c,
-    0xbf, 0x6c, 0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d,
-    0x3e, 0x6d, 0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d,
-    0x78, 0x6d, 0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d,
-    0x2f, 0x6e, 0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e,
-    0xc7, 0x6e, 0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f,
-    0x5e, 0x3f, 0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70,
-    0x1e, 0x70, 0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70,
-    0x7d, 0x70, 0x77, 0x70, 0xad, 0x70, 0x25, 0x05,
-    0x45, 0x71, 0x63, 0x42, 0x9c, 0x71, 0xab, 0x43,
-    0x28, 0x72, 0x35, 0x72, 0x50, 0x72, 0x08, 0x46,
-    0x80, 0x72, 0x95, 0x72, 0x35, 0x47, 0x02, 0x20,
-    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x08,
-    0x80, 0x00, 0x00, 0x02, 0x02, 0x80, 0x8a, 0x00,
-    0x00, 0x20, 0x00, 0x08, 0x0a, 0x00, 0x80, 0x88,
-    0x80, 0x20, 0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73,
-    0xac, 0x3e, 0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e,
-    0x47, 0x74, 0x5c, 0x74, 0x71, 0x74, 0x85, 0x74,
-    0xca, 0x74, 0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c,
-    0x3e, 0x75, 0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21,
-    0x10, 0x76, 0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50,
-    0xfc, 0x3f, 0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50,
-    0xf2, 0x50, 0x19, 0x51, 0x33, 0x51, 0x1e, 0x77,
-    0x1f, 0x77, 0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40,
-    0x8b, 0x77, 0x46, 0x40, 0x96, 0x40, 0x1d, 0x54,
-    0x4e, 0x78, 0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40,
-    0x26, 0x56, 0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56,
-    0x8f, 0x79, 0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a,
-    0x4a, 0x7a, 0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a,
-    0xa7, 0x5a, 0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b,
-    0xc6, 0x7b, 0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c,
-    0xd2, 0x7c, 0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c,
-    0x00, 0x7d, 0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43,
-    0xc7, 0x7d, 0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43,
-    0x28, 0x62, 0x47, 0x62, 0x59, 0x43, 0xd9, 0x62,
-    0x7a, 0x7f, 0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f,
-    0x05, 0x80, 0xda, 0x64, 0x23, 0x65, 0x60, 0x80,
-    0xa8, 0x65, 0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43,
-    0xb2, 0x80, 0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81,
-    0xb5, 0x5a, 0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33,
-    0x9c, 0x33, 0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f,
-    0x6b, 0x44, 0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82,
-    0xb3, 0x52, 0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82,
-    0xe6, 0x82, 0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83,
-    0x63, 0x83, 0xad, 0x83, 0x23, 0x83, 0xbd, 0x83,
-    0xe7, 0x83, 0x57, 0x84, 0x53, 0x83, 0xca, 0x83,
-    0xcc, 0x83, 0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d,
-    0x02, 0x00, 0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a,
-    0x00, 0x20, 0x80, 0x28, 0x00, 0xa8, 0x20, 0x20,
-    0x00, 0x02, 0x80, 0x22, 0x02, 0x8a, 0x08, 0x00,
-    0xaa, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x28,
-    0xd5, 0x6c, 0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84,
-    0x16, 0x85, 0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f,
-    0x5d, 0x45, 0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70,
-    0x6b, 0x45, 0x50, 0x86, 0x5c, 0x86, 0x67, 0x86,
-    0x69, 0x86, 0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87,
-    0xe2, 0x86, 0x79, 0x87, 0x28, 0x87, 0x6b, 0x87,
-    0x86, 0x87, 0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88,
-    0xf9, 0x45, 0x60, 0x88, 0x63, 0x88, 0x67, 0x76,
-    0xd7, 0x88, 0xde, 0x88, 0x35, 0x46, 0xfa, 0x88,
-    0xbb, 0x34, 0xae, 0x78, 0x66, 0x79, 0xbe, 0x46,
-    0xc7, 0x46, 0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b,
-    0x55, 0x8c, 0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c,
-    0x1b, 0x8d, 0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08,
-    0xcb, 0x8d, 0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08,
-    0xd4, 0x8e, 0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85,
-    0x94, 0x90, 0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87,
-    0x1b, 0x91, 0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92,
-    0x7c, 0x92, 0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b,
-    0x8b, 0x95, 0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d,
-    0xe6, 0x49, 0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97,
-    0x45, 0x91, 0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a,
-    0xe0, 0x97, 0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94,
-    0x0b, 0x98, 0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95,
-    0xe2, 0x98, 0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99,
-    0xc2, 0x99, 0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b,
-    0x12, 0x9b, 0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c,
-    0xed, 0x4c, 0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c,
-    0x05, 0xa1, 0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e,
-    0x56, 0x4d, 0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f,
-    0x0f, 0x9f, 0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6,
-    0x02, 0x88, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x80,
-    0x00, 0x28, 0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80,
-    0x00, 0x80, 0x80, 0x00, 0x0a, 0x88, 0x80, 0x00,
-    0x80, 0x00, 0x20, 0x2a, 0x00, 0x80,
+    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28,
+    0x06, 0x2c, 0x06, 0x2f, 0x06, 0x00, 0x00, 0x48,
+    0x06, 0x32, 0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a,
+    0x06, 0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f,
+    0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04,
+    0x06, 0x0c, 0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00,
+    0x2c, 0x00, 0x28, 0x00, 0x41, 0x00, 0x29, 0x00,
+    0x14, 0x30, 0x53, 0x00, 0x15, 0x30, 0x43, 0x52,
+    0x43, 0x44, 0x57, 0x5a, 0x41, 0x00, 0x48, 0x56,
+    0x4d, 0x56, 0x53, 0x44, 0x53, 0x53, 0x50, 0x50,
+    0x56, 0x57, 0x43, 0x4d, 0x43, 0x4d, 0x44, 0x4d,
+    0x52, 0x44, 0x4a, 0x4b, 0x30, 0x30, 0x00, 0x68,
+    0x68, 0x4b, 0x62, 0x57, 0x5b, 0xcc, 0x53, 0xc7,
+    0x30, 0x8c, 0x4e, 0x1a, 0x59, 0xe3, 0x89, 0x29,
+    0x59, 0xa4, 0x4e, 0x20, 0x66, 0x21, 0x71, 0x99,
+    0x65, 0x4d, 0x52, 0x8c, 0x5f, 0x8d, 0x51, 0xb0,
+    0x65, 0x1d, 0x52, 0x42, 0x7d, 0x1f, 0x75, 0xa9,
+    0x8c, 0xf0, 0x58, 0x39, 0x54, 0x14, 0x6f, 0x95,
+    0x62, 0x55, 0x63, 0x00, 0x4e, 0x09, 0x4e, 0x4a,
+    0x90, 0xe6, 0x5d, 0x2d, 0x4e, 0xf3, 0x53, 0x07,
+    0x63, 0x70, 0x8d, 0x53, 0x62, 0x81, 0x79, 0x7a,
+    0x7a, 0x08, 0x54, 0x80, 0x6e, 0x09, 0x67, 0x08,
+    0x67, 0x33, 0x75, 0x72, 0x52, 0xb6, 0x55, 0x4d,
+    0x91, 0x14, 0x30, 0x15, 0x30, 0x2c, 0x67, 0x09,
+    0x4e, 0x8c, 0x4e, 0x89, 0x5b, 0xb9, 0x70, 0x53,
+    0x62, 0xd7, 0x76, 0xdd, 0x52, 0x57, 0x65, 0x97,
+    0x5f, 0xef, 0x53, 0x30, 0x00, 0x38, 0x4e, 0x05,
+    0x00, 0x09, 0x22, 0x01, 0x60, 0x4f, 0xae, 0x4f,
+    0xbb, 0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99, 0x50,
+    0xe7, 0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a, 0x06,
+    0x4d, 0x51, 0x54, 0x51, 0x64, 0x51, 0x77, 0x51,
+    0x1c, 0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d, 0x51,
+    0x4b, 0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc, 0x4e,
+    0xac, 0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5, 0x51,
+    0x03, 0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46, 0x52,
+    0x72, 0x52, 0x77, 0x52, 0x15, 0x35, 0x02, 0x00,
+    0x20, 0x80, 0x80, 0x00, 0x08, 0x00, 0x00, 0xc7,
+    0x52, 0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f, 0x50,
+    0x82, 0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8, 0xb8,
+    0x2c, 0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf, 0x53,
+    0x63, 0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06, 0x54,
+    0x9e, 0x54, 0x38, 0x54, 0x48, 0x54, 0x68, 0x54,
+    0xa2, 0x54, 0xf6, 0x54, 0x10, 0x55, 0x53, 0x55,
+    0x63, 0x55, 0x84, 0x55, 0x84, 0x55, 0x99, 0x55,
+    0xab, 0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16, 0x57,
+    0x06, 0x56, 0x17, 0x57, 0x51, 0x56, 0x74, 0x56,
+    0x07, 0x52, 0xee, 0x58, 0xce, 0x57, 0xf4, 0x57,
+    0x0d, 0x58, 0x8b, 0x57, 0x32, 0x58, 0x31, 0x58,
+    0xac, 0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7, 0x58,
+    0x06, 0x59, 0x1a, 0x59, 0x22, 0x59, 0x62, 0x59,
+    0xa8, 0x16, 0xea, 0x16, 0xec, 0x59, 0x1b, 0x5a,
+    0x27, 0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee, 0x36,
+    0xfc, 0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e, 0x5b,
+    0xc8, 0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7, 0x5b,
+    0xf3, 0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06, 0x5c,
+    0x53, 0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60, 0x5c,
+    0x6e, 0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4, 0x1d,
+    0x43, 0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b, 0x5d,
+    0x7c, 0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f, 0x38,
+    0xfd, 0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69, 0x5e,
+    0x62, 0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0, 0x5e,
+    0xb3, 0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92, 0xa3,
+    0xfe, 0x5e, 0x31, 0x23, 0x31, 0x23, 0x01, 0x82,
+    0x22, 0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8, 0x32,
+    0xda, 0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3, 0x38,
+    0x9a, 0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9, 0x5f,
+    0x81, 0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94, 0x60,
+    0xd4, 0x26, 0xc7, 0x60, 0x02, 0x02, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a,
+    0x00, 0x00, 0x02, 0x08, 0x00, 0x80, 0x08, 0x00,
+    0x00, 0x08, 0x80, 0x28, 0x80, 0x02, 0x00, 0x00,
+    0x02, 0x48, 0x61, 0x00, 0x04, 0x06, 0x04, 0x32,
+    0x46, 0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae, 0xc8,
+    0xd3, 0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3, 0x0c,
+    0x2b, 0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63, 0x83,
+    0x63, 0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64, 0xc5,
+    0x63, 0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64, 0x7e,
+    0x64, 0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a, 0x4f,
+    0x65, 0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65, 0xf8,
+    0x66, 0x49, 0x66, 0x19, 0x3b, 0x91, 0x66, 0x08,
+    0x3b, 0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51, 0x00,
+    0x67, 0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43, 0x17,
+    0x67, 0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67, 0x53,
+    0x67, 0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67, 0x85,
+    0x67, 0x52, 0x68, 0x85, 0x68, 0x6d, 0x34, 0x8e,
+    0x68, 0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b, 0x42,
+    0x69, 0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a, 0xa3,
+    0x36, 0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b, 0xa7,
+    0x38, 0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b, 0x9f,
+    0x6b, 0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a, 0x0b,
+    0x1d, 0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c, 0xbf,
+    0x6c, 0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d, 0x3e,
+    0x6d, 0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d, 0x78,
+    0x6d, 0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d, 0x2f,
+    0x6e, 0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e, 0xc7,
+    0x6e, 0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f, 0x5e,
+    0x3f, 0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70, 0x1e,
+    0x70, 0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70, 0x7d,
+    0x70, 0x77, 0x70, 0xad, 0x70, 0x25, 0x05, 0x45,
+    0x71, 0x63, 0x42, 0x9c, 0x71, 0xab, 0x43, 0x28,
+    0x72, 0x35, 0x72, 0x50, 0x72, 0x08, 0x46, 0x80,
+    0x72, 0x95, 0x72, 0x35, 0x47, 0x02, 0x20, 0x00,
+    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80,
+    0x00, 0x00, 0x02, 0x02, 0x80, 0x8a, 0x00, 0x00,
+    0x20, 0x00, 0x08, 0x0a, 0x00, 0x80, 0x88, 0x80,
+    0x20, 0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73, 0xac,
+    0x3e, 0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e, 0x47,
+    0x74, 0x5c, 0x74, 0x71, 0x74, 0x85, 0x74, 0xca,
+    0x74, 0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c, 0x3e,
+    0x75, 0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21, 0x10,
+    0x76, 0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50, 0xfc,
+    0x3f, 0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50, 0xf2,
+    0x50, 0x19, 0x51, 0x33, 0x51, 0x1e, 0x77, 0x1f,
+    0x77, 0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40, 0x8b,
+    0x77, 0x46, 0x40, 0x96, 0x40, 0x1d, 0x54, 0x4e,
+    0x78, 0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40, 0x26,
+    0x56, 0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56, 0x8f,
+    0x79, 0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a, 0x4a,
+    0x7a, 0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a, 0xa7,
+    0x5a, 0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b, 0xc6,
+    0x7b, 0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c, 0xd2,
+    0x7c, 0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c, 0x00,
+    0x7d, 0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43, 0xc7,
+    0x7d, 0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43, 0x28,
+    0x62, 0x47, 0x62, 0x59, 0x43, 0xd9, 0x62, 0x7a,
+    0x7f, 0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f, 0x05,
+    0x80, 0xda, 0x64, 0x23, 0x65, 0x60, 0x80, 0xa8,
+    0x65, 0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43, 0xb2,
+    0x80, 0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81, 0xb5,
+    0x5a, 0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33, 0x9c,
+    0x33, 0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f, 0x6b,
+    0x44, 0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82, 0xb3,
+    0x52, 0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82, 0xe6,
+    0x82, 0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83, 0x63,
+    0x83, 0xad, 0x83, 0x23, 0x83, 0xbd, 0x83, 0xe7,
+    0x83, 0x57, 0x84, 0x53, 0x83, 0xca, 0x83, 0xcc,
+    0x83, 0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d, 0x02,
+    0x00, 0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a, 0x00,
+    0x20, 0x80, 0x28, 0x00, 0xa8, 0x20, 0x20, 0x00,
+    0x02, 0x80, 0x22, 0x02, 0x8a, 0x08, 0x00, 0xaa,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x28, 0xd5,
+    0x6c, 0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84, 0x16,
+    0x85, 0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f, 0x5d,
+    0x45, 0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70, 0x6b,
+    0x45, 0x50, 0x86, 0x5c, 0x86, 0x67, 0x86, 0x69,
+    0x86, 0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87, 0xe2,
+    0x86, 0x79, 0x87, 0x28, 0x87, 0x6b, 0x87, 0x86,
+    0x87, 0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88, 0xf9,
+    0x45, 0x60, 0x88, 0x63, 0x88, 0x67, 0x76, 0xd7,
+    0x88, 0xde, 0x88, 0x35, 0x46, 0xfa, 0x88, 0xbb,
+    0x34, 0xae, 0x78, 0x66, 0x79, 0xbe, 0x46, 0xc7,
+    0x46, 0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b, 0x55,
+    0x8c, 0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c, 0x1b,
+    0x8d, 0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08, 0xcb,
+    0x8d, 0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08, 0xd4,
+    0x8e, 0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85, 0x94,
+    0x90, 0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87, 0x1b,
+    0x91, 0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92, 0x7c,
+    0x92, 0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b, 0x8b,
+    0x95, 0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d, 0xe6,
+    0x49, 0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97, 0x45,
+    0x91, 0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a, 0xe0,
+    0x97, 0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94, 0x0b,
+    0x98, 0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95, 0xe2,
+    0x98, 0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99, 0xc2,
+    0x99, 0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b, 0x12,
+    0x9b, 0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c, 0xed,
+    0x4c, 0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c, 0x05,
+    0xa1, 0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e, 0x56,
+    0x4d, 0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f, 0x0f,
+    0x9f, 0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6, 0x02,
+    0x88, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
+    0x28, 0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80, 0x00,
+    0x80, 0x80, 0x00, 0x0a, 0x88, 0x80, 0x00, 0x80,
+    0x00, 0x20, 0x2a, 0x00, 0x80,
 };
 
-static const uint16_t unicode_comp_table[944] = {
+static const uint16_t unicode_comp_table[945] = {
     0x4a01, 0x49c0, 0x4a02, 0x0280, 0x0281, 0x0282, 0x0283, 0x02c0,
     0x02c2, 0x0a00, 0x0284, 0x2442, 0x0285, 0x07c0, 0x0980, 0x0982,
     0x2440, 0x2280, 0x02c4, 0x2282, 0x2284, 0x2286, 0x02c6, 0x02c8,
@@ -2173,8 +2191,9 @@ static const uint16_t unicode_comp_table[944] = {
     0x5704, 0x5706, 0x5708, 0x570a, 0x570c, 0x570e, 0x5710, 0x5712,
     0x5714, 0x5716, 0x5740, 0x5742, 0x5744, 0x5780, 0x5781, 0x57c0,
     0x57c1, 0x5800, 0x5801, 0x5840, 0x5841, 0x5880, 0x5881, 0x5900,
-    0x5901, 0x5902, 0x5903, 0x5940, 0x8e40, 0x8e42, 0x8e80, 0x8ec0,
-    0x8ec1, 0x8f00, 0x8f01, 0x8f41, 0x8f40, 0x8f43, 0x8f80, 0x8f81,
+    0x5901, 0x5902, 0x5903, 0x5940, 0x8e80, 0x8e82, 0x8ec0, 0x8f00,
+    0x8f01, 0x8f40, 0x8f41, 0x8f81, 0x8f80, 0x8f83, 0x8fc0, 0x8fc1,
+    0x9000,
 };
 
 typedef enum {
@@ -2260,7 +2279,7 @@ static const char unicode_gc_name_table[] =
     "C,Other"                  "\0"
 ;
 
-static const uint8_t unicode_gc_table[3719] = {
+static const uint8_t unicode_gc_table[3790] = {
     0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13,
     0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
     0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e,
@@ -2304,8 +2323,8 @@ static const uint8_t unicode_gc_table[3719] = {
     0x06, 0x2d, 0xe5, 0x0e, 0x66, 0x04, 0xe6, 0x01,
     0x04, 0x46, 0x04, 0x86, 0x20, 0xf6, 0x07, 0x00,
     0xe5, 0x11, 0x46, 0x20, 0x16, 0x00, 0xe5, 0x03,
-    0xe0, 0x2d, 0xe5, 0x0d, 0x00, 0xe5, 0x00, 0xe0,
-    0x0d, 0xe6, 0x07, 0x1b, 0xe6, 0x18, 0x07, 0xe5,
+    0xe0, 0x2d, 0xe5, 0x0d, 0x00, 0xe5, 0x0a, 0xe0,
+    0x03, 0xe6, 0x07, 0x1b, 0xe6, 0x18, 0x07, 0xe5,
     0x2e, 0x06, 0x07, 0x06, 0x05, 0x47, 0xe6, 0x00,
     0x67, 0x06, 0x27, 0x05, 0xc6, 0xe5, 0x02, 0x26,
     0x36, 0xe9, 0x02, 0x16, 0x04, 0xe5, 0x07, 0x06,
@@ -2328,80 +2347,80 @@ static const uint8_t unicode_gc_table[3719] = {
     0x00, 0x06, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25,
     0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00,
     0x85, 0x20, 0x06, 0x05, 0x07, 0x06, 0x07, 0x66,
-    0x20, 0x27, 0x20, 0x27, 0x06, 0xe0, 0x00, 0x06,
-    0x07, 0x60, 0x25, 0x00, 0x45, 0x26, 0x20, 0xe9,
-    0x02, 0x0f, 0x05, 0xab, 0xe0, 0x02, 0x06, 0x05,
-    0x00, 0xa5, 0x40, 0x45, 0x00, 0x65, 0x40, 0x25,
-    0x00, 0x05, 0x00, 0x25, 0x40, 0x25, 0x40, 0x45,
-    0x40, 0xe5, 0x04, 0x60, 0x27, 0x06, 0x27, 0x40,
-    0x47, 0x00, 0x47, 0x06, 0x20, 0x05, 0xa0, 0x07,
-    0xe0, 0x06, 0xe9, 0x02, 0x4b, 0xaf, 0x0d, 0x0f,
-    0x80, 0x06, 0x47, 0x06, 0xe5, 0x00, 0x00, 0x45,
-    0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x08, 0x40, 0x05,
-    0x46, 0x67, 0x00, 0x46, 0x00, 0x66, 0xc0, 0x26,
-    0x00, 0x45, 0x80, 0x25, 0x26, 0x20, 0xe9, 0x02,
-    0xc0, 0x16, 0xcb, 0x0f, 0x05, 0x06, 0x27, 0x16,
-    0xe5, 0x00, 0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00,
-    0xe5, 0x02, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07,
-    0x06, 0x87, 0x00, 0x06, 0x27, 0x00, 0x27, 0x26,
-    0xc0, 0x27, 0xc0, 0x05, 0x00, 0x25, 0x26, 0x20,
-    0xe9, 0x02, 0x00, 0x25, 0xe0, 0x05, 0x26, 0x27,
-    0x00, 0xe5, 0x00, 0x00, 0x45, 0x00, 0xe5, 0x21,
-    0x26, 0x05, 0x47, 0x66, 0x00, 0x47, 0x00, 0x47,
-    0x06, 0x05, 0x0f, 0x60, 0x45, 0x07, 0xcb, 0x45,
-    0x26, 0x20, 0xe9, 0x02, 0xeb, 0x01, 0x0f, 0xa5,
-    0x20, 0x27, 0x00, 0xe5, 0x0a, 0x40, 0xe5, 0x10,
-    0x00, 0xe5, 0x01, 0x00, 0x05, 0x20, 0xc5, 0x40,
-    0x06, 0x60, 0x47, 0x46, 0x00, 0x06, 0x00, 0xe7,
-    0x00, 0xa0, 0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0,
-    0x04, 0xe5, 0x28, 0x06, 0x25, 0xc6, 0x60, 0x0d,
-    0xa5, 0x04, 0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36,
-    0xe0, 0x1d, 0x25, 0x00, 0x05, 0x00, 0x85, 0x00,
-    0xe5, 0x10, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x06,
-    0x25, 0xe6, 0x01, 0x05, 0x20, 0x85, 0x00, 0x04,
-    0x00, 0xa6, 0x20, 0xe9, 0x02, 0x20, 0x65, 0xe0,
-    0x18, 0x05, 0x4f, 0xf6, 0x07, 0x0f, 0x16, 0x4f,
-    0x26, 0xaf, 0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06,
-    0x0f, 0x06, 0x0f, 0x06, 0x12, 0x13, 0x12, 0x13,
-    0x27, 0xe5, 0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6,
-    0x06, 0x07, 0x86, 0x16, 0x26, 0x85, 0xe6, 0x03,
-    0x00, 0xe6, 0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf,
-    0x00, 0x2f, 0x96, 0x6f, 0x36, 0xe0, 0x1d, 0xe5,
-    0x23, 0x27, 0x66, 0x07, 0xa6, 0x07, 0x26, 0x27,
-    0x26, 0x05, 0xe9, 0x02, 0xb6, 0xa5, 0x27, 0x26,
-    0x65, 0x46, 0x05, 0x47, 0x25, 0xc7, 0x45, 0x66,
-    0xe5, 0x05, 0x06, 0x27, 0x26, 0xa7, 0x06, 0x05,
-    0x07, 0xe9, 0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e,
-    0x00, 0x01, 0x80, 0x01, 0x20, 0xe2, 0x23, 0x16,
-    0x04, 0x42, 0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20,
-    0xc5, 0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x21,
-    0x00, 0x65, 0x20, 0xe5, 0x19, 0x00, 0x65, 0x20,
-    0xc5, 0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x07,
-    0x00, 0xe5, 0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b,
-    0x20, 0x46, 0xf6, 0x01, 0xeb, 0x0c, 0x40, 0xe5,
-    0x08, 0xef, 0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2,
-    0x20, 0x11, 0xe5, 0x81, 0xe4, 0x0f, 0x16, 0xe5,
-    0x09, 0x17, 0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5,
-    0x43, 0x56, 0x4a, 0xe5, 0x00, 0xc0, 0xe5, 0x05,
-    0x00, 0x65, 0x46, 0xe0, 0x03, 0xe5, 0x0a, 0x46,
-    0x36, 0xe0, 0x01, 0xe5, 0x0a, 0x26, 0xe0, 0x04,
-    0xe5, 0x05, 0x00, 0x45, 0x00, 0x26, 0xe0, 0x04,
-    0xe5, 0x2c, 0x26, 0x07, 0xc6, 0xe7, 0x00, 0x06,
-    0x27, 0xe6, 0x03, 0x56, 0x04, 0x56, 0x0d, 0x05,
-    0x06, 0x20, 0xe9, 0x02, 0xa0, 0xeb, 0x02, 0xa0,
-    0xb6, 0x11, 0x76, 0x46, 0x1b, 0x00, 0xe9, 0x02,
-    0xa0, 0xe5, 0x1b, 0x04, 0xe5, 0x2d, 0xc0, 0x85,
-    0x26, 0xe5, 0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e,
-    0xe0, 0x02, 0xe5, 0x17, 0x00, 0x46, 0x67, 0x26,
-    0x47, 0x60, 0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f,
-    0x40, 0x36, 0xe9, 0x02, 0xe5, 0x16, 0x20, 0x85,
-    0xe0, 0x03, 0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0,
-    0xe9, 0x02, 0x0b, 0x40, 0xef, 0x1a, 0xe5, 0x0f,
-    0x26, 0x27, 0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07,
-    0x06, 0x07, 0xc6, 0x00, 0x06, 0x07, 0x06, 0x27,
-    0xe6, 0x00, 0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9,
-    0x02, 0xa0, 0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6,
-    0x20, 0xe6, 0x06, 0x08, 0xe0, 0x39, 0x66, 0x07,
+    0x20, 0x27, 0x20, 0x27, 0x06, 0xc0, 0x26, 0x07,
+    0x60, 0x25, 0x00, 0x45, 0x26, 0x20, 0xe9, 0x02,
+    0x0f, 0x05, 0xab, 0xe0, 0x02, 0x06, 0x05, 0x00,
+    0xa5, 0x40, 0x45, 0x00, 0x65, 0x40, 0x25, 0x00,
+    0x05, 0x00, 0x25, 0x40, 0x25, 0x40, 0x45, 0x40,
+    0xe5, 0x04, 0x60, 0x27, 0x06, 0x27, 0x40, 0x47,
+    0x00, 0x47, 0x06, 0x20, 0x05, 0xa0, 0x07, 0xe0,
+    0x06, 0xe9, 0x02, 0x4b, 0xaf, 0x0d, 0x0f, 0x80,
+    0x06, 0x47, 0x06, 0xe5, 0x00, 0x00, 0x45, 0x00,
+    0xe5, 0x0f, 0x00, 0xe5, 0x08, 0x40, 0x05, 0x46,
+    0x67, 0x00, 0x46, 0x00, 0x66, 0xc0, 0x26, 0x00,
+    0x45, 0x80, 0x25, 0x26, 0x20, 0xe9, 0x02, 0xc0,
+    0x16, 0xcb, 0x0f, 0x05, 0x06, 0x27, 0x16, 0xe5,
+    0x00, 0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5,
+    0x02, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07, 0x06,
+    0x87, 0x00, 0x06, 0x27, 0x00, 0x27, 0x26, 0xc0,
+    0x27, 0xc0, 0x05, 0x00, 0x25, 0x26, 0x20, 0xe9,
+    0x02, 0x00, 0x25, 0xe0, 0x05, 0x26, 0x27, 0xe5,
+    0x01, 0x00, 0x45, 0x00, 0xe5, 0x21, 0x26, 0x05,
+    0x47, 0x66, 0x00, 0x47, 0x00, 0x47, 0x06, 0x05,
+    0x0f, 0x60, 0x45, 0x07, 0xcb, 0x45, 0x26, 0x20,
+    0xe9, 0x02, 0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06,
+    0x27, 0x00, 0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00,
+    0xe5, 0x01, 0x00, 0x05, 0x20, 0xc5, 0x40, 0x06,
+    0x60, 0x47, 0x46, 0x00, 0x06, 0x00, 0xe7, 0x00,
+    0xa0, 0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0, 0x04,
+    0xe5, 0x28, 0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5,
+    0x04, 0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0,
+    0x1d, 0x25, 0x00, 0x05, 0x00, 0x85, 0x00, 0xe5,
+    0x10, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x06, 0x25,
+    0xe6, 0x01, 0x05, 0x20, 0x85, 0x00, 0x04, 0x00,
+    0xa6, 0x20, 0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18,
+    0x05, 0x4f, 0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26,
+    0xaf, 0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f,
+    0x06, 0x0f, 0x06, 0x12, 0x13, 0x12, 0x13, 0x27,
+    0xe5, 0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06,
+    0x07, 0x86, 0x16, 0x26, 0x85, 0xe6, 0x03, 0x00,
+    0xe6, 0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf, 0x00,
+    0x2f, 0x96, 0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23,
+    0x27, 0x66, 0x07, 0xa6, 0x07, 0x26, 0x27, 0x26,
+    0x05, 0xe9, 0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65,
+    0x46, 0x05, 0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5,
+    0x05, 0x06, 0x27, 0x26, 0xa7, 0x06, 0x05, 0x07,
+    0xe9, 0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00,
+    0x01, 0x80, 0x01, 0x20, 0xe2, 0x23, 0x16, 0x04,
+    0x42, 0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5,
+    0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x21, 0x00,
+    0x65, 0x20, 0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5,
+    0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x07, 0x00,
+    0xe5, 0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20,
+    0x46, 0xf6, 0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08,
+    0xef, 0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20,
+    0x11, 0xe5, 0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09,
+    0x17, 0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5, 0x43,
+    0x56, 0x4a, 0xe5, 0x00, 0xc0, 0xe5, 0x05, 0x00,
+    0x65, 0x46, 0xe0, 0x03, 0xe5, 0x0a, 0x46, 0x36,
+    0xe0, 0x01, 0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5,
+    0x05, 0x00, 0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5,
+    0x2c, 0x26, 0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27,
+    0xe6, 0x03, 0x56, 0x04, 0x56, 0x0d, 0x05, 0x06,
+    0x20, 0xe9, 0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6,
+    0x11, 0x76, 0x46, 0x1b, 0x00, 0xe9, 0x02, 0xa0,
+    0xe5, 0x1b, 0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26,
+    0xe5, 0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0,
+    0x02, 0xe5, 0x17, 0x00, 0x46, 0x67, 0x26, 0x47,
+    0x60, 0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40,
+    0x36, 0xe9, 0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0,
+    0x03, 0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9,
+    0x02, 0x0b, 0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26,
+    0x27, 0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06,
+    0x07, 0xc6, 0x00, 0x06, 0x07, 0x06, 0x27, 0xe6,
+    0x00, 0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02,
+    0xa0, 0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20,
+    0xe6, 0x06, 0x08, 0x26, 0xe0, 0x37, 0x66, 0x07,
     0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87,
     0x06, 0x27, 0xc5, 0x60, 0xe9, 0x02, 0xd6, 0xef,
     0x02, 0xe6, 0x01, 0xef, 0x01, 0x40, 0x26, 0x07,
@@ -2461,7 +2480,7 @@ static const uint8_t unicode_gc_table[3719] = {
     0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12,
     0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec,
     0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac,
-    0xef, 0x1f, 0x20, 0xef, 0x18, 0x20, 0xef, 0x60,
+    0xef, 0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61,
     0xe1, 0x27, 0x00, 0xe2, 0x27, 0x00, 0x5f, 0x21,
     0x22, 0xdf, 0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82,
     0x24, 0x41, 0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f,
@@ -2475,257 +2494,266 @@ static const uint8_t unicode_gc_table[3719] = {
     0x11, 0x36, 0x11, 0x16, 0x14, 0x15, 0x36, 0x14,
     0x15, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
     0x13, 0x96, 0x04, 0xf6, 0x02, 0x31, 0x76, 0x11,
-    0x16, 0x12, 0xf6, 0x05, 0xe0, 0x28, 0xef, 0x12,
-    0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80, 0x4e,
-    0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56, 0x0f,
-    0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0x12,
-    0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11, 0x84,
-    0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00, 0xe5,
-    0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5,
-    0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23, 0x00,
-    0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5,
-    0x13, 0x80, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08,
-    0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb,
-    0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02,
-    0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5,
-    0x99, 0x2e, 0xe0, 0x02, 0xef, 0x38, 0xe5, 0xc0,
-    0x11, 0x68, 0xe0, 0x08, 0xe5, 0x0d, 0x04, 0xe5,
-    0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01, 0xe5,
-    0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84, 0x04, 0x56,
-    0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c, 0xff,
-    0x26, 0x05, 0x06, 0x48, 0x16, 0xe6, 0x02, 0x16,
-    0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e, 0xea,
-    0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee, 0x0f, 0xe4,
-    0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36, 0x04,
-    0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04, 0x2e, 0x7f,
-    0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02, 0x81,
-    0x02, 0xff, 0x02, 0x20, 0x5f, 0x21, 0xe0, 0x28,
-    0x05, 0x24, 0x02, 0xc5, 0x06, 0x45, 0x06, 0x65,
-    0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07, 0x6f, 0x60,
-    0xab, 0x2f, 0x0d, 0x0f, 0xa0, 0xe5, 0x2c, 0x76,
-    0xe0, 0x00, 0x27, 0xe5, 0x2a, 0xe7, 0x08, 0x26,
-    0xe0, 0x00, 0x36, 0xe9, 0x02, 0xa0, 0xe6, 0x0a,
-    0xa5, 0x56, 0x05, 0x16, 0x25, 0x06, 0xe9, 0x02,
-    0xe5, 0x14, 0xe6, 0x00, 0x36, 0xe5, 0x0f, 0xe6,
-    0x03, 0x27, 0xe0, 0x03, 0x16, 0xe5, 0x15, 0x40,
-    0x46, 0x07, 0xe5, 0x27, 0x06, 0x27, 0x66, 0x27,
-    0x26, 0x47, 0xf6, 0x05, 0x00, 0x04, 0xe9, 0x02,
-    0x60, 0x36, 0x85, 0x06, 0x04, 0xe5, 0x01, 0xe9,
-    0x02, 0x85, 0x00, 0xe5, 0x21, 0xa6, 0x27, 0x26,
-    0x27, 0x26, 0xe0, 0x01, 0x45, 0x06, 0xe5, 0x00,
-    0x06, 0x07, 0x20, 0xe9, 0x02, 0x20, 0x76, 0xe5,
-    0x08, 0x04, 0xa5, 0x4f, 0x05, 0x07, 0x06, 0x07,
-    0xe5, 0x2a, 0x06, 0x05, 0x46, 0x25, 0x26, 0x85,
-    0x26, 0x05, 0x06, 0x05, 0xe0, 0x10, 0x25, 0x04,
-    0x36, 0xe5, 0x03, 0x07, 0x26, 0x27, 0x36, 0x05,
-    0x24, 0x07, 0x06, 0xe0, 0x02, 0xa5, 0x20, 0xa5,
-    0x20, 0xa5, 0xe0, 0x01, 0xc5, 0x00, 0xc5, 0x00,
-    0xe2, 0x23, 0x0e, 0x64, 0xe2, 0x00, 0xe0, 0x00,
-    0xe2, 0x48, 0xe5, 0x1b, 0x27, 0x06, 0x27, 0x06,
-    0x27, 0x16, 0x07, 0x06, 0x20, 0xe9, 0x02, 0xa0,
-    0xe5, 0xab, 0x1c, 0xe0, 0x04, 0xe5, 0x0f, 0x60,
-    0xe5, 0x29, 0x60, 0xfc, 0x87, 0x78, 0xfd, 0x98,
-    0x78, 0xe5, 0x80, 0xe6, 0x20, 0xe5, 0x62, 0xe0,
-    0x1e, 0xc2, 0xe0, 0x04, 0x82, 0x80, 0x05, 0x06,
-    0xe5, 0x02, 0x0c, 0xe5, 0x05, 0x00, 0x85, 0x00,
-    0x05, 0x00, 0x25, 0x00, 0x25, 0x00, 0xe5, 0x64,
-    0xee, 0x08, 0xe0, 0x09, 0xe5, 0x80, 0xe3, 0x13,
-    0x12, 0xe0, 0x08, 0xe5, 0x38, 0x20, 0xe5, 0x2e,
-    0xe0, 0x20, 0xe5, 0x04, 0x0d, 0x0f, 0x20, 0xe6,
-    0x08, 0xd6, 0x12, 0x13, 0x16, 0xa0, 0xe6, 0x08,
-    0x16, 0x31, 0x30, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x36, 0x12, 0x13, 0x76, 0x50,
-    0x56, 0x00, 0x76, 0x11, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16,
-    0x0d, 0x36, 0x60, 0x85, 0x00, 0xe5, 0x7f, 0x20,
-    0x1b, 0x00, 0x56, 0x0d, 0x56, 0x12, 0x13, 0x16,
-    0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36, 0x4c,
-    0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e, 0x10,
-    0x0e, 0xe2, 0x12, 0x12, 0x0c, 0x13, 0x0c, 0x12,
-    0x13, 0x16, 0x12, 0x13, 0x36, 0xe5, 0x02, 0x04,
-    0xe5, 0x25, 0x24, 0xe5, 0x17, 0x40, 0xa5, 0x20,
-    0xa5, 0x20, 0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c,
-    0x0e, 0x0f, 0x2d, 0x00, 0x0f, 0x6c, 0x2f, 0xe0,
-    0x02, 0x5b, 0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5,
-    0x12, 0x00, 0xe5, 0x0b, 0x00, 0x25, 0x00, 0xe5,
-    0x07, 0x20, 0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73,
-    0x80, 0x56, 0x60, 0xeb, 0x25, 0x40, 0xef, 0x01,
-    0xea, 0x2d, 0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00,
-    0xef, 0x04, 0x60, 0x0f, 0xe0, 0x27, 0xef, 0x25,
-    0x06, 0xe0, 0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29,
-    0xe0, 0x07, 0x06, 0xeb, 0x13, 0x60, 0xe5, 0x18,
-    0x6b, 0xe0, 0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00,
-    0x0a, 0x80, 0xe5, 0x1e, 0x86, 0x80, 0xe5, 0x16,
-    0x00, 0x16, 0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16,
-    0x8a, 0xe0, 0x22, 0xe1, 0x20, 0xe2, 0x20, 0xe5,
-    0x46, 0x20, 0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60,
-    0xe2, 0x1c, 0x60, 0xe5, 0x20, 0xe0, 0x00, 0xe5,
-    0x2c, 0xe0, 0x03, 0x16, 0xe0, 0x80, 0x08, 0xe5,
-    0x80, 0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02,
-    0xe5, 0x00, 0xe0, 0x80, 0x10, 0xa5, 0x20, 0x05,
-    0x00, 0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20,
-    0xe5, 0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f,
-    0x2f, 0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01,
-    0xe0, 0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b,
-    0xe5, 0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80,
-    0x16, 0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25,
-    0xeb, 0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00,
-    0x26, 0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5,
-    0x15, 0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0,
-    0xf6, 0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5,
-    0x15, 0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5,
-    0x14, 0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5,
-    0x2e, 0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00,
-    0xe5, 0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0,
-    0x76, 0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41,
-    0xe0, 0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b,
-    0xc0, 0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9,
-    0x02, 0xe0, 0x80, 0x9e, 0xeb, 0x17, 0xe0, 0x79,
-    0xe5, 0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00, 0xe5,
-    0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x7e, 0xe5,
+    0x16, 0x12, 0xf6, 0x05, 0x2f, 0x16, 0xe0, 0x25,
+    0xef, 0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef,
+    0x80, 0x4e, 0xe0, 0x12, 0xef, 0x04, 0x60, 0x17,
+    0x56, 0x0f, 0x04, 0x05, 0x0a, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x2f,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x11, 0x12, 0x33, 0x0f, 0xea, 0x01, 0x66, 0x27,
+    0x11, 0x84, 0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f,
+    0x00, 0xe5, 0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05,
+    0x11, 0xe5, 0x52, 0x16, 0x44, 0x05, 0x80, 0xe5,
+    0x23, 0x00, 0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef,
+    0x02, 0xe5, 0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5,
+    0x08, 0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16,
+    0xeb, 0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb,
+    0x02, 0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8,
+    0xe5, 0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11,
+    0x75, 0x40, 0xe5, 0x0d, 0x04, 0xe5, 0x83, 0xef,
+    0x40, 0xef, 0x2f, 0xe0, 0x01, 0xe5, 0x20, 0xa4,
+    0x36, 0xe5, 0x80, 0x84, 0x04, 0x56, 0xe5, 0x08,
+    0xe9, 0x02, 0x25, 0xe0, 0x0c, 0xff, 0x26, 0x05,
+    0x06, 0x48, 0x16, 0xe6, 0x02, 0x16, 0x04, 0xff,
+    0x14, 0x24, 0x26, 0xe5, 0x3e, 0xea, 0x02, 0x26,
+    0xb6, 0xe0, 0x00, 0xee, 0x0f, 0xe4, 0x01, 0x2e,
+    0xff, 0x06, 0x22, 0xff, 0x36, 0x04, 0xe2, 0x00,
+    0x9f, 0xff, 0x02, 0x04, 0x2e, 0x7f, 0x05, 0x7f,
+    0x22, 0xff, 0x0d, 0x61, 0x02, 0x81, 0x02, 0xff,
+    0x02, 0x20, 0x5f, 0x41, 0x02, 0x3f, 0xe0, 0x22,
+    0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06, 0x45, 0x06,
+    0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07, 0x6f,
+    0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f, 0xa0, 0xe5,
+    0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5, 0x2a, 0xe7,
+    0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9, 0x02, 0xa0,
+    0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16, 0x25, 0x06,
+    0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00, 0x36, 0xe5,
+    0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03, 0x16, 0xe5,
+    0x15, 0x40, 0x46, 0x07, 0xe5, 0x27, 0x06, 0x27,
+    0x66, 0x27, 0x26, 0x47, 0xf6, 0x05, 0x00, 0x04,
+    0xe9, 0x02, 0x60, 0x36, 0x85, 0x06, 0x04, 0xe5,
+    0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5, 0x21, 0xa6,
+    0x27, 0x26, 0x27, 0x26, 0xe0, 0x01, 0x45, 0x06,
+    0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9, 0x02, 0x20,
+    0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f, 0x05, 0x07,
+    0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05, 0x46, 0x25,
+    0x26, 0x85, 0x26, 0x05, 0x06, 0x05, 0xe0, 0x10,
+    0x25, 0x04, 0x36, 0xe5, 0x03, 0x07, 0x26, 0x27,
+    0x36, 0x05, 0x24, 0x07, 0x06, 0xe0, 0x02, 0xa5,
+    0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01, 0xc5, 0x00,
+    0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64, 0xe2, 0x01,
+    0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5, 0x1b, 0x27,
+    0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06, 0x20,
+    0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c, 0xe0, 0x04,
+    0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc, 0x87,
+    0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80, 0xe6, 0x20,
+    0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04, 0x82,
+    0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c, 0xe5, 0x05,
+    0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00, 0x25,
+    0x00, 0xe5, 0x64, 0xee, 0x08, 0xe0, 0x09, 0xe5,
+    0x80, 0xe3, 0x13, 0x12, 0xe0, 0x08, 0xe5, 0x38,
+    0x20, 0xe5, 0x2e, 0xe0, 0x20, 0xe5, 0x04, 0x0d,
+    0x0f, 0x20, 0xe6, 0x08, 0xd6, 0x12, 0x13, 0x16,
+    0xa0, 0xe6, 0x08, 0x16, 0x31, 0x30, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x36, 0x12,
+    0x13, 0x76, 0x50, 0x56, 0x00, 0x76, 0x11, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x56, 0x0c, 0x11,
+    0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60, 0x85, 0x00,
+    0xe5, 0x7f, 0x20, 0x1b, 0x00, 0x56, 0x0d, 0x56,
+    0x12, 0x13, 0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9,
+    0x02, 0x36, 0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16,
+    0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12, 0x12, 0x0c,
+    0x13, 0x0c, 0x12, 0x13, 0x16, 0x12, 0x13, 0x36,
+    0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24, 0xe5, 0x17,
+    0x40, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0x20, 0x45,
+    0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d, 0x00, 0x0f,
+    0x6c, 0x2f, 0xe0, 0x02, 0x5b, 0x2f, 0x20, 0xe5,
+    0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5, 0x0b, 0x00,
+    0x25, 0x00, 0xe5, 0x07, 0x20, 0xe5, 0x06, 0xe0,
+    0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60, 0xeb, 0x25,
+    0x40, 0xef, 0x01, 0xea, 0x2d, 0x6b, 0xef, 0x09,
+    0x2b, 0x4f, 0x00, 0xef, 0x05, 0x40, 0x0f, 0xe0,
+    0x27, 0xef, 0x25, 0x06, 0xe0, 0x7a, 0xe5, 0x15,
+    0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06, 0xeb, 0x13,
+    0x60, 0xe5, 0x18, 0x6b, 0xe0, 0x01, 0xe5, 0x0c,
+    0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5, 0x1e, 0x86,
+    0x80, 0xe5, 0x16, 0x00, 0x16, 0xe5, 0x1c, 0x60,
+    0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22, 0xe1, 0x20,
+    0xe2, 0x20, 0xe5, 0x46, 0x20, 0xe9, 0x02, 0xa0,
+    0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60, 0xe5, 0x20,
+    0xe0, 0x00, 0xe5, 0x2c, 0xe0, 0x03, 0x16, 0xe0,
+    0x80, 0x08, 0xe5, 0x80, 0xaf, 0xe0, 0x01, 0xe5,
+    0x0e, 0xe0, 0x02, 0xe5, 0x00, 0xe0, 0x80, 0x10,
+    0xa5, 0x20, 0x05, 0x00, 0xe5, 0x24, 0x00, 0x25,
+    0x40, 0x05, 0x20, 0xe5, 0x0f, 0x00, 0x16, 0xeb,
+    0x00, 0xe5, 0x0f, 0x2f, 0xcb, 0xe5, 0x17, 0xe0,
+    0x00, 0xeb, 0x01, 0xe0, 0x28, 0xe5, 0x0b, 0x00,
+    0x25, 0x80, 0x8b, 0xe5, 0x0e, 0xab, 0x40, 0x16,
+    0xe5, 0x12, 0x80, 0x16, 0xe0, 0x38, 0xe5, 0x30,
+    0x60, 0x2b, 0x25, 0xeb, 0x08, 0x20, 0xeb, 0x26,
+    0x05, 0x46, 0x00, 0x26, 0x80, 0x66, 0x65, 0x00,
+    0x45, 0x00, 0xe5, 0x15, 0x20, 0x46, 0x60, 0x06,
+    0xeb, 0x01, 0xc0, 0xf6, 0x01, 0xc0, 0xe5, 0x15,
+    0x2b, 0x16, 0xe5, 0x15, 0x4b, 0xe0, 0x18, 0xe5,
+    0x00, 0x0f, 0xe5, 0x14, 0x26, 0x60, 0x8b, 0xd6,
+    0xe0, 0x01, 0xe5, 0x2e, 0x40, 0xd6, 0xe5, 0x0e,
+    0x20, 0xeb, 0x00, 0xe5, 0x0b, 0x80, 0xeb, 0x00,
+    0xe5, 0x0a, 0xc0, 0x76, 0xe0, 0x04, 0xcb, 0xe0,
+    0x48, 0xe5, 0x41, 0xe0, 0x2f, 0xe1, 0x2b, 0xe0,
+    0x05, 0xe2, 0x2b, 0xc0, 0xab, 0xe5, 0x1c, 0x66,
+    0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x9e, 0xeb,
+    0x17, 0x00, 0xe5, 0x22, 0x00, 0x26, 0x11, 0x20,
+    0x25, 0xe0, 0x46, 0xe5, 0x15, 0xeb, 0x02, 0x05,
+    0xe0, 0x00, 0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96,
+    0xe0, 0x4e, 0xe5, 0x0d, 0xcb, 0xe0, 0x0c, 0xe5,
     0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07, 0xe5, 0x2d,
     0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c, 0xe9, 0x02,
     0xe0, 0x07, 0x46, 0x07, 0xe5, 0x25, 0x47, 0x66,
     0x27, 0x26, 0x36, 0x1b, 0x76, 0xe0, 0x03, 0x1b,
     0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0, 0x46,
     0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9,
-    0x02, 0x76, 0x05, 0x27, 0xe0, 0x01, 0xe5, 0x1b,
-    0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07, 0xe5,
-    0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76, 0x66,
-    0x16, 0x20, 0xe9, 0x02, 0x05, 0x16, 0x05, 0x56,
-    0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a, 0x00,
-    0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07, 0x26,
-    0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00, 0x05, 0x00,
-    0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02, 0x16,
-    0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00, 0x80,
-    0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5, 0x00,
-    0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00,
-    0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27, 0x06,
-    0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05, 0xa0,
-    0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40, 0x86,
-    0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47, 0xe6, 0x00,
-    0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9, 0x02,
-    0x00, 0x16, 0x00, 0x16, 0x06, 0x05, 0xe0, 0x18,
-    0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67, 0x26,
-    0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9,
-    0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47, 0x66,
-    0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f, 0x65,
-    0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6, 0x00,
-    0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03,
-    0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b, 0xe5,
-    0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06,
-    0x05, 0xc0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5, 0x13,
-    0x20, 0x46, 0x27, 0x66, 0x07, 0x86, 0x60, 0xe9,
-    0x02, 0x2b, 0x56, 0x0f, 0xe0, 0x80, 0x38, 0xe5,
-    0x24, 0x47, 0xe6, 0x01, 0x07, 0x26, 0x16, 0xe0,
-    0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9, 0x02, 0xeb,
-    0x01, 0xe0, 0x04, 0x05, 0xe0, 0x80, 0x18, 0xe5,
-    0x00, 0x20, 0xe5, 0x1f, 0x47, 0x66, 0x20, 0x26,
-    0x67, 0x06, 0x05, 0x16, 0x05, 0x07, 0xe0, 0x13,
-    0x05, 0xe6, 0x02, 0xe5, 0x20, 0xa6, 0x07, 0x05,
-    0x66, 0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05, 0xa6,
-    0x27, 0x46, 0xe5, 0x26, 0xe6, 0x05, 0x07, 0x26,
-    0x56, 0x05, 0x96, 0xe0, 0x15, 0xe5, 0x31, 0xe0,
-    0x80, 0x7f, 0xe5, 0x01, 0x00, 0xe5, 0x1d, 0x07,
-    0xc6, 0x00, 0xa6, 0x07, 0x06, 0x05, 0x96, 0xe0,
-    0x02, 0xe9, 0x02, 0xeb, 0x0b, 0x40, 0x36, 0xe5,
-    0x16, 0x20, 0xe6, 0x0e, 0x00, 0x07, 0xc6, 0x07,
-    0x26, 0x07, 0x26, 0xe0, 0x41, 0xc5, 0x00, 0x25,
-    0x00, 0xe5, 0x1e, 0xa6, 0x40, 0x06, 0x00, 0x26,
-    0x00, 0xc6, 0x05, 0x06, 0xe0, 0x00, 0xe9, 0x02,
-    0xa0, 0xa5, 0x00, 0x25, 0x00, 0xe5, 0x18, 0x87,
-    0x00, 0x26, 0x00, 0x27, 0x06, 0x07, 0x06, 0x05,
-    0xc0, 0xe9, 0x02, 0xe0, 0x80, 0xae, 0xe5, 0x0b,
-    0x26, 0x27, 0x36, 0xe0, 0x80, 0x3f, 0xeb, 0x0d,
-    0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16,
-    0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00,
-    0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x8a,
-    0x34, 0xe5, 0x83, 0xa7, 0x00, 0xfb, 0x01, 0xe0,
-    0x8f, 0x3f, 0xe5, 0x81, 0xbf, 0xe0, 0xa1, 0x31,
-    0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00, 0xe9,
-    0x02, 0x60, 0x36, 0xe0, 0x58, 0xe5, 0x16, 0x20,
-    0x86, 0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96,
-    0x6f, 0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02,
-    0x00, 0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b,
-    0xe0, 0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb,
-    0x0f, 0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06,
-    0x05, 0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0,
-    0x38, 0x24, 0x16, 0x04, 0xe0, 0x14, 0xe5, 0x97,
-    0x70, 0xe0, 0x00, 0xe5, 0x82, 0x6b, 0xe0, 0xa4,
-    0x85, 0xe5, 0x80, 0x97, 0xe0, 0x29, 0x45, 0xe0,
-    0x09, 0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0,
-    0x88, 0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05, 0x40,
-    0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26,
-    0x16, 0x7b, 0xe0, 0x92, 0xd4, 0xef, 0x80, 0x6e,
-    0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27,
-    0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6, 0x00, 0x2f,
-    0xc6, 0xef, 0x16, 0x66, 0xef, 0x33, 0xe0, 0x0f,
-    0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x80, 0x12, 0xeb,
-    0x0c, 0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb,
-    0x11, 0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
-    0x12, 0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2,
-    0x12, 0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21,
-    0x20, 0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02,
-    0x00, 0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2,
-    0x12, 0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00,
-    0xc1, 0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00,
-    0x81, 0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12,
-    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12,
-    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12,
-    0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14,
-    0x20, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2,
+    0x02, 0x76, 0x05, 0x27, 0x05, 0xe0, 0x00, 0xe5,
+    0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07,
+    0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76,
+    0x66, 0x16, 0x07, 0x06, 0xe9, 0x02, 0x05, 0x16,
+    0x05, 0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5,
+    0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06,
+    0x07, 0x26, 0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00,
+    0x05, 0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5,
+    0x02, 0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6,
+    0x00, 0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00,
+    0xe5, 0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00,
+    0xc5, 0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05,
+    0x27, 0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20,
+    0x05, 0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6,
+    0x40, 0x86, 0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47,
+    0xe6, 0x00, 0x27, 0x46, 0x07, 0x06, 0x65, 0x96,
+    0xe9, 0x02, 0x36, 0x00, 0x16, 0x06, 0x45, 0xe0,
+    0x16, 0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67,
+    0x26, 0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00,
+    0xe9, 0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47,
+    0x66, 0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f,
+    0x65, 0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6,
+    0x00, 0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0,
+    0x03, 0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b,
+    0xe5, 0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07,
+    0x06, 0x05, 0xc0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5,
+    0x13, 0x20, 0x46, 0x27, 0x66, 0x07, 0x86, 0x60,
+    0xe9, 0x02, 0x2b, 0x56, 0x0f, 0xe0, 0x80, 0x38,
+    0xe5, 0x24, 0x47, 0xe6, 0x01, 0x07, 0x26, 0x16,
+    0xe0, 0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9, 0x02,
+    0xeb, 0x01, 0xe0, 0x04, 0xe5, 0x00, 0x20, 0x05,
+    0x20, 0xe5, 0x00, 0x00, 0x25, 0x00, 0xe5, 0x10,
+    0xa7, 0x00, 0x27, 0x20, 0x26, 0x07, 0x06, 0x05,
+    0x07, 0x05, 0x07, 0x06, 0x56, 0xe0, 0x01, 0xe9,
+    0x02, 0xe0, 0x3e, 0xe5, 0x00, 0x20, 0xe5, 0x1f,
+    0x47, 0x66, 0x20, 0x26, 0x67, 0x06, 0x05, 0x16,
+    0x05, 0x07, 0xe0, 0x13, 0x05, 0xe6, 0x02, 0xe5,
+    0x20, 0xa6, 0x07, 0x05, 0x66, 0xf6, 0x00, 0x06,
+    0xe0, 0x00, 0x05, 0xa6, 0x27, 0x46, 0xe5, 0x26,
+    0xe6, 0x05, 0x07, 0x26, 0x56, 0x05, 0x96, 0xe0,
+    0x15, 0xe5, 0x31, 0xe0, 0x80, 0x7f, 0xe5, 0x01,
+    0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6, 0x07,
+    0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02, 0xeb,
+    0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6, 0x0e,
+    0x00, 0x07, 0xc6, 0x07, 0x26, 0x07, 0x26, 0xe0,
+    0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e, 0xa6,
+    0x40, 0x06, 0x00, 0x26, 0x00, 0xc6, 0x05, 0x06,
+    0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00, 0x25,
+    0x00, 0xe5, 0x18, 0x87, 0x00, 0x26, 0x00, 0x27,
+    0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02, 0xe0,
+    0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36, 0xe0,
+    0x80, 0x2f, 0x05, 0xe0, 0x07, 0xeb, 0x0d, 0xef,
+    0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16, 0xe5,
+    0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00, 0x96,
+    0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x8a, 0x34,
+    0xe5, 0x83, 0xa7, 0x00, 0xfb, 0x01, 0xe0, 0x8f,
+    0x3f, 0xe5, 0x81, 0xbf, 0xe0, 0xa1, 0x31, 0xe5,
+    0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00, 0xe9, 0x02,
+    0x60, 0x36, 0xe0, 0x58, 0xe5, 0x16, 0x20, 0x86,
+    0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f,
+    0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00,
+    0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0,
+    0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb, 0x0f,
+    0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06, 0x05,
+    0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38,
+    0x24, 0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0xe0,
+    0x06, 0xe5, 0x97, 0x70, 0xe0, 0x00, 0xe5, 0x84,
+    0x4e, 0xe0, 0x22, 0xe5, 0x01, 0xe0, 0xa2, 0x6f,
+    0xe5, 0x80, 0x97, 0xe0, 0x29, 0x45, 0xe0, 0x09,
+    0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0, 0x88,
+    0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05, 0x40, 0xe5,
+    0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26, 0x16,
+    0x7b, 0xe0, 0x92, 0xd4, 0xef, 0x80, 0x6e, 0xe0,
+    0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27, 0x46,
+    0x4f, 0xa7, 0xfb, 0x00, 0xe6, 0x00, 0x2f, 0xc6,
+    0xef, 0x16, 0x66, 0xef, 0x33, 0xe0, 0x0f, 0xef,
+    0x3a, 0x46, 0x0f, 0xe0, 0x80, 0x12, 0xeb, 0x0c,
+    0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11,
+    0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
+    0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12,
+    0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21, 0x20,
+    0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02, 0x00,
+    0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12,
+    0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1,
+    0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00, 0x81,
+    0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20,
     0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1,
     0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11,
     0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
-    0xe2, 0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a,
-    0xef, 0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a,
-    0xef, 0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96,
-    0xe0, 0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x84,
-    0xc8, 0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6, 0x00,
-    0x26, 0x00, 0x86, 0xe0, 0x80, 0x4d, 0xe5, 0x25,
-    0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05,
-    0x0f, 0xe0, 0x80, 0xe8, 0xe5, 0x24, 0x66, 0xe9,
-    0x02, 0x80, 0x0d, 0xe0, 0x84, 0x78, 0xe5, 0x80,
-    0x3d, 0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1,
-    0x1a, 0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02,
-    0x60, 0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f,
-    0x4b, 0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f,
-    0xeb, 0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5,
-    0x13, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
-    0xe5, 0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05,
-    0xa0, 0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05,
-    0x00, 0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05,
-    0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
-    0x00, 0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5,
-    0x00, 0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5,
-    0x02, 0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85,
-    0x00, 0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80,
-    0x86, 0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04,
-    0xef, 0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07,
-    0x00, 0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0x40,
-    0xef, 0x55, 0x40, 0xef, 0x35, 0xe0, 0x31, 0xef,
-    0x15, 0xe0, 0x05, 0xef, 0x24, 0x60, 0xef, 0x01,
-    0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0, 0x80, 0x12,
-    0xef, 0x80, 0x73, 0x8e, 0xef, 0x82, 0x4e, 0xe0,
-    0x02, 0xef, 0x05, 0x40, 0xef, 0x03, 0x80, 0xef,
-    0x6c, 0xe0, 0x04, 0xef, 0x51, 0xc0, 0xef, 0x04,
-    0xe0, 0x0c, 0xef, 0x04, 0x60, 0xef, 0x30, 0xe0,
-    0x00, 0xef, 0x02, 0xa0, 0xef, 0x20, 0xe0, 0x00,
-    0xef, 0x16, 0xe0, 0x4a, 0xef, 0x04, 0x00, 0xef,
-    0x5d, 0x00, 0x6f, 0x40, 0xef, 0x21, 0x20, 0xaf,
-    0x40, 0xef, 0x15, 0x20, 0xef, 0x7f, 0xe0, 0x04,
-    0xef, 0x06, 0x20, 0x6f, 0x60, 0x4f, 0x80, 0x4f,
-    0xe0, 0x05, 0xaf, 0xe0, 0x84, 0xe2, 0xe5, 0xc0,
-    0x66, 0x4f, 0xe0, 0x21, 0xe5, 0x8f, 0xad, 0xe0,
-    0x03, 0xe5, 0x80, 0x56, 0x20, 0xe5, 0x95, 0xfa,
-    0xe0, 0x06, 0xe5, 0x9c, 0xa9, 0xe0, 0x8b, 0x97,
-    0xe5, 0x81, 0x96, 0xe0, 0xca, 0xc5, 0x5b, 0x1b,
-    0xe0, 0x16, 0xfb, 0x58, 0xe0, 0x78, 0xe6, 0x80,
-    0x68, 0xe0, 0xc0, 0xbd, 0x88, 0xfd, 0xc0, 0xbf,
-    0x76, 0x20, 0xfd, 0xc0, 0xbf, 0x76, 0x20,
+    0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2,
+    0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef,
+    0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef,
+    0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0,
+    0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x84, 0xc8,
+    0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6, 0x00, 0x26,
+    0x00, 0x86, 0xe0, 0x80, 0x4d, 0xe5, 0x25, 0x40,
+    0xc6, 0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05, 0x0f,
+    0xe0, 0x80, 0xe8, 0xe5, 0x24, 0x66, 0xe9, 0x02,
+    0x80, 0x0d, 0xe0, 0x84, 0x78, 0xe5, 0x80, 0x3d,
+    0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a,
+    0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02, 0x60,
+    0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f, 0x4b,
+    0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f, 0xeb,
+    0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5, 0x13,
+    0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0xe5,
+    0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05, 0xa0,
+    0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00,
+    0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
+    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00,
+    0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5, 0x00,
+    0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5, 0x02,
+    0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85, 0x00,
+    0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80, 0x86,
+    0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef,
+    0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07, 0x00,
+    0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0xef, 0x80,
+    0x19, 0xe0, 0x30, 0xef, 0x15, 0xe0, 0x05, 0xef,
+    0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0, 0x06,
+    0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73, 0x8e,
+    0xef, 0x82, 0x50, 0xe0, 0x00, 0xef, 0x05, 0x40,
+    0xef, 0x05, 0x40, 0xef, 0x6c, 0xe0, 0x04, 0xef,
+    0x51, 0xc0, 0xef, 0x04, 0xe0, 0x0c, 0xef, 0x04,
+    0x60, 0xef, 0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0,
+    0xef, 0x20, 0xe0, 0x00, 0xef, 0x16, 0x20, 0x2f,
+    0xe0, 0x46, 0xef, 0x71, 0x00, 0xef, 0x4a, 0x00,
+    0xef, 0x7f, 0xe0, 0x04, 0xef, 0x06, 0x20, 0x8f,
+    0x40, 0x4f, 0x80, 0xcf, 0xe0, 0x01, 0xef, 0x11,
+    0xc0, 0xcf, 0xe0, 0x01, 0x4f, 0xe0, 0x05, 0xcf,
+    0xe0, 0x21, 0xef, 0x80, 0x0b, 0x00, 0xef, 0x2f,
+    0xe0, 0x1d, 0xe9, 0x02, 0xe0, 0x83, 0x7e, 0xe5,
+    0xc0, 0x66, 0x56, 0xe0, 0x1a, 0xe5, 0x8f, 0xad,
+    0xe0, 0x03, 0xe5, 0x80, 0x56, 0x20, 0xe5, 0x95,
+    0xfa, 0xe0, 0x06, 0xe5, 0x9c, 0xa9, 0xe0, 0x8b,
+    0x97, 0xe5, 0x81, 0x96, 0xe0, 0x85, 0x5a, 0xe5,
+    0x92, 0xc3, 0xe0, 0xca, 0xac, 0x2e, 0x1b, 0xe0,
+    0x16, 0xfb, 0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68,
+    0xe0, 0xc0, 0xbd, 0x88, 0xfd, 0xc0, 0xbf, 0x76,
+    0x20, 0xfd, 0xc0, 0xbf, 0x76, 0x20,
 };
 
 typedef enum {
@@ -2753,6 +2781,7 @@ typedef enum {
     UNICODE_SCRIPT_Chakma,
     UNICODE_SCRIPT_Cham,
     UNICODE_SCRIPT_Cherokee,
+    UNICODE_SCRIPT_Chorasmian,
     UNICODE_SCRIPT_Common,
     UNICODE_SCRIPT_Coptic,
     UNICODE_SCRIPT_Cuneiform,
@@ -2760,6 +2789,7 @@ typedef enum {
     UNICODE_SCRIPT_Cyrillic,
     UNICODE_SCRIPT_Deseret,
     UNICODE_SCRIPT_Devanagari,
+    UNICODE_SCRIPT_Dives_Akuru,
     UNICODE_SCRIPT_Dogra,
     UNICODE_SCRIPT_Duployan,
     UNICODE_SCRIPT_Egyptian_Hieroglyphs,
@@ -2793,6 +2823,7 @@ typedef enum {
     UNICODE_SCRIPT_Kharoshthi,
     UNICODE_SCRIPT_Khmer,
     UNICODE_SCRIPT_Khojki,
+    UNICODE_SCRIPT_Khitan_Small_Script,
     UNICODE_SCRIPT_Khudawadi,
     UNICODE_SCRIPT_Lao,
     UNICODE_SCRIPT_Latin,
@@ -2880,6 +2911,7 @@ typedef enum {
     UNICODE_SCRIPT_Vai,
     UNICODE_SCRIPT_Wancho,
     UNICODE_SCRIPT_Warang_Citi,
+    UNICODE_SCRIPT_Yezidi,
     UNICODE_SCRIPT_Yi,
     UNICODE_SCRIPT_Zanabazar_Square,
     UNICODE_SCRIPT_COUNT,
@@ -2909,6 +2941,7 @@ static const char unicode_script_name_table[] =
     "Chakma,Cakm"                 "\0"
     "Cham,Cham"                   "\0"
     "Cherokee,Cher"               "\0"
+    "Chorasmian,Chrs"             "\0"
     "Common,Zyyy"                 "\0"
     "Coptic,Copt,Qaac"            "\0"
     "Cuneiform,Xsux"              "\0"
@@ -2916,6 +2949,7 @@ static const char unicode_script_name_table[] =
     "Cyrillic,Cyrl"               "\0"
     "Deseret,Dsrt"                "\0"
     "Devanagari,Deva"             "\0"
+    "Dives_Akuru,Diak"            "\0"
     "Dogra,Dogr"                  "\0"
     "Duployan,Dupl"               "\0"
     "Egyptian_Hieroglyphs,Egyp"   "\0"
@@ -2949,6 +2983,7 @@ static const char unicode_script_name_table[] =
     "Kharoshthi,Khar"             "\0"
     "Khmer,Khmr"                  "\0"
     "Khojki,Khoj"                 "\0"
+    "Khitan_Small_Script,Kits"    "\0"
     "Khudawadi,Sind"              "\0"
     "Lao,Laoo"                    "\0"
     "Latin,Latn"                  "\0"
@@ -3036,434 +3071,442 @@ static const char unicode_script_name_table[] =
     "Vai,Vaii"                    "\0"
     "Wancho,Wcho"                 "\0"
     "Warang_Citi,Wara"            "\0"
+    "Yezidi,Yezi"                 "\0"
     "Yi,Yiii"                     "\0"
     "Zanabazar_Square,Zanb"       "\0"
 ;
 
-static const uint8_t unicode_script_table[2565] = {
-    0xc0, 0x18, 0x99, 0x42, 0x85, 0x18, 0x99, 0x42,
-    0xae, 0x18, 0x80, 0x42, 0x8e, 0x18, 0x80, 0x42,
-    0x84, 0x18, 0x96, 0x42, 0x80, 0x18, 0x9e, 0x42,
-    0x80, 0x18, 0xe1, 0x60, 0x42, 0xa6, 0x18, 0x84,
-    0x42, 0x84, 0x18, 0x81, 0x0d, 0x93, 0x18, 0xe0,
-    0x0f, 0x35, 0x83, 0x29, 0x80, 0x18, 0x82, 0x29,
-    0x01, 0x83, 0x29, 0x80, 0x18, 0x80, 0x29, 0x03,
-    0x80, 0x29, 0x80, 0x18, 0x80, 0x29, 0x80, 0x18,
-    0x82, 0x29, 0x00, 0x80, 0x29, 0x00, 0x93, 0x29,
-    0x00, 0xbe, 0x29, 0x8d, 0x19, 0x8f, 0x29, 0xe0,
-    0x24, 0x1c, 0x81, 0x35, 0xe0, 0x48, 0x1c, 0x00,
-    0xa5, 0x05, 0x01, 0xaf, 0x05, 0x80, 0x18, 0x80,
-    0x05, 0x01, 0x82, 0x05, 0x00, 0xb6, 0x32, 0x07,
-    0x9a, 0x32, 0x03, 0x85, 0x32, 0x0a, 0x84, 0x04,
-    0x80, 0x18, 0x85, 0x04, 0x80, 0x18, 0x8d, 0x04,
-    0x80, 0x18, 0x80, 0x04, 0x00, 0x80, 0x04, 0x80,
-    0x18, 0x9f, 0x04, 0x80, 0x18, 0x89, 0x04, 0x8a,
-    0x35, 0x99, 0x04, 0x80, 0x35, 0xe0, 0x0b, 0x04,
-    0x80, 0x18, 0xa1, 0x04, 0x8d, 0x84, 0x00, 0xbb,
-    0x84, 0x01, 0x82, 0x84, 0xaf, 0x04, 0xb1, 0x8e,
-    0x0d, 0xba, 0x60, 0x01, 0x82, 0x60, 0xad, 0x78,
-    0x01, 0x8e, 0x78, 0x00, 0x9b, 0x4d, 0x01, 0x80,
-    0x4d, 0x00, 0x8a, 0x84, 0x34, 0x94, 0x04, 0x00,
-    0x87, 0x04, 0x14, 0x8e, 0x04, 0x80, 0x18, 0x9c,
-    0x04, 0xd0, 0x1e, 0x83, 0x35, 0x8e, 0x1e, 0x81,
-    0x18, 0x99, 0x1e, 0x83, 0x0b, 0x00, 0x87, 0x0b,
-    0x01, 0x81, 0x0b, 0x01, 0x95, 0x0b, 0x00, 0x86,
-    0x0b, 0x00, 0x80, 0x0b, 0x02, 0x83, 0x0b, 0x01,
-    0x88, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x83, 0x0b,
-    0x07, 0x80, 0x0b, 0x03, 0x81, 0x0b, 0x00, 0x84,
-    0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x2c, 0x00,
-    0x85, 0x2c, 0x03, 0x81, 0x2c, 0x01, 0x95, 0x2c,
-    0x00, 0x86, 0x2c, 0x00, 0x81, 0x2c, 0x00, 0x81,
-    0x2c, 0x00, 0x81, 0x2c, 0x01, 0x80, 0x2c, 0x00,
-    0x84, 0x2c, 0x03, 0x81, 0x2c, 0x01, 0x82, 0x2c,
-    0x02, 0x80, 0x2c, 0x06, 0x83, 0x2c, 0x00, 0x80,
-    0x2c, 0x06, 0x90, 0x2c, 0x09, 0x82, 0x2a, 0x00,
-    0x88, 0x2a, 0x00, 0x82, 0x2a, 0x00, 0x95, 0x2a,
-    0x00, 0x86, 0x2a, 0x00, 0x81, 0x2a, 0x00, 0x84,
-    0x2a, 0x01, 0x89, 0x2a, 0x00, 0x82, 0x2a, 0x00,
-    0x82, 0x2a, 0x01, 0x80, 0x2a, 0x0e, 0x83, 0x2a,
-    0x01, 0x8b, 0x2a, 0x06, 0x86, 0x2a, 0x00, 0x82,
-    0x6d, 0x00, 0x87, 0x6d, 0x01, 0x81, 0x6d, 0x01,
-    0x95, 0x6d, 0x00, 0x86, 0x6d, 0x00, 0x81, 0x6d,
-    0x00, 0x84, 0x6d, 0x01, 0x88, 0x6d, 0x01, 0x81,
-    0x6d, 0x01, 0x82, 0x6d, 0x07, 0x81, 0x6d, 0x03,
-    0x81, 0x6d, 0x00, 0x84, 0x6d, 0x01, 0x91, 0x6d,
-    0x09, 0x81, 0x8b, 0x00, 0x85, 0x8b, 0x02, 0x82,
-    0x8b, 0x00, 0x83, 0x8b, 0x02, 0x81, 0x8b, 0x00,
-    0x80, 0x8b, 0x00, 0x81, 0x8b, 0x02, 0x81, 0x8b,
-    0x02, 0x82, 0x8b, 0x02, 0x8b, 0x8b, 0x03, 0x84,
-    0x8b, 0x02, 0x82, 0x8b, 0x00, 0x83, 0x8b, 0x01,
-    0x80, 0x8b, 0x05, 0x80, 0x8b, 0x0d, 0x94, 0x8b,
-    0x04, 0x8c, 0x8d, 0x00, 0x82, 0x8d, 0x00, 0x96,
-    0x8d, 0x00, 0x8f, 0x8d, 0x02, 0x87, 0x8d, 0x00,
-    0x82, 0x8d, 0x00, 0x83, 0x8d, 0x06, 0x81, 0x8d,
-    0x00, 0x82, 0x8d, 0x04, 0x83, 0x8d, 0x01, 0x89,
-    0x8d, 0x06, 0x88, 0x8d, 0x8c, 0x3a, 0x00, 0x82,
-    0x3a, 0x00, 0x96, 0x3a, 0x00, 0x89, 0x3a, 0x00,
-    0x84, 0x3a, 0x01, 0x88, 0x3a, 0x00, 0x82, 0x3a,
-    0x00, 0x83, 0x3a, 0x06, 0x81, 0x3a, 0x06, 0x80,
-    0x3a, 0x00, 0x83, 0x3a, 0x01, 0x89, 0x3a, 0x00,
-    0x81, 0x3a, 0x0c, 0x83, 0x4c, 0x00, 0x87, 0x4c,
-    0x00, 0x82, 0x4c, 0x00, 0xb2, 0x4c, 0x00, 0x82,
-    0x4c, 0x00, 0x85, 0x4c, 0x03, 0x8f, 0x4c, 0x01,
-    0x99, 0x4c, 0x01, 0x81, 0x7e, 0x00, 0x91, 0x7e,
-    0x02, 0x97, 0x7e, 0x00, 0x88, 0x7e, 0x00, 0x80,
-    0x7e, 0x01, 0x86, 0x7e, 0x02, 0x80, 0x7e, 0x03,
-    0x85, 0x7e, 0x00, 0x80, 0x7e, 0x00, 0x87, 0x7e,
-    0x05, 0x89, 0x7e, 0x01, 0x82, 0x7e, 0x0b, 0xb9,
-    0x8f, 0x03, 0x80, 0x18, 0x9b, 0x8f, 0x24, 0x81,
-    0x41, 0x00, 0x80, 0x41, 0x00, 0x84, 0x41, 0x00,
-    0x97, 0x41, 0x00, 0x80, 0x41, 0x00, 0x96, 0x41,
-    0x01, 0x84, 0x41, 0x00, 0x80, 0x41, 0x00, 0x85,
-    0x41, 0x01, 0x89, 0x41, 0x01, 0x83, 0x41, 0x1f,
-    0xc7, 0x90, 0x00, 0xa3, 0x90, 0x03, 0xa6, 0x90,
-    0x00, 0xa3, 0x90, 0x00, 0x8e, 0x90, 0x00, 0x86,
-    0x90, 0x83, 0x18, 0x81, 0x90, 0x24, 0xe0, 0x3f,
-    0x5b, 0xa5, 0x25, 0x00, 0x80, 0x25, 0x04, 0x80,
-    0x25, 0x01, 0xaa, 0x25, 0x80, 0x18, 0x83, 0x25,
-    0xe0, 0x9f, 0x2e, 0xc8, 0x24, 0x00, 0x83, 0x24,
-    0x01, 0x86, 0x24, 0x00, 0x80, 0x24, 0x00, 0x83,
-    0x24, 0x01, 0xa8, 0x24, 0x00, 0x83, 0x24, 0x01,
-    0xa0, 0x24, 0x00, 0x83, 0x24, 0x01, 0x86, 0x24,
-    0x00, 0x80, 0x24, 0x00, 0x83, 0x24, 0x01, 0x8e,
-    0x24, 0x00, 0xb8, 0x24, 0x00, 0x83, 0x24, 0x01,
-    0xc2, 0x24, 0x01, 0x9f, 0x24, 0x02, 0x99, 0x24,
-    0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01, 0xe2,
-    0x1f, 0x12, 0x9c, 0x63, 0x02, 0xca, 0x77, 0x82,
-    0x18, 0x8a, 0x77, 0x06, 0x8c, 0x85, 0x00, 0x86,
-    0x85, 0x0a, 0x94, 0x30, 0x81, 0x18, 0x08, 0x93,
-    0x11, 0x0b, 0x8c, 0x86, 0x00, 0x82, 0x86, 0x00,
-    0x81, 0x86, 0x0b, 0xdd, 0x3e, 0x01, 0x89, 0x3e,
-    0x05, 0x89, 0x3e, 0x05, 0x81, 0x58, 0x81, 0x18,
-    0x80, 0x58, 0x80, 0x18, 0x88, 0x58, 0x00, 0x89,
-    0x58, 0x05, 0xd8, 0x58, 0x06, 0xaa, 0x58, 0x04,
-    0xc5, 0x12, 0x09, 0x9e, 0x44, 0x00, 0x8b, 0x44,
-    0x03, 0x8b, 0x44, 0x03, 0x80, 0x44, 0x02, 0x8b,
-    0x44, 0x9d, 0x87, 0x01, 0x84, 0x87, 0x0a, 0xab,
-    0x5e, 0x03, 0x99, 0x5e, 0x05, 0x8a, 0x5e, 0x02,
-    0x81, 0x5e, 0x9f, 0x3e, 0x9b, 0x10, 0x01, 0x81,
-    0x10, 0xbe, 0x88, 0x00, 0x9c, 0x88, 0x01, 0x8a,
-    0x88, 0x05, 0x89, 0x88, 0x05, 0x8d, 0x88, 0x01,
-    0x8e, 0x35, 0x40, 0xcb, 0x07, 0x03, 0xac, 0x07,
-    0x02, 0xbf, 0x82, 0xb3, 0x0a, 0x07, 0x83, 0x0a,
-    0xb7, 0x43, 0x02, 0x8e, 0x43, 0x02, 0x82, 0x43,
-    0xaf, 0x64, 0x88, 0x1c, 0x06, 0xaa, 0x25, 0x01,
-    0x82, 0x25, 0x87, 0x82, 0x07, 0x82, 0x35, 0x80,
-    0x18, 0x8c, 0x35, 0x80, 0x18, 0x86, 0x35, 0x83,
-    0x18, 0x80, 0x35, 0x85, 0x18, 0x80, 0x35, 0x82,
-    0x18, 0x81, 0x35, 0x80, 0x18, 0x04, 0xa5, 0x42,
-    0x84, 0x29, 0x80, 0x1c, 0xb0, 0x42, 0x84, 0x29,
-    0x83, 0x42, 0x84, 0x29, 0x8c, 0x42, 0x80, 0x1c,
-    0xc5, 0x42, 0x80, 0x29, 0xb9, 0x35, 0x00, 0x84,
-    0x35, 0xe0, 0x9f, 0x42, 0x95, 0x29, 0x01, 0x85,
-    0x29, 0x01, 0xa5, 0x29, 0x01, 0x85, 0x29, 0x01,
-    0x87, 0x29, 0x00, 0x80, 0x29, 0x00, 0x80, 0x29,
-    0x00, 0x80, 0x29, 0x00, 0x9e, 0x29, 0x01, 0xb4,
-    0x29, 0x00, 0x8e, 0x29, 0x00, 0x8d, 0x29, 0x01,
-    0x85, 0x29, 0x00, 0x92, 0x29, 0x01, 0x82, 0x29,
-    0x00, 0x88, 0x29, 0x00, 0x8b, 0x18, 0x81, 0x35,
-    0xd6, 0x18, 0x00, 0x8a, 0x18, 0x80, 0x42, 0x01,
-    0x8a, 0x18, 0x80, 0x42, 0x8e, 0x18, 0x00, 0x8c,
-    0x42, 0x02, 0x9f, 0x18, 0x0f, 0xa0, 0x35, 0x0e,
-    0xa5, 0x18, 0x80, 0x29, 0x82, 0x18, 0x81, 0x42,
-    0x85, 0x18, 0x80, 0x42, 0x9a, 0x18, 0x80, 0x42,
-    0x90, 0x18, 0xa8, 0x42, 0x82, 0x18, 0x03, 0xe2,
-    0x36, 0x18, 0x18, 0x8a, 0x18, 0x14, 0xe3, 0x3f,
-    0x18, 0xe0, 0x9f, 0x0f, 0xe2, 0x13, 0x18, 0x01,
-    0x9f, 0x18, 0x01, 0xe0, 0x07, 0x18, 0xae, 0x26,
-    0x00, 0xae, 0x26, 0x00, 0x9f, 0x42, 0xe0, 0x13,
-    0x19, 0x04, 0x86, 0x19, 0xa5, 0x25, 0x00, 0x80,
-    0x25, 0x04, 0x80, 0x25, 0x01, 0xb7, 0x91, 0x06,
-    0x81, 0x91, 0x0d, 0x80, 0x91, 0x96, 0x24, 0x08,
-    0x86, 0x24, 0x00, 0x86, 0x24, 0x00, 0x86, 0x24,
-    0x00, 0x86, 0x24, 0x00, 0x86, 0x24, 0x00, 0x86,
-    0x24, 0x00, 0x86, 0x24, 0x00, 0x86, 0x24, 0x00,
-    0x9f, 0x1c, 0xcf, 0x18, 0x2f, 0x99, 0x2d, 0x00,
-    0xd8, 0x2d, 0x0b, 0xe0, 0x75, 0x2d, 0x19, 0x8b,
-    0x18, 0x03, 0x84, 0x18, 0x80, 0x2d, 0x80, 0x18,
-    0x80, 0x2d, 0x98, 0x18, 0x88, 0x2d, 0x83, 0x35,
-    0x81, 0x2e, 0x87, 0x18, 0x83, 0x2d, 0x83, 0x18,
-    0x00, 0xd5, 0x33, 0x01, 0x81, 0x35, 0x81, 0x18,
-    0x82, 0x33, 0x80, 0x18, 0xd9, 0x3b, 0x81, 0x18,
-    0x82, 0x3b, 0x04, 0xaa, 0x0d, 0x00, 0xdd, 0x2e,
-    0x00, 0x8f, 0x18, 0x9a, 0x0d, 0x04, 0xa3, 0x18,
-    0x0b, 0x8f, 0x3b, 0x9e, 0x2e, 0x00, 0xbf, 0x18,
-    0x9e, 0x2e, 0xd0, 0x18, 0xae, 0x3b, 0x80, 0x18,
-    0xd7, 0x3b, 0xe0, 0x47, 0x18, 0xf0, 0x09, 0x55,
-    0x2d, 0x09, 0xbf, 0x18, 0xf0, 0x41, 0x8f, 0x2d,
-    0x0f, 0xe4, 0x2c, 0x97, 0x02, 0xb6, 0x97, 0x08,
-    0xaf, 0x47, 0xe0, 0xcb, 0x94, 0x13, 0xdf, 0x1c,
-    0xd7, 0x08, 0x07, 0xa1, 0x18, 0xe0, 0x05, 0x42,
-    0x82, 0x18, 0xb4, 0x42, 0x01, 0x84, 0x42, 0x2f,
-    0x88, 0x42, 0xab, 0x83, 0x03, 0x89, 0x18, 0x05,
-    0xb7, 0x73, 0x07, 0xc5, 0x79, 0x07, 0x8b, 0x79,
-    0x05, 0x9f, 0x1e, 0xad, 0x3c, 0x80, 0x18, 0x80,
-    0x3c, 0xa3, 0x76, 0x0a, 0x80, 0x76, 0x9c, 0x2e,
-    0x02, 0xcd, 0x38, 0x00, 0x80, 0x18, 0x89, 0x38,
-    0x03, 0x81, 0x38, 0x9e, 0x5b, 0x00, 0xb6, 0x16,
-    0x08, 0x8d, 0x16, 0x01, 0x89, 0x16, 0x01, 0x83,
-    0x16, 0x9f, 0x5b, 0xc2, 0x89, 0x17, 0x84, 0x89,
-    0x96, 0x52, 0x09, 0x85, 0x24, 0x01, 0x85, 0x24,
-    0x01, 0x85, 0x24, 0x08, 0x86, 0x24, 0x00, 0x86,
-    0x24, 0x00, 0xaa, 0x42, 0x80, 0x18, 0x88, 0x42,
-    0x80, 0x29, 0x81, 0x42, 0x07, 0xcf, 0x17, 0xad,
-    0x52, 0x01, 0x89, 0x52, 0x05, 0xf0, 0x1b, 0x43,
-    0x2e, 0x0b, 0x96, 0x2e, 0x03, 0xb0, 0x2e, 0x70,
-    0x10, 0xa3, 0xe1, 0x0d, 0x2d, 0x01, 0xe0, 0x09,
-    0x2d, 0x25, 0x86, 0x42, 0x0b, 0x84, 0x05, 0x04,
-    0x99, 0x32, 0x00, 0x84, 0x32, 0x00, 0x80, 0x32,
-    0x00, 0x81, 0x32, 0x00, 0x81, 0x32, 0x00, 0x89,
-    0x32, 0xe0, 0x11, 0x04, 0x10, 0xe1, 0x0a, 0x04,
-    0x81, 0x18, 0x0f, 0xbf, 0x04, 0x01, 0xb5, 0x04,
-    0x27, 0x8d, 0x04, 0x01, 0x8f, 0x35, 0x89, 0x18,
-    0x05, 0x8d, 0x35, 0x81, 0x1c, 0xa2, 0x18, 0x00,
-    0x92, 0x18, 0x00, 0x83, 0x18, 0x03, 0x84, 0x04,
-    0x00, 0xe0, 0x26, 0x04, 0x01, 0x80, 0x18, 0x00,
-    0x9f, 0x18, 0x99, 0x42, 0x85, 0x18, 0x99, 0x42,
-    0x8a, 0x18, 0x89, 0x3b, 0x80, 0x18, 0xac, 0x3b,
-    0x81, 0x18, 0x9e, 0x2e, 0x02, 0x85, 0x2e, 0x01,
-    0x85, 0x2e, 0x01, 0x85, 0x2e, 0x01, 0x82, 0x2e,
-    0x02, 0x86, 0x18, 0x00, 0x86, 0x18, 0x09, 0x84,
-    0x18, 0x01, 0x8b, 0x46, 0x00, 0x99, 0x46, 0x00,
-    0x92, 0x46, 0x00, 0x81, 0x46, 0x00, 0x8e, 0x46,
-    0x01, 0x8d, 0x46, 0x21, 0xe0, 0x1a, 0x46, 0x04,
-    0x82, 0x18, 0x03, 0xac, 0x18, 0x02, 0x88, 0x18,
-    0xce, 0x29, 0x00, 0x8b, 0x18, 0x03, 0x80, 0x29,
-    0x2e, 0xac, 0x18, 0x80, 0x35, 0x60, 0x21, 0x9c,
-    0x48, 0x02, 0xb0, 0x13, 0x0e, 0x80, 0x35, 0x9a,
-    0x18, 0x03, 0xa3, 0x66, 0x08, 0x82, 0x66, 0x9a,
-    0x27, 0x04, 0xaa, 0x68, 0x04, 0x9d, 0x93, 0x00,
-    0x80, 0x93, 0xa3, 0x69, 0x03, 0x8d, 0x69, 0x29,
-    0xcf, 0x1d, 0xaf, 0x7b, 0x9d, 0x6f, 0x01, 0x89,
-    0x6f, 0x05, 0xa3, 0x6e, 0x03, 0xa3, 0x6e, 0x03,
-    0xa7, 0x22, 0x07, 0xb3, 0x14, 0x0a, 0x80, 0x14,
-    0x60, 0x2f, 0xe0, 0xd6, 0x45, 0x08, 0x95, 0x45,
-    0x09, 0x87, 0x45, 0x60, 0x37, 0x85, 0x1b, 0x01,
-    0x80, 0x1b, 0x00, 0xab, 0x1b, 0x00, 0x81, 0x1b,
-    0x02, 0x80, 0x1b, 0x01, 0x80, 0x1b, 0x95, 0x34,
-    0x00, 0x88, 0x34, 0x9f, 0x71, 0x9e, 0x5c, 0x07,
-    0x88, 0x5c, 0x2f, 0x92, 0x31, 0x00, 0x81, 0x31,
-    0x04, 0x84, 0x31, 0x9b, 0x74, 0x02, 0x80, 0x74,
-    0x99, 0x49, 0x04, 0x80, 0x49, 0x3f, 0x9f, 0x55,
-    0x97, 0x54, 0x03, 0x93, 0x54, 0x01, 0xad, 0x54,
-    0x83, 0x3d, 0x00, 0x81, 0x3d, 0x04, 0x87, 0x3d,
-    0x00, 0x82, 0x3d, 0x00, 0x9c, 0x3d, 0x01, 0x82,
-    0x3d, 0x03, 0x89, 0x3d, 0x06, 0x88, 0x3d, 0x06,
-    0x9f, 0x6b, 0x9f, 0x67, 0x1f, 0xa6, 0x4e, 0x03,
-    0x8b, 0x4e, 0x08, 0xb5, 0x06, 0x02, 0x86, 0x06,
-    0x95, 0x37, 0x01, 0x87, 0x37, 0x92, 0x36, 0x04,
-    0x87, 0x36, 0x91, 0x75, 0x06, 0x83, 0x75, 0x0b,
-    0x86, 0x75, 0x4f, 0xc8, 0x6c, 0x36, 0xb2, 0x65,
-    0x0c, 0xb2, 0x65, 0x06, 0x85, 0x65, 0xa7, 0x2f,
-    0x07, 0x89, 0x2f, 0x60, 0xc5, 0x9e, 0x04, 0x60,
-    0x20, 0xa7, 0x6a, 0x07, 0xa9, 0x7f, 0x60, 0x25,
-    0x96, 0x23, 0x08, 0xcd, 0x0e, 0x03, 0x9d, 0x0e,
-    0x0e, 0x80, 0x0e, 0xc1, 0x39, 0x0a, 0x80, 0x39,
-    0x01, 0x98, 0x80, 0x06, 0x89, 0x80, 0x05, 0xb4,
-    0x15, 0x00, 0x90, 0x15, 0x08, 0xa6, 0x4b, 0x08,
-    0xcd, 0x7a, 0x01, 0x8f, 0x7a, 0x00, 0x93, 0x7e,
-    0x0a, 0x91, 0x3f, 0x00, 0xab, 0x3f, 0x40, 0x86,
-    0x5a, 0x00, 0x80, 0x5a, 0x00, 0x83, 0x5a, 0x00,
-    0x8e, 0x5a, 0x00, 0x8a, 0x5a, 0x05, 0xba, 0x40,
-    0x04, 0x89, 0x40, 0x05, 0x83, 0x28, 0x00, 0x87,
-    0x28, 0x01, 0x81, 0x28, 0x01, 0x95, 0x28, 0x00,
-    0x86, 0x28, 0x00, 0x81, 0x28, 0x00, 0x84, 0x28,
-    0x00, 0x80, 0x35, 0x88, 0x28, 0x01, 0x81, 0x28,
-    0x01, 0x82, 0x28, 0x01, 0x80, 0x28, 0x05, 0x80,
-    0x28, 0x04, 0x86, 0x28, 0x01, 0x86, 0x28, 0x02,
-    0x84, 0x28, 0x60, 0x2a, 0xd9, 0x5f, 0x00, 0x80,
-    0x5f, 0x00, 0x82, 0x5f, 0x1f, 0xc7, 0x92, 0x07,
-    0x89, 0x92, 0x60, 0x45, 0xb5, 0x7c, 0x01, 0xa5,
-    0x7c, 0x21, 0xc4, 0x57, 0x0a, 0x89, 0x57, 0x05,
-    0x8c, 0x58, 0x12, 0xb8, 0x8a, 0x06, 0x89, 0x8a,
-    0x35, 0x9a, 0x02, 0x01, 0x8e, 0x02, 0x03, 0x8f,
-    0x02, 0x60, 0x5f, 0xbb, 0x1f, 0x60, 0x03, 0xd2,
-    0x96, 0x0b, 0x80, 0x96, 0x60, 0x3f, 0x87, 0x5d,
-    0x01, 0xad, 0x5d, 0x01, 0x8a, 0x5d, 0x1a, 0xc7,
-    0x98, 0x07, 0xd2, 0x81, 0x1c, 0xb8, 0x72, 0x60,
-    0xa6, 0x88, 0x0c, 0x00, 0xac, 0x0c, 0x00, 0x8d,
-    0x0c, 0x09, 0x9c, 0x0c, 0x02, 0x9f, 0x4f, 0x01,
-    0x95, 0x4f, 0x00, 0x8d, 0x4f, 0x48, 0x86, 0x50,
-    0x00, 0x81, 0x50, 0x00, 0xab, 0x50, 0x02, 0x80,
-    0x50, 0x00, 0x81, 0x50, 0x00, 0x88, 0x50, 0x07,
-    0x89, 0x50, 0x05, 0x85, 0x2b, 0x00, 0x81, 0x2b,
-    0x00, 0xa4, 0x2b, 0x00, 0x81, 0x2b, 0x00, 0x85,
-    0x2b, 0x06, 0x89, 0x2b, 0x60, 0xd5, 0x98, 0x4a,
-    0x60, 0x66, 0xb1, 0x8b, 0x0c, 0x80, 0x8b, 0xe3,
-    0x39, 0x1a, 0x60, 0x05, 0xe0, 0x0e, 0x1a, 0x00,
-    0x84, 0x1a, 0x0a, 0xe0, 0x63, 0x1a, 0x6a, 0x5b,
-    0xe3, 0xce, 0x21, 0x00, 0x88, 0x21, 0x6f, 0x66,
-    0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8,
-    0x08, 0x06, 0x9e, 0x59, 0x00, 0x89, 0x59, 0x03,
-    0x81, 0x59, 0x5f, 0x9d, 0x09, 0x01, 0x85, 0x09,
-    0x09, 0xc5, 0x70, 0x09, 0x89, 0x70, 0x00, 0x86,
-    0x70, 0x00, 0x94, 0x70, 0x04, 0x92, 0x70, 0x62,
-    0x4f, 0xda, 0x51, 0x60, 0x04, 0xca, 0x56, 0x03,
-    0xb8, 0x56, 0x06, 0x90, 0x56, 0x3f, 0x80, 0x8c,
-    0x80, 0x61, 0x81, 0x18, 0x1b, 0xf0, 0x07, 0x97,
-    0x8c, 0x07, 0xe2, 0x92, 0x8c, 0x70, 0x14, 0xac,
-    0x80, 0x3b, 0xe0, 0xbd, 0x33, 0x30, 0x82, 0x33,
-    0x10, 0x83, 0x3b, 0x07, 0xe1, 0x2b, 0x61, 0x68,
-    0xa3, 0xe0, 0x0a, 0x20, 0x04, 0x8c, 0x20, 0x02,
-    0x88, 0x20, 0x06, 0x89, 0x20, 0x01, 0x83, 0x20,
-    0x83, 0x18, 0x70, 0x02, 0xfb, 0xe0, 0x95, 0x18,
-    0x09, 0xa6, 0x18, 0x01, 0xbd, 0x18, 0x82, 0x35,
-    0x90, 0x18, 0x87, 0x35, 0x81, 0x18, 0x86, 0x35,
-    0x9d, 0x18, 0x83, 0x35, 0xba, 0x18, 0x16, 0xc5,
-    0x29, 0x60, 0x39, 0x93, 0x18, 0x0b, 0xd6, 0x18,
-    0x08, 0x98, 0x18, 0x60, 0x26, 0xd4, 0x18, 0x00,
-    0xc6, 0x18, 0x00, 0x81, 0x18, 0x01, 0x80, 0x18,
-    0x01, 0x81, 0x18, 0x01, 0x83, 0x18, 0x00, 0x8b,
-    0x18, 0x00, 0x80, 0x18, 0x00, 0x86, 0x18, 0x00,
-    0xc0, 0x18, 0x00, 0x83, 0x18, 0x01, 0x87, 0x18,
-    0x00, 0x86, 0x18, 0x00, 0x9b, 0x18, 0x00, 0x83,
-    0x18, 0x00, 0x84, 0x18, 0x00, 0x80, 0x18, 0x02,
-    0x86, 0x18, 0x00, 0xe0, 0xf3, 0x18, 0x01, 0xe0,
-    0xc3, 0x18, 0x01, 0xb1, 0x18, 0xe2, 0x2b, 0x7d,
-    0x0e, 0x84, 0x7d, 0x00, 0x8e, 0x7d, 0x64, 0xef,
-    0x86, 0x26, 0x00, 0x90, 0x26, 0x01, 0x86, 0x26,
-    0x00, 0x81, 0x26, 0x00, 0x84, 0x26, 0x60, 0x74,
-    0xac, 0x62, 0x02, 0x8d, 0x62, 0x01, 0x89, 0x62,
-    0x03, 0x81, 0x62, 0x61, 0x0f, 0xb9, 0x95, 0x04,
-    0x80, 0x95, 0x64, 0x9f, 0xe0, 0x64, 0x53, 0x01,
-    0x8f, 0x53, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
-    0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x18, 0x4b,
-    0xbc, 0x18, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a,
-    0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
-    0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83, 0x04,
-    0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05, 0x80,
-    0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81, 0x04,
-    0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00, 0x80,
-    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
-    0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00, 0x83,
-    0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82, 0x04,
-    0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33, 0x81,
-    0x04, 0x60, 0xad, 0xab, 0x18, 0x03, 0xe0, 0x03,
-    0x18, 0x0b, 0x8e, 0x18, 0x01, 0x8e, 0x18, 0x00,
-    0x8e, 0x18, 0x00, 0xa4, 0x18, 0x09, 0x8c, 0x18,
-    0x02, 0xdc, 0x18, 0x02, 0xbc, 0x18, 0x38, 0x99,
-    0x18, 0x80, 0x33, 0x81, 0x18, 0x0c, 0xab, 0x18,
-    0x03, 0x88, 0x18, 0x06, 0x81, 0x18, 0x0d, 0x85,
-    0x18, 0x60, 0x39, 0xe3, 0x75, 0x18, 0x09, 0x8c,
-    0x18, 0x02, 0x8a, 0x18, 0x04, 0xe0, 0x13, 0x18,
-    0x0b, 0xd8, 0x18, 0x06, 0x8b, 0x18, 0x13, 0x8b,
-    0x18, 0x03, 0xb7, 0x18, 0x07, 0x89, 0x18, 0x05,
-    0xa7, 0x18, 0x07, 0x9d, 0x18, 0x51, 0x8b, 0x18,
-    0x00, 0xe0, 0x04, 0x18, 0x00, 0x83, 0x18, 0x02,
-    0xa8, 0x18, 0x01, 0x85, 0x18, 0x02, 0x9c, 0x18,
-    0x01, 0xe0, 0x26, 0x18, 0x0b, 0x8d, 0x18, 0x01,
-    0x83, 0x18, 0x03, 0x82, 0x18, 0x04, 0x82, 0x18,
-    0x0c, 0x85, 0x18, 0x65, 0x09, 0xf0, 0x96, 0x76,
-    0x2d, 0x28, 0xef, 0xd4, 0x2d, 0x0a, 0xe0, 0x7d,
-    0x2d, 0x01, 0xf0, 0x06, 0x21, 0x2d, 0x0d, 0xf0,
-    0x0c, 0xd0, 0x2d, 0x6b, 0xbe, 0xe1, 0xbd, 0x2d,
-    0x7a, 0xf5, 0x82, 0x80, 0x18, 0x1d, 0xdf, 0x18,
-    0x60, 0x1f, 0xe0, 0x8f, 0x35,
+static const uint8_t unicode_script_table[2609] = {
+    0xc0, 0x19, 0x99, 0x45, 0x85, 0x19, 0x99, 0x45,
+    0xae, 0x19, 0x80, 0x45, 0x8e, 0x19, 0x80, 0x45,
+    0x84, 0x19, 0x96, 0x45, 0x80, 0x19, 0x9e, 0x45,
+    0x80, 0x19, 0xe1, 0x60, 0x45, 0xa6, 0x19, 0x84,
+    0x45, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
+    0x0f, 0x37, 0x83, 0x2b, 0x80, 0x19, 0x82, 0x2b,
+    0x01, 0x83, 0x2b, 0x80, 0x19, 0x80, 0x2b, 0x03,
+    0x80, 0x2b, 0x80, 0x19, 0x80, 0x2b, 0x80, 0x19,
+    0x82, 0x2b, 0x00, 0x80, 0x2b, 0x00, 0x93, 0x2b,
+    0x00, 0xbe, 0x2b, 0x8d, 0x1a, 0x8f, 0x2b, 0xe0,
+    0x24, 0x1d, 0x81, 0x37, 0xe0, 0x48, 0x1d, 0x00,
+    0xa5, 0x05, 0x01, 0xb1, 0x05, 0x01, 0x82, 0x05,
+    0x00, 0xb6, 0x34, 0x07, 0x9a, 0x34, 0x03, 0x85,
+    0x34, 0x0a, 0x84, 0x04, 0x80, 0x19, 0x85, 0x04,
+    0x80, 0x19, 0x8d, 0x04, 0x80, 0x19, 0x80, 0x04,
+    0x00, 0x80, 0x04, 0x80, 0x19, 0x9f, 0x04, 0x80,
+    0x19, 0x89, 0x04, 0x8a, 0x37, 0x99, 0x04, 0x80,
+    0x37, 0xe0, 0x0b, 0x04, 0x80, 0x19, 0xa1, 0x04,
+    0x8d, 0x87, 0x00, 0xbb, 0x87, 0x01, 0x82, 0x87,
+    0xaf, 0x04, 0xb1, 0x91, 0x0d, 0xba, 0x63, 0x01,
+    0x82, 0x63, 0xad, 0x7b, 0x01, 0x8e, 0x7b, 0x00,
+    0x9b, 0x50, 0x01, 0x80, 0x50, 0x00, 0x8a, 0x87,
+    0x34, 0x94, 0x04, 0x00, 0x91, 0x04, 0x0a, 0x8e,
+    0x04, 0x80, 0x19, 0x9c, 0x04, 0xd0, 0x1f, 0x83,
+    0x37, 0x8e, 0x1f, 0x81, 0x19, 0x99, 0x1f, 0x83,
+    0x0b, 0x00, 0x87, 0x0b, 0x01, 0x81, 0x0b, 0x01,
+    0x95, 0x0b, 0x00, 0x86, 0x0b, 0x00, 0x80, 0x0b,
+    0x02, 0x83, 0x0b, 0x01, 0x88, 0x0b, 0x01, 0x81,
+    0x0b, 0x01, 0x83, 0x0b, 0x07, 0x80, 0x0b, 0x03,
+    0x81, 0x0b, 0x00, 0x84, 0x0b, 0x01, 0x98, 0x0b,
+    0x01, 0x82, 0x2e, 0x00, 0x85, 0x2e, 0x03, 0x81,
+    0x2e, 0x01, 0x95, 0x2e, 0x00, 0x86, 0x2e, 0x00,
+    0x81, 0x2e, 0x00, 0x81, 0x2e, 0x00, 0x81, 0x2e,
+    0x01, 0x80, 0x2e, 0x00, 0x84, 0x2e, 0x03, 0x81,
+    0x2e, 0x01, 0x82, 0x2e, 0x02, 0x80, 0x2e, 0x06,
+    0x83, 0x2e, 0x00, 0x80, 0x2e, 0x06, 0x90, 0x2e,
+    0x09, 0x82, 0x2c, 0x00, 0x88, 0x2c, 0x00, 0x82,
+    0x2c, 0x00, 0x95, 0x2c, 0x00, 0x86, 0x2c, 0x00,
+    0x81, 0x2c, 0x00, 0x84, 0x2c, 0x01, 0x89, 0x2c,
+    0x00, 0x82, 0x2c, 0x00, 0x82, 0x2c, 0x01, 0x80,
+    0x2c, 0x0e, 0x83, 0x2c, 0x01, 0x8b, 0x2c, 0x06,
+    0x86, 0x2c, 0x00, 0x82, 0x70, 0x00, 0x87, 0x70,
+    0x01, 0x81, 0x70, 0x01, 0x95, 0x70, 0x00, 0x86,
+    0x70, 0x00, 0x81, 0x70, 0x00, 0x84, 0x70, 0x01,
+    0x88, 0x70, 0x01, 0x81, 0x70, 0x01, 0x82, 0x70,
+    0x06, 0x82, 0x70, 0x03, 0x81, 0x70, 0x00, 0x84,
+    0x70, 0x01, 0x91, 0x70, 0x09, 0x81, 0x8e, 0x00,
+    0x85, 0x8e, 0x02, 0x82, 0x8e, 0x00, 0x83, 0x8e,
+    0x02, 0x81, 0x8e, 0x00, 0x80, 0x8e, 0x00, 0x81,
+    0x8e, 0x02, 0x81, 0x8e, 0x02, 0x82, 0x8e, 0x02,
+    0x8b, 0x8e, 0x03, 0x84, 0x8e, 0x02, 0x82, 0x8e,
+    0x00, 0x83, 0x8e, 0x01, 0x80, 0x8e, 0x05, 0x80,
+    0x8e, 0x0d, 0x94, 0x8e, 0x04, 0x8c, 0x90, 0x00,
+    0x82, 0x90, 0x00, 0x96, 0x90, 0x00, 0x8f, 0x90,
+    0x02, 0x87, 0x90, 0x00, 0x82, 0x90, 0x00, 0x83,
+    0x90, 0x06, 0x81, 0x90, 0x00, 0x82, 0x90, 0x04,
+    0x83, 0x90, 0x01, 0x89, 0x90, 0x06, 0x88, 0x90,
+    0x8c, 0x3c, 0x00, 0x82, 0x3c, 0x00, 0x96, 0x3c,
+    0x00, 0x89, 0x3c, 0x00, 0x84, 0x3c, 0x01, 0x88,
+    0x3c, 0x00, 0x82, 0x3c, 0x00, 0x83, 0x3c, 0x06,
+    0x81, 0x3c, 0x06, 0x80, 0x3c, 0x00, 0x83, 0x3c,
+    0x01, 0x89, 0x3c, 0x00, 0x81, 0x3c, 0x0c, 0x8c,
+    0x4f, 0x00, 0x82, 0x4f, 0x00, 0xb2, 0x4f, 0x00,
+    0x82, 0x4f, 0x00, 0x85, 0x4f, 0x03, 0x8f, 0x4f,
+    0x01, 0x99, 0x4f, 0x00, 0x82, 0x81, 0x00, 0x91,
+    0x81, 0x02, 0x97, 0x81, 0x00, 0x88, 0x81, 0x00,
+    0x80, 0x81, 0x01, 0x86, 0x81, 0x02, 0x80, 0x81,
+    0x03, 0x85, 0x81, 0x00, 0x80, 0x81, 0x00, 0x87,
+    0x81, 0x05, 0x89, 0x81, 0x01, 0x82, 0x81, 0x0b,
+    0xb9, 0x92, 0x03, 0x80, 0x19, 0x9b, 0x92, 0x24,
+    0x81, 0x44, 0x00, 0x80, 0x44, 0x00, 0x84, 0x44,
+    0x00, 0x97, 0x44, 0x00, 0x80, 0x44, 0x00, 0x96,
+    0x44, 0x01, 0x84, 0x44, 0x00, 0x80, 0x44, 0x00,
+    0x85, 0x44, 0x01, 0x89, 0x44, 0x01, 0x83, 0x44,
+    0x1f, 0xc7, 0x93, 0x00, 0xa3, 0x93, 0x03, 0xa6,
+    0x93, 0x00, 0xa3, 0x93, 0x00, 0x8e, 0x93, 0x00,
+    0x86, 0x93, 0x83, 0x19, 0x81, 0x93, 0x24, 0xe0,
+    0x3f, 0x5e, 0xa5, 0x27, 0x00, 0x80, 0x27, 0x04,
+    0x80, 0x27, 0x01, 0xaa, 0x27, 0x80, 0x19, 0x83,
+    0x27, 0xe0, 0x9f, 0x30, 0xc8, 0x26, 0x00, 0x83,
+    0x26, 0x01, 0x86, 0x26, 0x00, 0x80, 0x26, 0x00,
+    0x83, 0x26, 0x01, 0xa8, 0x26, 0x00, 0x83, 0x26,
+    0x01, 0xa0, 0x26, 0x00, 0x83, 0x26, 0x01, 0x86,
+    0x26, 0x00, 0x80, 0x26, 0x00, 0x83, 0x26, 0x01,
+    0x8e, 0x26, 0x00, 0xb8, 0x26, 0x00, 0x83, 0x26,
+    0x01, 0xc2, 0x26, 0x01, 0x9f, 0x26, 0x02, 0x99,
+    0x26, 0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01,
+    0xe2, 0x1f, 0x12, 0x9c, 0x66, 0x02, 0xca, 0x7a,
+    0x82, 0x19, 0x8a, 0x7a, 0x06, 0x8c, 0x88, 0x00,
+    0x86, 0x88, 0x0a, 0x94, 0x32, 0x81, 0x19, 0x08,
+    0x93, 0x11, 0x0b, 0x8c, 0x89, 0x00, 0x82, 0x89,
+    0x00, 0x81, 0x89, 0x0b, 0xdd, 0x40, 0x01, 0x89,
+    0x40, 0x05, 0x89, 0x40, 0x05, 0x81, 0x5b, 0x81,
+    0x19, 0x80, 0x5b, 0x80, 0x19, 0x88, 0x5b, 0x00,
+    0x89, 0x5b, 0x05, 0xd8, 0x5b, 0x06, 0xaa, 0x5b,
+    0x04, 0xc5, 0x12, 0x09, 0x9e, 0x47, 0x00, 0x8b,
+    0x47, 0x03, 0x8b, 0x47, 0x03, 0x80, 0x47, 0x02,
+    0x8b, 0x47, 0x9d, 0x8a, 0x01, 0x84, 0x8a, 0x0a,
+    0xab, 0x61, 0x03, 0x99, 0x61, 0x05, 0x8a, 0x61,
+    0x02, 0x81, 0x61, 0x9f, 0x40, 0x9b, 0x10, 0x01,
+    0x81, 0x10, 0xbe, 0x8b, 0x00, 0x9c, 0x8b, 0x01,
+    0x8a, 0x8b, 0x05, 0x89, 0x8b, 0x05, 0x8d, 0x8b,
+    0x01, 0x90, 0x37, 0x3e, 0xcb, 0x07, 0x03, 0xac,
+    0x07, 0x02, 0xbf, 0x85, 0xb3, 0x0a, 0x07, 0x83,
+    0x0a, 0xb7, 0x46, 0x02, 0x8e, 0x46, 0x02, 0x82,
+    0x46, 0xaf, 0x67, 0x88, 0x1d, 0x06, 0xaa, 0x27,
+    0x01, 0x82, 0x27, 0x87, 0x85, 0x07, 0x82, 0x37,
+    0x80, 0x19, 0x8c, 0x37, 0x80, 0x19, 0x86, 0x37,
+    0x83, 0x19, 0x80, 0x37, 0x85, 0x19, 0x80, 0x37,
+    0x82, 0x19, 0x81, 0x37, 0x80, 0x19, 0x04, 0xa5,
+    0x45, 0x84, 0x2b, 0x80, 0x1d, 0xb0, 0x45, 0x84,
+    0x2b, 0x83, 0x45, 0x84, 0x2b, 0x8c, 0x45, 0x80,
+    0x1d, 0xc5, 0x45, 0x80, 0x2b, 0xb9, 0x37, 0x00,
+    0x84, 0x37, 0xe0, 0x9f, 0x45, 0x95, 0x2b, 0x01,
+    0x85, 0x2b, 0x01, 0xa5, 0x2b, 0x01, 0x85, 0x2b,
+    0x01, 0x87, 0x2b, 0x00, 0x80, 0x2b, 0x00, 0x80,
+    0x2b, 0x00, 0x80, 0x2b, 0x00, 0x9e, 0x2b, 0x01,
+    0xb4, 0x2b, 0x00, 0x8e, 0x2b, 0x00, 0x8d, 0x2b,
+    0x01, 0x85, 0x2b, 0x00, 0x92, 0x2b, 0x01, 0x82,
+    0x2b, 0x00, 0x88, 0x2b, 0x00, 0x8b, 0x19, 0x81,
+    0x37, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80, 0x45,
+    0x01, 0x8a, 0x19, 0x80, 0x45, 0x8e, 0x19, 0x00,
+    0x8c, 0x45, 0x02, 0x9f, 0x19, 0x0f, 0xa0, 0x37,
+    0x0e, 0xa5, 0x19, 0x80, 0x2b, 0x82, 0x19, 0x81,
+    0x45, 0x85, 0x19, 0x80, 0x45, 0x9a, 0x19, 0x80,
+    0x45, 0x90, 0x19, 0xa8, 0x45, 0x82, 0x19, 0x03,
+    0xe2, 0x36, 0x19, 0x18, 0x8a, 0x19, 0x14, 0xe3,
+    0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13, 0x19,
+    0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19, 0xae,
+    0x28, 0x00, 0xae, 0x28, 0x00, 0x9f, 0x45, 0xe0,
+    0x13, 0x1a, 0x04, 0x86, 0x1a, 0xa5, 0x27, 0x00,
+    0x80, 0x27, 0x04, 0x80, 0x27, 0x01, 0xb7, 0x94,
+    0x06, 0x81, 0x94, 0x0d, 0x80, 0x94, 0x96, 0x26,
+    0x08, 0x86, 0x26, 0x00, 0x86, 0x26, 0x00, 0x86,
+    0x26, 0x00, 0x86, 0x26, 0x00, 0x86, 0x26, 0x00,
+    0x86, 0x26, 0x00, 0x86, 0x26, 0x00, 0x86, 0x26,
+    0x00, 0x9f, 0x1d, 0xd2, 0x19, 0x2c, 0x99, 0x2f,
+    0x00, 0xd8, 0x2f, 0x0b, 0xe0, 0x75, 0x2f, 0x19,
+    0x8b, 0x19, 0x03, 0x84, 0x19, 0x80, 0x2f, 0x80,
+    0x19, 0x80, 0x2f, 0x98, 0x19, 0x88, 0x2f, 0x83,
+    0x37, 0x81, 0x30, 0x87, 0x19, 0x83, 0x2f, 0x83,
+    0x19, 0x00, 0xd5, 0x35, 0x01, 0x81, 0x37, 0x81,
+    0x19, 0x82, 0x35, 0x80, 0x19, 0xd9, 0x3d, 0x81,
+    0x19, 0x82, 0x3d, 0x04, 0xaa, 0x0d, 0x00, 0xdd,
+    0x30, 0x00, 0x8f, 0x19, 0x9f, 0x0d, 0xa3, 0x19,
+    0x0b, 0x8f, 0x3d, 0x9e, 0x30, 0x00, 0xbf, 0x19,
+    0x9e, 0x30, 0xd0, 0x19, 0xae, 0x3d, 0x80, 0x19,
+    0xd7, 0x3d, 0xe0, 0x47, 0x19, 0xf0, 0x09, 0x5f,
+    0x2f, 0xbf, 0x19, 0xf0, 0x41, 0x9c, 0x2f, 0x02,
+    0xe4, 0x2c, 0x9b, 0x02, 0xb6, 0x9b, 0x08, 0xaf,
+    0x4a, 0xe0, 0xcb, 0x97, 0x13, 0xdf, 0x1d, 0xd7,
+    0x08, 0x07, 0xa1, 0x19, 0xe0, 0x05, 0x45, 0x82,
+    0x19, 0xb4, 0x45, 0x01, 0x88, 0x45, 0x29, 0x8a,
+    0x45, 0xac, 0x86, 0x02, 0x89, 0x19, 0x05, 0xb7,
+    0x76, 0x07, 0xc5, 0x7c, 0x07, 0x8b, 0x7c, 0x05,
+    0x9f, 0x1f, 0xad, 0x3e, 0x80, 0x19, 0x80, 0x3e,
+    0xa3, 0x79, 0x0a, 0x80, 0x79, 0x9c, 0x30, 0x02,
+    0xcd, 0x3a, 0x00, 0x80, 0x19, 0x89, 0x3a, 0x03,
+    0x81, 0x3a, 0x9e, 0x5e, 0x00, 0xb6, 0x16, 0x08,
+    0x8d, 0x16, 0x01, 0x89, 0x16, 0x01, 0x83, 0x16,
+    0x9f, 0x5e, 0xc2, 0x8c, 0x17, 0x84, 0x8c, 0x96,
+    0x55, 0x09, 0x85, 0x26, 0x01, 0x85, 0x26, 0x01,
+    0x85, 0x26, 0x08, 0x86, 0x26, 0x00, 0x86, 0x26,
+    0x00, 0xaa, 0x45, 0x80, 0x19, 0x88, 0x45, 0x80,
+    0x2b, 0x83, 0x45, 0x81, 0x19, 0x03, 0xcf, 0x17,
+    0xad, 0x55, 0x01, 0x89, 0x55, 0x05, 0xf0, 0x1b,
+    0x43, 0x30, 0x0b, 0x96, 0x30, 0x03, 0xb0, 0x30,
+    0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x2f, 0x01, 0xe0,
+    0x09, 0x2f, 0x25, 0x86, 0x45, 0x0b, 0x84, 0x05,
+    0x04, 0x99, 0x34, 0x00, 0x84, 0x34, 0x00, 0x80,
+    0x34, 0x00, 0x81, 0x34, 0x00, 0x81, 0x34, 0x00,
+    0x89, 0x34, 0xe0, 0x11, 0x04, 0x10, 0xe1, 0x0a,
+    0x04, 0x81, 0x19, 0x0f, 0xbf, 0x04, 0x01, 0xb5,
+    0x04, 0x27, 0x8d, 0x04, 0x01, 0x8f, 0x37, 0x89,
+    0x19, 0x05, 0x8d, 0x37, 0x81, 0x1d, 0xa2, 0x19,
+    0x00, 0x92, 0x19, 0x00, 0x83, 0x19, 0x03, 0x84,
+    0x04, 0x00, 0xe0, 0x26, 0x04, 0x01, 0x80, 0x19,
+    0x00, 0x9f, 0x19, 0x99, 0x45, 0x85, 0x19, 0x99,
+    0x45, 0x8a, 0x19, 0x89, 0x3d, 0x80, 0x19, 0xac,
+    0x3d, 0x81, 0x19, 0x9e, 0x30, 0x02, 0x85, 0x30,
+    0x01, 0x85, 0x30, 0x01, 0x85, 0x30, 0x01, 0x82,
+    0x30, 0x02, 0x86, 0x19, 0x00, 0x86, 0x19, 0x09,
+    0x84, 0x19, 0x01, 0x8b, 0x49, 0x00, 0x99, 0x49,
+    0x00, 0x92, 0x49, 0x00, 0x81, 0x49, 0x00, 0x8e,
+    0x49, 0x01, 0x8d, 0x49, 0x21, 0xe0, 0x1a, 0x49,
+    0x04, 0x82, 0x19, 0x03, 0xac, 0x19, 0x02, 0x88,
+    0x19, 0xce, 0x2b, 0x00, 0x8c, 0x19, 0x02, 0x80,
+    0x2b, 0x2e, 0xac, 0x19, 0x80, 0x37, 0x60, 0x21,
+    0x9c, 0x4b, 0x02, 0xb0, 0x13, 0x0e, 0x80, 0x37,
+    0x9a, 0x19, 0x03, 0xa3, 0x69, 0x08, 0x82, 0x69,
+    0x9a, 0x29, 0x04, 0xaa, 0x6b, 0x04, 0x9d, 0x96,
+    0x00, 0x80, 0x96, 0xa3, 0x6c, 0x03, 0x8d, 0x6c,
+    0x29, 0xcf, 0x1e, 0xaf, 0x7e, 0x9d, 0x72, 0x01,
+    0x89, 0x72, 0x05, 0xa3, 0x71, 0x03, 0xa3, 0x71,
+    0x03, 0xa7, 0x24, 0x07, 0xb3, 0x14, 0x0a, 0x80,
+    0x14, 0x60, 0x2f, 0xe0, 0xd6, 0x48, 0x08, 0x95,
+    0x48, 0x09, 0x87, 0x48, 0x60, 0x37, 0x85, 0x1c,
+    0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c, 0x00, 0x81,
+    0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80, 0x1c, 0x95,
+    0x36, 0x00, 0x88, 0x36, 0x9f, 0x74, 0x9e, 0x5f,
+    0x07, 0x88, 0x5f, 0x2f, 0x92, 0x33, 0x00, 0x81,
+    0x33, 0x04, 0x84, 0x33, 0x9b, 0x77, 0x02, 0x80,
+    0x77, 0x99, 0x4c, 0x04, 0x80, 0x4c, 0x3f, 0x9f,
+    0x58, 0x97, 0x57, 0x03, 0x93, 0x57, 0x01, 0xad,
+    0x57, 0x83, 0x3f, 0x00, 0x81, 0x3f, 0x04, 0x87,
+    0x3f, 0x00, 0x82, 0x3f, 0x00, 0x9c, 0x3f, 0x01,
+    0x82, 0x3f, 0x03, 0x89, 0x3f, 0x06, 0x88, 0x3f,
+    0x06, 0x9f, 0x6e, 0x9f, 0x6a, 0x1f, 0xa6, 0x51,
+    0x03, 0x8b, 0x51, 0x08, 0xb5, 0x06, 0x02, 0x86,
+    0x06, 0x95, 0x39, 0x01, 0x87, 0x39, 0x92, 0x38,
+    0x04, 0x87, 0x38, 0x91, 0x78, 0x06, 0x83, 0x78,
+    0x0b, 0x86, 0x78, 0x4f, 0xc8, 0x6f, 0x36, 0xb2,
+    0x68, 0x0c, 0xb2, 0x68, 0x06, 0x85, 0x68, 0xa7,
+    0x31, 0x07, 0x89, 0x31, 0x60, 0xc5, 0x9e, 0x04,
+    0x00, 0xa9, 0x9a, 0x00, 0x82, 0x9a, 0x01, 0x81,
+    0x9a, 0x4d, 0xa7, 0x6d, 0x07, 0xa9, 0x82, 0x55,
+    0x9b, 0x18, 0x13, 0x96, 0x25, 0x08, 0xcd, 0x0e,
+    0x03, 0x9d, 0x0e, 0x0e, 0x80, 0x0e, 0xc1, 0x3b,
+    0x0a, 0x80, 0x3b, 0x01, 0x98, 0x83, 0x06, 0x89,
+    0x83, 0x05, 0xb4, 0x15, 0x00, 0x91, 0x15, 0x07,
+    0xa6, 0x4e, 0x08, 0xdf, 0x7d, 0x00, 0x93, 0x81,
+    0x0a, 0x91, 0x41, 0x00, 0xab, 0x41, 0x40, 0x86,
+    0x5d, 0x00, 0x80, 0x5d, 0x00, 0x83, 0x5d, 0x00,
+    0x8e, 0x5d, 0x00, 0x8a, 0x5d, 0x05, 0xba, 0x43,
+    0x04, 0x89, 0x43, 0x05, 0x83, 0x2a, 0x00, 0x87,
+    0x2a, 0x01, 0x81, 0x2a, 0x01, 0x95, 0x2a, 0x00,
+    0x86, 0x2a, 0x00, 0x81, 0x2a, 0x00, 0x84, 0x2a,
+    0x00, 0x80, 0x37, 0x88, 0x2a, 0x01, 0x81, 0x2a,
+    0x01, 0x82, 0x2a, 0x01, 0x80, 0x2a, 0x05, 0x80,
+    0x2a, 0x04, 0x86, 0x2a, 0x01, 0x86, 0x2a, 0x02,
+    0x84, 0x2a, 0x60, 0x2a, 0xdb, 0x62, 0x00, 0x84,
+    0x62, 0x1d, 0xc7, 0x95, 0x07, 0x89, 0x95, 0x60,
+    0x45, 0xb5, 0x7f, 0x01, 0xa5, 0x7f, 0x21, 0xc4,
+    0x5a, 0x0a, 0x89, 0x5a, 0x05, 0x8c, 0x5b, 0x12,
+    0xb8, 0x8d, 0x06, 0x89, 0x8d, 0x35, 0x9a, 0x02,
+    0x01, 0x8e, 0x02, 0x03, 0x8f, 0x02, 0x60, 0x5f,
+    0xbb, 0x21, 0x60, 0x03, 0xd2, 0x99, 0x0b, 0x80,
+    0x99, 0x86, 0x20, 0x01, 0x80, 0x20, 0x01, 0x87,
+    0x20, 0x00, 0x81, 0x20, 0x00, 0x9d, 0x20, 0x00,
+    0x81, 0x20, 0x01, 0x8b, 0x20, 0x08, 0x89, 0x20,
+    0x45, 0x87, 0x60, 0x01, 0xad, 0x60, 0x01, 0x8a,
+    0x60, 0x1a, 0xc7, 0x9c, 0x07, 0xd2, 0x84, 0x1c,
+    0xb8, 0x75, 0x60, 0xa6, 0x88, 0x0c, 0x00, 0xac,
+    0x0c, 0x00, 0x8d, 0x0c, 0x09, 0x9c, 0x0c, 0x02,
+    0x9f, 0x52, 0x01, 0x95, 0x52, 0x00, 0x8d, 0x52,
+    0x48, 0x86, 0x53, 0x00, 0x81, 0x53, 0x00, 0xab,
+    0x53, 0x02, 0x80, 0x53, 0x00, 0x81, 0x53, 0x00,
+    0x88, 0x53, 0x07, 0x89, 0x53, 0x05, 0x85, 0x2d,
+    0x00, 0x81, 0x2d, 0x00, 0xa4, 0x2d, 0x00, 0x81,
+    0x2d, 0x00, 0x85, 0x2d, 0x06, 0x89, 0x2d, 0x60,
+    0xd5, 0x98, 0x4d, 0x60, 0x56, 0x80, 0x4a, 0x0e,
+    0xb1, 0x8e, 0x0c, 0x80, 0x8e, 0xe3, 0x39, 0x1b,
+    0x60, 0x05, 0xe0, 0x0e, 0x1b, 0x00, 0x84, 0x1b,
+    0x0a, 0xe0, 0x63, 0x1b, 0x6a, 0x5b, 0xe3, 0xce,
+    0x23, 0x00, 0x88, 0x23, 0x6f, 0x66, 0xe1, 0xe6,
+    0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8, 0x08, 0x06,
+    0x9e, 0x5c, 0x00, 0x89, 0x5c, 0x03, 0x81, 0x5c,
+    0x5f, 0x9d, 0x09, 0x01, 0x85, 0x09, 0x09, 0xc5,
+    0x73, 0x09, 0x89, 0x73, 0x00, 0x86, 0x73, 0x00,
+    0x94, 0x73, 0x04, 0x92, 0x73, 0x62, 0x4f, 0xda,
+    0x54, 0x60, 0x04, 0xca, 0x59, 0x03, 0xb8, 0x59,
+    0x06, 0x90, 0x59, 0x3f, 0x80, 0x8f, 0x80, 0x64,
+    0x81, 0x19, 0x80, 0x42, 0x0a, 0x81, 0x2f, 0x0d,
+    0xf0, 0x07, 0x97, 0x8f, 0x07, 0xe2, 0x9f, 0x8f,
+    0xe1, 0x75, 0x42, 0x29, 0x88, 0x8f, 0x70, 0x12,
+    0x96, 0x80, 0x3d, 0xe0, 0xbd, 0x35, 0x30, 0x82,
+    0x35, 0x10, 0x83, 0x3d, 0x07, 0xe1, 0x2b, 0x64,
+    0x68, 0xa3, 0xe0, 0x0a, 0x22, 0x04, 0x8c, 0x22,
+    0x02, 0x88, 0x22, 0x06, 0x89, 0x22, 0x01, 0x83,
+    0x22, 0x83, 0x19, 0x70, 0x02, 0xfb, 0xe0, 0x95,
+    0x19, 0x09, 0xa6, 0x19, 0x01, 0xbd, 0x19, 0x82,
+    0x37, 0x90, 0x19, 0x87, 0x37, 0x81, 0x19, 0x86,
+    0x37, 0x9d, 0x19, 0x83, 0x37, 0xba, 0x19, 0x16,
+    0xc5, 0x2b, 0x60, 0x39, 0x93, 0x19, 0x0b, 0xd6,
+    0x19, 0x08, 0x98, 0x19, 0x60, 0x26, 0xd4, 0x19,
+    0x00, 0xc6, 0x19, 0x00, 0x81, 0x19, 0x01, 0x80,
+    0x19, 0x01, 0x81, 0x19, 0x01, 0x83, 0x19, 0x00,
+    0x8b, 0x19, 0x00, 0x80, 0x19, 0x00, 0x86, 0x19,
+    0x00, 0xc0, 0x19, 0x00, 0x83, 0x19, 0x01, 0x87,
+    0x19, 0x00, 0x86, 0x19, 0x00, 0x9b, 0x19, 0x00,
+    0x83, 0x19, 0x00, 0x84, 0x19, 0x00, 0x80, 0x19,
+    0x02, 0x86, 0x19, 0x00, 0xe0, 0xf3, 0x19, 0x01,
+    0xe0, 0xc3, 0x19, 0x01, 0xb1, 0x19, 0xe2, 0x2b,
+    0x80, 0x0e, 0x84, 0x80, 0x00, 0x8e, 0x80, 0x64,
+    0xef, 0x86, 0x28, 0x00, 0x90, 0x28, 0x01, 0x86,
+    0x28, 0x00, 0x81, 0x28, 0x00, 0x84, 0x28, 0x60,
+    0x74, 0xac, 0x65, 0x02, 0x8d, 0x65, 0x01, 0x89,
+    0x65, 0x03, 0x81, 0x65, 0x61, 0x0f, 0xb9, 0x98,
+    0x04, 0x80, 0x98, 0x64, 0x9f, 0xe0, 0x64, 0x56,
+    0x01, 0x8f, 0x56, 0x28, 0xcb, 0x01, 0x03, 0x89,
+    0x01, 0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19,
+    0x4b, 0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00,
+    0x9a, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
+    0x01, 0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83,
+    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05,
+    0x80, 0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81,
+    0x04, 0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00,
+    0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80,
+    0x04, 0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00,
+    0x83, 0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82,
+    0x04, 0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33,
+    0x81, 0x04, 0x60, 0xad, 0xab, 0x19, 0x03, 0xe0,
+    0x03, 0x19, 0x0b, 0x8e, 0x19, 0x01, 0x8e, 0x19,
+    0x00, 0x8e, 0x19, 0x00, 0xa4, 0x19, 0x09, 0xe0,
+    0x4d, 0x19, 0x37, 0x99, 0x19, 0x80, 0x35, 0x81,
+    0x19, 0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06,
+    0x81, 0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3,
+    0x77, 0x19, 0x07, 0x8c, 0x19, 0x02, 0x8c, 0x19,
+    0x02, 0xe0, 0x13, 0x19, 0x0b, 0xd8, 0x19, 0x06,
+    0x8b, 0x19, 0x13, 0x8b, 0x19, 0x03, 0xb7, 0x19,
+    0x07, 0x89, 0x19, 0x05, 0xa7, 0x19, 0x07, 0x9d,
+    0x19, 0x01, 0x81, 0x19, 0x4d, 0xe0, 0x18, 0x19,
+    0x00, 0xd1, 0x19, 0x00, 0xe0, 0x26, 0x19, 0x0b,
+    0x8d, 0x19, 0x01, 0x84, 0x19, 0x02, 0x82, 0x19,
+    0x04, 0x86, 0x19, 0x08, 0x98, 0x19, 0x06, 0x86,
+    0x19, 0x08, 0x82, 0x19, 0x0c, 0x86, 0x19, 0x28,
+    0xe0, 0x32, 0x19, 0x00, 0xb6, 0x19, 0x24, 0x89,
+    0x19, 0x63, 0xa5, 0xf0, 0x96, 0x7d, 0x2f, 0x21,
+    0xef, 0xd4, 0x2f, 0x0a, 0xe0, 0x7d, 0x2f, 0x01,
+    0xf0, 0x06, 0x21, 0x2f, 0x0d, 0xf0, 0x0c, 0xd0,
+    0x2f, 0x6b, 0xbe, 0xe1, 0xbd, 0x2f, 0x65, 0x81,
+    0xf0, 0x02, 0xea, 0x2f, 0x7a, 0xdc, 0x55, 0x80,
+    0x19, 0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0, 0x8f,
+    0x37,
 };
 
-static const uint8_t unicode_script_ext_table[789] = {
-    0x82, 0xc1, 0x00, 0x00, 0x01, 0x29, 0x01, 0x00,
-    0x00, 0x01, 0x29, 0x1c, 0x00, 0x0c, 0x01, 0x42,
-    0x80, 0x92, 0x00, 0x00, 0x02, 0x1c, 0x68, 0x00,
-    0x02, 0x1c, 0x26, 0x01, 0x02, 0x1c, 0x42, 0x00,
-    0x02, 0x1c, 0x26, 0x80, 0x80, 0x00, 0x00, 0x02,
-    0x05, 0x25, 0x80, 0x01, 0x00, 0x00, 0x04, 0x04,
-    0x2f, 0x84, 0x8e, 0x0d, 0x00, 0x00, 0x04, 0x04,
-    0x2f, 0x84, 0x8e, 0x00, 0x03, 0x04, 0x84, 0x8e,
-    0x01, 0x00, 0x00, 0x04, 0x04, 0x2f, 0x84, 0x8e,
-    0x1f, 0x00, 0x00, 0x08, 0x01, 0x04, 0x4d, 0x4e,
-    0x75, 0x2f, 0x7f, 0x84, 0x09, 0x00, 0x0a, 0x02,
-    0x04, 0x84, 0x09, 0x00, 0x09, 0x02, 0x04, 0x8e,
-    0x05, 0x00, 0x00, 0x02, 0x04, 0x84, 0x62, 0x00,
-    0x00, 0x02, 0x04, 0x2f, 0x81, 0xfb, 0x00, 0x00,
-    0x0d, 0x0b, 0x1e, 0x28, 0x2a, 0x2c, 0x3a, 0x42,
-    0x4c, 0x6d, 0x7a, 0x8b, 0x8d, 0x92, 0x00, 0x0c,
-    0x0b, 0x1e, 0x28, 0x2a, 0x2c, 0x3a, 0x42, 0x4c,
-    0x6d, 0x8b, 0x8d, 0x92, 0x10, 0x00, 0x00, 0x14,
-    0x0b, 0x1e, 0x1f, 0x2b, 0x50, 0x28, 0x2a, 0x2c,
-    0x3a, 0x4b, 0x4c, 0x5d, 0x6d, 0x40, 0x7e, 0x83,
-    0x8a, 0x8b, 0x8d, 0x92, 0x00, 0x15, 0x0b, 0x1e,
-    0x1f, 0x2b, 0x50, 0x28, 0x2a, 0x2c, 0x3a, 0x44,
-    0x4b, 0x4c, 0x5d, 0x6d, 0x40, 0x7e, 0x83, 0x8a,
-    0x8b, 0x8d, 0x92, 0x09, 0x04, 0x1e, 0x1f, 0x39,
-    0x4b, 0x75, 0x00, 0x09, 0x03, 0x0b, 0x15, 0x83,
-    0x75, 0x00, 0x09, 0x02, 0x2c, 0x5a, 0x75, 0x00,
-    0x09, 0x02, 0x2a, 0x3f, 0x80, 0x75, 0x00, 0x0d,
-    0x02, 0x28, 0x8b, 0x80, 0x71, 0x00, 0x09, 0x02,
-    0x3a, 0x5d, 0x82, 0xcf, 0x00, 0x09, 0x03, 0x15,
-    0x5b, 0x87, 0x80, 0x30, 0x00, 0x00, 0x02, 0x25,
-    0x42, 0x85, 0xb8, 0x00, 0x01, 0x04, 0x11, 0x30,
-    0x86, 0x85, 0x80, 0x4a, 0x00, 0x01, 0x02, 0x58,
-    0x73, 0x00, 0x00, 0x00, 0x02, 0x58, 0x73, 0x84,
-    0x49, 0x00, 0x00, 0x04, 0x0b, 0x1e, 0x28, 0x3a,
-    0x00, 0x01, 0x1e, 0x00, 0x04, 0x0b, 0x1e, 0x28,
-    0x3a, 0x00, 0x02, 0x1e, 0x28, 0x00, 0x01, 0x1e,
-    0x01, 0x02, 0x0b, 0x1e, 0x00, 0x02, 0x1e, 0x7a,
-    0x00, 0x02, 0x0b, 0x1e, 0x00, 0x02, 0x1e, 0x7a,
-    0x00, 0x06, 0x1e, 0x3a, 0x4c, 0x6d, 0x8b, 0x8d,
-    0x00, 0x01, 0x1e, 0x01, 0x02, 0x1e, 0x7a, 0x01,
-    0x01, 0x1e, 0x00, 0x02, 0x1e, 0x7a, 0x00, 0x02,
-    0x0b, 0x1e, 0x06, 0x01, 0x1e, 0x00, 0x02, 0x1e,
-    0x5d, 0x00, 0x02, 0x0b, 0x1e, 0x01, 0x01, 0x1e,
-    0x00, 0x02, 0x0b, 0x1e, 0x03, 0x01, 0x1e, 0x00,
-    0x08, 0x0b, 0x1e, 0x28, 0x3a, 0x5d, 0x6d, 0x8d,
-    0x92, 0x00, 0x02, 0x1e, 0x28, 0x00, 0x03, 0x1e,
-    0x28, 0x3a, 0x01, 0x02, 0x0b, 0x1e, 0x00, 0x01,
-    0x0b, 0x01, 0x02, 0x1e, 0x28, 0x00, 0x01, 0x5d,
-    0x80, 0x44, 0x00, 0x01, 0x01, 0x29, 0x81, 0xec,
-    0x00, 0x00, 0x02, 0x42, 0x58, 0x80, 0x3f, 0x00,
-    0x00, 0x03, 0x1e, 0x28, 0x42, 0x8c, 0xd1, 0x00,
-    0x00, 0x02, 0x1c, 0x26, 0x81, 0x3c, 0x00, 0x01,
-    0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x00,
-    0x05, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x01, 0x00,
-    0x00, 0x01, 0x2d, 0x00, 0x00, 0x09, 0x06, 0x0d,
-    0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x00, 0x00, 0x00,
-    0x05, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x07, 0x06,
-    0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x03, 0x05,
-    0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x09, 0x00, 0x03,
-    0x02, 0x0d, 0x2d, 0x01, 0x00, 0x00, 0x05, 0x0d,
-    0x2e, 0x2d, 0x33, 0x3b, 0x04, 0x02, 0x33, 0x3b,
-    0x00, 0x00, 0x00, 0x05, 0x0d, 0x2e, 0x2d, 0x33,
-    0x3b, 0x03, 0x00, 0x01, 0x03, 0x2d, 0x33, 0x3b,
-    0x01, 0x01, 0x2d, 0x58, 0x00, 0x03, 0x02, 0x33,
-    0x3b, 0x02, 0x00, 0x00, 0x02, 0x33, 0x3b, 0x59,
-    0x00, 0x00, 0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b,
-    0x97, 0x00, 0x02, 0x33, 0x3b, 0x80, 0x12, 0x00,
-    0x0f, 0x01, 0x2d, 0x1f, 0x00, 0x23, 0x01, 0x2d,
-    0x3b, 0x00, 0x27, 0x01, 0x2d, 0x37, 0x00, 0x30,
-    0x01, 0x2d, 0x0e, 0x00, 0x0b, 0x01, 0x2d, 0x32,
-    0x00, 0x00, 0x01, 0x2d, 0x57, 0x00, 0x18, 0x01,
-    0x2d, 0x09, 0x00, 0x04, 0x01, 0x2d, 0x5f, 0x00,
-    0x1e, 0x01, 0x2d, 0xc0, 0x31, 0xef, 0x00, 0x00,
-    0x02, 0x1c, 0x26, 0x81, 0x3f, 0x00, 0x02, 0x0e,
-    0x1e, 0x1f, 0x2a, 0x2c, 0x3f, 0x3a, 0x39, 0x4b,
-    0x4c, 0x57, 0x5d, 0x40, 0x8a, 0x92, 0x02, 0x0d,
-    0x1e, 0x1f, 0x2a, 0x2c, 0x3f, 0x3a, 0x39, 0x4b,
-    0x57, 0x5d, 0x40, 0x8a, 0x92, 0x03, 0x0b, 0x1e,
-    0x1f, 0x2a, 0x2c, 0x3f, 0x39, 0x4b, 0x57, 0x40,
-    0x8a, 0x92, 0x80, 0x36, 0x00, 0x00, 0x02, 0x0b,
-    0x1e, 0x00, 0x00, 0x00, 0x02, 0x1e, 0x8b, 0x39,
-    0x00, 0x00, 0x03, 0x3c, 0x42, 0x5b, 0x80, 0x1f,
-    0x00, 0x00, 0x02, 0x10, 0x38, 0xc0, 0x13, 0xa1,
-    0x00, 0x00, 0x02, 0x04, 0x8e, 0x09, 0x00, 0x00,
-    0x02, 0x04, 0x8e, 0x46, 0x00, 0x01, 0x05, 0x0d,
-    0x2e, 0x2d, 0x33, 0x3b, 0x80, 0x99, 0x00, 0x04,
-    0x06, 0x0d, 0x2e, 0x2d, 0x33, 0x3b, 0x97, 0x09,
-    0x00, 0x00, 0x02, 0x33, 0x3b, 0x2c, 0x00, 0x01,
-    0x02, 0x33, 0x3b, 0x80, 0xdf, 0x00, 0x02, 0x02,
-    0x1b, 0x46, 0x03, 0x00, 0x2c, 0x03, 0x1b, 0x45,
-    0x46, 0x02, 0x00, 0x08, 0x02, 0x1b, 0x46, 0x81,
-    0x1f, 0x00, 0x1b, 0x02, 0x04, 0x19, 0x8f, 0x84,
-    0x00, 0x00, 0x02, 0x28, 0x8b, 0x00, 0x00, 0x00,
-    0x02, 0x28, 0x8b, 0x36, 0x00, 0x01, 0x02, 0x28,
-    0x8b, 0x8c, 0x12, 0x00, 0x01, 0x02, 0x28, 0x8b,
-    0x00, 0x00, 0x00, 0x02, 0x28, 0x8b, 0xc0, 0x5c,
-    0x4b, 0x00, 0x03, 0x01, 0x20, 0x96, 0x3b, 0x00,
-    0x11, 0x01, 0x2d, 0x9e, 0x5d, 0x00, 0x01, 0x01,
-    0x2d, 0xce, 0xcd, 0x2d, 0x00,
+static const uint8_t unicode_script_ext_table[799] = {
+    0x82, 0xc1, 0x00, 0x00, 0x01, 0x2b, 0x01, 0x00,
+    0x00, 0x01, 0x2b, 0x1c, 0x00, 0x0c, 0x01, 0x45,
+    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6b, 0x00,
+    0x02, 0x1d, 0x28, 0x01, 0x02, 0x1d, 0x45, 0x00,
+    0x02, 0x1d, 0x28, 0x81, 0x03, 0x00, 0x00, 0x05,
+    0x04, 0x31, 0x87, 0x91, 0x9a, 0x0d, 0x00, 0x00,
+    0x05, 0x04, 0x31, 0x87, 0x91, 0x9a, 0x00, 0x03,
+    0x04, 0x87, 0x91, 0x01, 0x00, 0x00, 0x05, 0x04,
+    0x31, 0x87, 0x91, 0x9a, 0x1f, 0x00, 0x00, 0x08,
+    0x01, 0x04, 0x50, 0x51, 0x78, 0x31, 0x82, 0x87,
+    0x09, 0x00, 0x0a, 0x02, 0x04, 0x87, 0x09, 0x00,
+    0x09, 0x03, 0x04, 0x91, 0x9a, 0x05, 0x00, 0x00,
+    0x02, 0x04, 0x87, 0x62, 0x00, 0x00, 0x02, 0x04,
+    0x31, 0x81, 0xfb, 0x00, 0x00, 0x0d, 0x0b, 0x1f,
+    0x2a, 0x2c, 0x2e, 0x3c, 0x45, 0x4f, 0x70, 0x7d,
+    0x8e, 0x90, 0x95, 0x00, 0x0c, 0x0b, 0x1f, 0x2a,
+    0x2c, 0x2e, 0x3c, 0x45, 0x4f, 0x70, 0x8e, 0x90,
+    0x95, 0x10, 0x00, 0x00, 0x14, 0x0b, 0x1f, 0x21,
+    0x2d, 0x53, 0x2a, 0x2c, 0x2e, 0x3c, 0x4e, 0x4f,
+    0x60, 0x70, 0x43, 0x81, 0x86, 0x8d, 0x8e, 0x90,
+    0x95, 0x00, 0x15, 0x0b, 0x1f, 0x21, 0x2d, 0x53,
+    0x2a, 0x2c, 0x2e, 0x3c, 0x47, 0x4e, 0x4f, 0x60,
+    0x70, 0x43, 0x81, 0x86, 0x8d, 0x8e, 0x90, 0x95,
+    0x09, 0x04, 0x1f, 0x21, 0x3b, 0x4e, 0x75, 0x00,
+    0x09, 0x03, 0x0b, 0x15, 0x86, 0x75, 0x00, 0x09,
+    0x02, 0x2e, 0x5d, 0x75, 0x00, 0x09, 0x02, 0x2c,
+    0x41, 0x80, 0x75, 0x00, 0x0d, 0x02, 0x2a, 0x8e,
+    0x80, 0x71, 0x00, 0x09, 0x02, 0x3c, 0x60, 0x82,
+    0xcf, 0x00, 0x09, 0x03, 0x15, 0x5e, 0x8a, 0x80,
+    0x30, 0x00, 0x00, 0x02, 0x27, 0x45, 0x85, 0xb8,
+    0x00, 0x01, 0x04, 0x11, 0x32, 0x89, 0x88, 0x80,
+    0x4a, 0x00, 0x01, 0x02, 0x5b, 0x76, 0x00, 0x00,
+    0x00, 0x02, 0x5b, 0x76, 0x84, 0x49, 0x00, 0x00,
+    0x04, 0x0b, 0x1f, 0x2a, 0x3c, 0x00, 0x01, 0x1f,
+    0x00, 0x04, 0x0b, 0x1f, 0x2a, 0x3c, 0x00, 0x02,
+    0x1f, 0x2a, 0x00, 0x01, 0x1f, 0x01, 0x02, 0x0b,
+    0x1f, 0x00, 0x02, 0x1f, 0x7d, 0x00, 0x02, 0x0b,
+    0x1f, 0x00, 0x02, 0x1f, 0x7d, 0x00, 0x06, 0x1f,
+    0x3c, 0x4f, 0x70, 0x8e, 0x90, 0x00, 0x01, 0x1f,
+    0x01, 0x02, 0x1f, 0x7d, 0x01, 0x01, 0x1f, 0x00,
+    0x02, 0x1f, 0x7d, 0x00, 0x02, 0x0b, 0x1f, 0x06,
+    0x01, 0x1f, 0x00, 0x02, 0x1f, 0x60, 0x00, 0x02,
+    0x0b, 0x1f, 0x01, 0x01, 0x1f, 0x00, 0x02, 0x0b,
+    0x1f, 0x03, 0x01, 0x1f, 0x00, 0x08, 0x0b, 0x1f,
+    0x2a, 0x3c, 0x60, 0x70, 0x90, 0x95, 0x00, 0x02,
+    0x1f, 0x2a, 0x00, 0x03, 0x1f, 0x2a, 0x3c, 0x01,
+    0x02, 0x0b, 0x1f, 0x00, 0x01, 0x0b, 0x01, 0x02,
+    0x1f, 0x2a, 0x00, 0x01, 0x60, 0x80, 0x44, 0x00,
+    0x01, 0x01, 0x2b, 0x35, 0x00, 0x00, 0x02, 0x1d,
+    0x87, 0x81, 0xb5, 0x00, 0x00, 0x02, 0x45, 0x5b,
+    0x80, 0x3f, 0x00, 0x00, 0x03, 0x1f, 0x2a, 0x45,
+    0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d, 0x28, 0x81,
+    0x3c, 0x00, 0x01, 0x06, 0x0d, 0x30, 0x2f, 0x35,
+    0x3d, 0x9b, 0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35,
+    0x3d, 0x01, 0x00, 0x00, 0x01, 0x2f, 0x00, 0x00,
+    0x09, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x9b,
+    0x00, 0x00, 0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35,
+    0x3d, 0x07, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
+    0x9b, 0x03, 0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
+    0x09, 0x00, 0x03, 0x02, 0x0d, 0x2f, 0x01, 0x00,
+    0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x04,
+    0x02, 0x35, 0x3d, 0x00, 0x00, 0x00, 0x05, 0x0d,
+    0x30, 0x2f, 0x35, 0x3d, 0x03, 0x00, 0x01, 0x03,
+    0x2f, 0x35, 0x3d, 0x01, 0x01, 0x2f, 0x58, 0x00,
+    0x03, 0x02, 0x35, 0x3d, 0x02, 0x00, 0x00, 0x02,
+    0x35, 0x3d, 0x59, 0x00, 0x00, 0x06, 0x0d, 0x30,
+    0x2f, 0x35, 0x3d, 0x9b, 0x00, 0x02, 0x35, 0x3d,
+    0x80, 0x12, 0x00, 0x0f, 0x01, 0x2f, 0x1f, 0x00,
+    0x23, 0x01, 0x2f, 0x3b, 0x00, 0x27, 0x01, 0x2f,
+    0x37, 0x00, 0x30, 0x01, 0x2f, 0x0e, 0x00, 0x0b,
+    0x01, 0x2f, 0x32, 0x00, 0x00, 0x01, 0x2f, 0x57,
+    0x00, 0x18, 0x01, 0x2f, 0x09, 0x00, 0x04, 0x01,
+    0x2f, 0x5f, 0x00, 0x1e, 0x01, 0x2f, 0xc0, 0x31,
+    0xef, 0x00, 0x00, 0x02, 0x1d, 0x28, 0x80, 0x0f,
+    0x00, 0x07, 0x02, 0x2f, 0x45, 0x80, 0xa7, 0x00,
+    0x02, 0x0e, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3c,
+    0x3b, 0x4e, 0x4f, 0x5a, 0x60, 0x43, 0x8d, 0x95,
+    0x02, 0x0d, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3c,
+    0x3b, 0x4e, 0x5a, 0x60, 0x43, 0x8d, 0x95, 0x03,
+    0x0b, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3b, 0x4e,
+    0x5a, 0x43, 0x8d, 0x95, 0x80, 0x36, 0x00, 0x00,
+    0x02, 0x0b, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x1f,
+    0x8e, 0x39, 0x00, 0x00, 0x03, 0x3e, 0x45, 0x5e,
+    0x80, 0x1f, 0x00, 0x00, 0x02, 0x10, 0x3a, 0xc0,
+    0x13, 0xa1, 0x00, 0x00, 0x02, 0x04, 0x91, 0x09,
+    0x00, 0x00, 0x02, 0x04, 0x91, 0x46, 0x00, 0x01,
+    0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x80, 0x99,
+    0x00, 0x04, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
+    0x9b, 0x09, 0x00, 0x00, 0x02, 0x35, 0x3d, 0x2c,
+    0x00, 0x01, 0x02, 0x35, 0x3d, 0x80, 0xdf, 0x00,
+    0x02, 0x02, 0x1c, 0x49, 0x03, 0x00, 0x2c, 0x03,
+    0x1c, 0x48, 0x49, 0x02, 0x00, 0x08, 0x02, 0x1c,
+    0x49, 0x81, 0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a,
+    0x8f, 0x84, 0x00, 0x00, 0x02, 0x2a, 0x8e, 0x00,
+    0x00, 0x00, 0x02, 0x2a, 0x8e, 0x36, 0x00, 0x01,
+    0x02, 0x2a, 0x8e, 0x8c, 0x12, 0x00, 0x01, 0x02,
+    0x2a, 0x8e, 0x00, 0x00, 0x00, 0x02, 0x2a, 0x8e,
+    0xc0, 0x5c, 0x4b, 0x00, 0x03, 0x01, 0x22, 0x96,
+    0x3b, 0x00, 0x11, 0x01, 0x2f, 0x9e, 0x5d, 0x00,
+    0x01, 0x01, 0x2f, 0xce, 0xcd, 0x2d, 0x00,
 };
 
 static const uint8_t unicode_prop_Hyphen_table[28] = {
@@ -3501,7 +3544,7 @@ static const uint8_t unicode_prop_Other_Math_table[200] = {
     0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
 };
 
-static const uint8_t unicode_prop_Other_Alphabetic_table[396] = {
+static const uint8_t unicode_prop_Other_Alphabetic_table[411] = {
     0x43, 0x44, 0x80, 0x42, 0x69, 0x8d, 0x00, 0x01,
     0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c, 0x06, 0x8f,
     0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80,
@@ -3517,7 +3560,7 @@ static const uint8_t unicode_prop_Other_Alphabetic_table[396] = {
     0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9c, 0x82,
     0xb9, 0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9b,
     0x83, 0xb9, 0x30, 0x10, 0x82, 0x89, 0x80, 0x89,
-    0x81, 0x9d, 0x81, 0xca, 0x28, 0x00, 0x87, 0x91,
+    0x81, 0x9c, 0x82, 0xca, 0x28, 0x00, 0x87, 0x91,
     0x81, 0xbc, 0x01, 0x86, 0x91, 0x80, 0xe2, 0x01,
     0x28, 0x81, 0x8f, 0x80, 0x40, 0xa2, 0x90, 0x8a,
     0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00, 0x0b, 0x96,
@@ -3525,33 +3568,35 @@ static const uint8_t unicode_prop_Other_Alphabetic_table[396] = {
     0x89, 0x83, 0x46, 0x73, 0x81, 0x9d, 0x81, 0x9d,
     0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40, 0xbb, 0x81,
     0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88, 0x40, 0xdd,
-    0x84, 0xb8, 0x89, 0x81, 0x93, 0x40, 0x8a, 0x84,
-    0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09, 0xb8,
-    0x8a, 0xb1, 0x92, 0x41, 0xaf, 0x8d, 0x46, 0xc0,
-    0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73, 0x87,
-    0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96, 0x84,
-    0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80, 0xa5,
-    0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b, 0xa4,
-    0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac, 0x82,
-    0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24, 0x80,
-    0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80, 0x48,
-    0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0x43,
-    0x13, 0x83, 0x42, 0xd7, 0x82, 0xb4, 0x8d, 0xbb,
-    0x80, 0xac, 0x88, 0xc6, 0x82, 0xa3, 0x8b, 0x91,
-    0x81, 0xb8, 0x82, 0xaf, 0x8c, 0xeb, 0x88, 0x08,
-    0x28, 0x40, 0x9f, 0x89, 0x96, 0x83, 0xb9, 0x31,
-    0x09, 0x81, 0x89, 0x80, 0x89, 0x81, 0x40, 0xd0,
-    0x8c, 0x02, 0xe9, 0x91, 0x40, 0xec, 0x31, 0x86,
-    0x9c, 0x81, 0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6,
-    0x8d, 0x41, 0x00, 0x8c, 0x41, 0x97, 0x31, 0x2b,
-    0x80, 0x9b, 0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a,
-    0xad, 0x8d, 0x41, 0x96, 0x38, 0x86, 0xd2, 0x95,
-    0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x10, 0x02,
-    0x80, 0xc1, 0x20, 0x08, 0x83, 0x41, 0x5b, 0x83,
-    0x60, 0x50, 0x57, 0x00, 0xb6, 0x33, 0x60, 0x4d,
-    0x0a, 0x80, 0x60, 0x23, 0x60, 0x30, 0x90, 0x0e,
-    0x01, 0x04, 0x49, 0x1b, 0x80, 0x47, 0xe7, 0x99,
-    0x85, 0x99, 0x85, 0x99,
+    0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9, 0x81, 0xbe,
+    0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09,
+    0xb8, 0x8a, 0xb1, 0x92, 0x41, 0xaf, 0x8d, 0x46,
+    0xc0, 0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73,
+    0x87, 0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96,
+    0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80,
+    0xa5, 0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b,
+    0xa4, 0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac,
+    0x82, 0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24,
+    0x80, 0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80,
+    0x48, 0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83,
+    0x43, 0x13, 0x83, 0x41, 0x82, 0x81, 0x41, 0x52,
+    0x82, 0xb4, 0x8d, 0xbb, 0x80, 0xac, 0x88, 0xc6,
+    0x82, 0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf,
+    0x8c, 0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x40,
+    0x9f, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09, 0x81,
+    0x89, 0x80, 0x89, 0x81, 0x40, 0xd0, 0x8c, 0x02,
+    0xe9, 0x91, 0x40, 0xec, 0x31, 0x86, 0x9c, 0x81,
+    0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6, 0x8d, 0x41,
+    0x00, 0x8c, 0x40, 0xf6, 0x28, 0x09, 0x0a, 0x00,
+    0x80, 0x40, 0x8d, 0x31, 0x2b, 0x80, 0x9b, 0x89,
+    0xa9, 0x20, 0x83, 0x91, 0x8a, 0xad, 0x8d, 0x41,
+    0x96, 0x38, 0x86, 0xd2, 0x95, 0x80, 0x8d, 0xf9,
+    0x2a, 0x00, 0x08, 0x10, 0x02, 0x80, 0xc1, 0x20,
+    0x08, 0x83, 0x41, 0x5b, 0x83, 0x60, 0x50, 0x57,
+    0x00, 0xb6, 0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab,
+    0x80, 0x60, 0x23, 0x60, 0x30, 0x90, 0x0e, 0x01,
+    0x04, 0x49, 0x1b, 0x80, 0x47, 0xe7, 0x99, 0x85,
+    0x99, 0x85, 0x99,
 };
 
 static const uint8_t unicode_prop_Other_Lowercase_table[51] = {
@@ -3569,15 +3614,16 @@ static const uint8_t unicode_prop_Other_Uppercase_table[15] = {
     0xcc, 0x5f, 0x99, 0x85, 0x99, 0x85, 0x99,
 };
 
-static const uint8_t unicode_prop_Other_Grapheme_Extend_table[62] = {
+static const uint8_t unicode_prop_Other_Grapheme_Extend_table[65] = {
     0x49, 0xbd, 0x80, 0x97, 0x80, 0x41, 0x65, 0x80,
     0x97, 0x80, 0xe5, 0x80, 0x97, 0x80, 0x40, 0xe9,
     0x80, 0x91, 0x81, 0xe6, 0x80, 0x97, 0x80, 0xf6,
     0x80, 0x8e, 0x80, 0x4d, 0x54, 0x80, 0x44, 0xd5,
     0x80, 0x50, 0x20, 0x81, 0x60, 0xcf, 0x6d, 0x81,
     0x53, 0x9d, 0x80, 0x97, 0x80, 0x41, 0x57, 0x80,
-    0x8b, 0x80, 0x40, 0xf0, 0x80, 0x60, 0xbb, 0xb4,
-    0x07, 0x84, 0x6c, 0x2e, 0xac, 0xdf,
+    0x8b, 0x80, 0x40, 0xf0, 0x80, 0x43, 0x7f, 0x80,
+    0x60, 0xb8, 0x33, 0x07, 0x84, 0x6c, 0x2e, 0xac,
+    0xdf,
 };
 
 static const uint8_t unicode_prop_Other_Default_Ignorable_Code_Point_table[32] = {
@@ -3630,7 +3676,7 @@ static const uint8_t unicode_prop_Changes_When_Casefolded1_table[33] = {
     0x84,
 };
 
-static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[436] = {
+static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[441] = {
     0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12,
     0x10, 0x82, 0x9f, 0x80, 0xcf, 0x01, 0x80, 0x8b,
     0x07, 0x80, 0xfb, 0x01, 0x01, 0x80, 0xa5, 0x80,
@@ -3663,29 +3709,30 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[436] = {
     0x80, 0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf,
     0x9e, 0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f,
     0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0x40,
-    0x86, 0x81, 0x43, 0x61, 0x83, 0x60, 0x4d, 0x9f,
-    0x41, 0x0d, 0x08, 0x00, 0x81, 0x89, 0x00, 0x00,
-    0x09, 0x82, 0xc3, 0x81, 0xe9, 0xa5, 0x86, 0x8b,
-    0x24, 0x00, 0x97, 0x04, 0x00, 0x01, 0x01, 0x80,
-    0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5,
-    0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94, 0x81, 0x8b,
-    0x80, 0x92, 0x03, 0x1a, 0x00, 0x80, 0x40, 0x86,
-    0x08, 0x80, 0x9f, 0x99, 0x40, 0x83, 0x15, 0x0d,
-    0x0d, 0x0a, 0x16, 0x06, 0x80, 0x88, 0x60, 0xbc,
-    0xa6, 0x83, 0x54, 0xb9, 0x86, 0x8d, 0x87, 0xbf,
-    0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01, 0x08,
-    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
-    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
-    0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23, 0x81,
-    0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01, 0x00, 0x08,
-    0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00,
-    0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00,
-    0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
-    0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80, 0x9f, 0x99,
-    0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c, 0xab, 0x83,
-    0x88, 0x31, 0x61, 0x05, 0xad, 0x42, 0x1d, 0x6b,
-    0x05, 0xe1, 0x4f, 0xff,
+    0x86, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80, 0x60,
+    0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81, 0x89,
+    0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9, 0xa5,
+    0x86, 0x8b, 0x24, 0x00, 0x97, 0x04, 0x00, 0x01,
+    0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf,
+    0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94,
+    0x81, 0x8b, 0x80, 0x92, 0x03, 0x1a, 0x00, 0x80,
+    0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40, 0x83,
+    0x15, 0x0d, 0x0d, 0x0a, 0x16, 0x06, 0x80, 0x88,
+    0x60, 0xbc, 0xa6, 0x83, 0x54, 0xb9, 0x86, 0x8d,
+    0x87, 0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6,
+    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
+    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
+    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41,
+    0x23, 0x81, 0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01,
+    0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28,
+    0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03,
+    0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04,
+    0x80, 0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80,
+    0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c,
+    0xab, 0x83, 0x88, 0x31, 0x49, 0x9d, 0x89, 0x60,
+    0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1, 0x4f,
+    0xff,
 };
 
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
@@ -3697,14 +3744,14 @@ static const uint8_t unicode_prop_Bidi_Control_table[10] = {
     0xb6, 0x83,
 };
 
-static const uint8_t unicode_prop_Dash_table[50] = {
+static const uint8_t unicode_prop_Dash_table[53] = {
     0xac, 0x80, 0x45, 0x5b, 0x80, 0xb2, 0x80, 0x4e,
     0x40, 0x80, 0x44, 0x04, 0x80, 0x48, 0x08, 0x85,
     0xbc, 0x80, 0xa6, 0x80, 0x8e, 0x80, 0x41, 0x85,
     0x80, 0x4c, 0x03, 0x01, 0x80, 0x9e, 0x0b, 0x80,
     0x41, 0xda, 0x80, 0x92, 0x80, 0xee, 0x80, 0x60,
     0xcd, 0x8f, 0x81, 0xa4, 0x80, 0x89, 0x80, 0x40,
-    0xa8, 0x80,
+    0xa8, 0x80, 0x4f, 0x9e, 0x80,
 };
 
 static const uint8_t unicode_prop_Deprecated_table[23] = {
@@ -3713,7 +3760,7 @@ static const uint8_t unicode_prop_Deprecated_table[23] = {
     0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
 };
 
-static const uint8_t unicode_prop_Diacritic_table[350] = {
+static const uint8_t unicode_prop_Diacritic_table[358] = {
     0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81,
     0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
     0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0,
@@ -3723,55 +3770,57 @@ static const uint8_t unicode_prop_Diacritic_table[350] = {
     0x81, 0x40, 0xc8, 0x9b, 0xbc, 0x80, 0x8f, 0x02,
     0x83, 0x9b, 0x80, 0xc9, 0x80, 0x8f, 0x80, 0xed,
     0x80, 0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xae,
-    0x82, 0xbb, 0x80, 0x8f, 0x80, 0xfe, 0x80, 0xfe,
-    0x80, 0xed, 0x80, 0x8f, 0x80, 0xec, 0x81, 0x8f,
-    0x80, 0xfb, 0x80, 0xfb, 0x28, 0x80, 0xea, 0x80,
-    0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00, 0x03,
-    0x81, 0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef, 0x00,
-    0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80, 0x89,
-    0x81, 0x42, 0xc0, 0x82, 0x44, 0x68, 0x8a, 0x88,
-    0x80, 0x41, 0x5a, 0x82, 0x41, 0x38, 0x39, 0x80,
-    0xaf, 0x8d, 0xf5, 0x80, 0x8e, 0x80, 0xa5, 0x88,
-    0xb5, 0x81, 0x40, 0x89, 0x81, 0xbf, 0x85, 0xd1,
-    0x98, 0x18, 0x28, 0x0a, 0xb1, 0xbe, 0xd8, 0x8b,
-    0xa4, 0x22, 0x82, 0x41, 0xbc, 0x00, 0x82, 0x8a,
-    0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81, 0x4c,
-    0xef, 0x82, 0x41, 0x3c, 0x80, 0x41, 0xf9, 0x85,
-    0xe8, 0x83, 0xde, 0x80, 0x60, 0x75, 0x71, 0x80,
-    0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81, 0x8d,
-    0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40, 0xc9, 0x80,
-    0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80, 0xde, 0x80,
-    0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94, 0x82, 0xc0,
-    0x83, 0xb2, 0x80, 0xe3, 0x84, 0x40, 0x8b, 0x81,
-    0x60, 0x4f, 0x2f, 0x80, 0x43, 0x00, 0x8f, 0x41,
-    0x0d, 0x00, 0x80, 0xae, 0x80, 0xac, 0x81, 0xc2,
-    0x80, 0x42, 0xfb, 0x80, 0x48, 0x03, 0x81, 0x42,
-    0x3a, 0x85, 0x42, 0x1d, 0x8a, 0x41, 0x67, 0x81,
-    0xf7, 0x81, 0xbd, 0x80, 0xcb, 0x80, 0x88, 0x82,
-    0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80, 0x8f,
-    0x80, 0x97, 0x32, 0x84, 0x40, 0xcc, 0x02, 0x80,
-    0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80, 0xf5,
-    0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0xa4,
-    0x80, 0xd2, 0x80, 0x91, 0x80, 0xd0, 0x80, 0x41,
-    0xa4, 0x80, 0x41, 0x01, 0x00, 0x81, 0xd0, 0x80,
-    0x60, 0x4d, 0x57, 0x84, 0xba, 0x86, 0x44, 0x57,
-    0x90, 0x60, 0x61, 0xc6, 0x12, 0x2f, 0x39, 0x86,
+    0x82, 0xbb, 0x80, 0x8f, 0x06, 0x80, 0xf6, 0x80,
+    0xfe, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xec, 0x81,
+    0x8f, 0x80, 0xfb, 0x80, 0xfb, 0x28, 0x80, 0xea,
+    0x80, 0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00,
+    0x03, 0x81, 0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef,
+    0x00, 0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80,
+    0x89, 0x81, 0x42, 0xc0, 0x82, 0x44, 0x68, 0x8a,
+    0x88, 0x80, 0x41, 0x5a, 0x82, 0x41, 0x38, 0x39,
+    0x80, 0xaf, 0x8d, 0xf5, 0x80, 0x8e, 0x80, 0xa5,
+    0x88, 0xb5, 0x81, 0x40, 0x89, 0x81, 0xbf, 0x85,
+    0xd1, 0x98, 0x18, 0x28, 0x0a, 0xb1, 0xbe, 0xd8,
+    0x8b, 0xa4, 0x22, 0x82, 0x41, 0xbc, 0x00, 0x82,
+    0x8a, 0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81,
+    0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80, 0x41, 0xf9,
+    0x85, 0xe8, 0x83, 0xde, 0x80, 0x60, 0x75, 0x71,
+    0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81,
+    0x8d, 0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40, 0xc9,
+    0x80, 0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80, 0xde,
+    0x80, 0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94, 0x82,
+    0xc0, 0x83, 0xb2, 0x80, 0xe3, 0x84, 0x88, 0x82,
+    0xff, 0x81, 0x60, 0x4f, 0x2f, 0x80, 0x43, 0x00,
+    0x8f, 0x41, 0x0d, 0x00, 0x80, 0xae, 0x80, 0xac,
+    0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x48, 0x03,
+    0x81, 0x42, 0x3a, 0x85, 0x42, 0x1d, 0x8a, 0x41,
+    0x67, 0x81, 0xf7, 0x81, 0xbd, 0x80, 0xcb, 0x80,
+    0x88, 0x82, 0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0,
+    0x80, 0x8f, 0x80, 0x97, 0x32, 0x84, 0x40, 0xcc,
+    0x02, 0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd,
+    0x80, 0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81,
+    0x41, 0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2,
+    0x80, 0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80,
+    0x41, 0x01, 0x00, 0x81, 0xd0, 0x80, 0x60, 0x4d,
+    0x57, 0x84, 0xba, 0x86, 0x44, 0x57, 0x90, 0xcf,
+    0x81, 0x60, 0x61, 0x74, 0x12, 0x2f, 0x39, 0x86,
     0x9d, 0x83, 0x4f, 0x81, 0x86, 0x41, 0xb4, 0x83,
     0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
 };
 
-static const uint8_t unicode_prop_Extender_table[86] = {
+static const uint8_t unicode_prop_Extender_table[89] = {
     0x40, 0xb6, 0x80, 0x42, 0x17, 0x81, 0x43, 0x6d,
-    0x80, 0x41, 0xb8, 0x80, 0x46, 0x4a, 0x80, 0xfe,
-    0x80, 0x49, 0x42, 0x80, 0xb7, 0x80, 0x42, 0x62,
-    0x80, 0x41, 0x8d, 0x80, 0xc3, 0x80, 0x53, 0x88,
-    0x80, 0xaa, 0x84, 0xe6, 0x81, 0xdc, 0x82, 0x60,
-    0x6f, 0x15, 0x80, 0x45, 0xf5, 0x80, 0x43, 0xc1,
-    0x80, 0x95, 0x80, 0x40, 0x88, 0x80, 0xeb, 0x80,
-    0x94, 0x81, 0x60, 0x54, 0x7a, 0x80, 0x53, 0xeb,
-    0x80, 0x42, 0x67, 0x82, 0x44, 0xce, 0x80, 0x60,
-    0x50, 0xa8, 0x81, 0x44, 0x9b, 0x08, 0x80, 0x60,
-    0x71, 0x57, 0x81, 0x48, 0x05, 0x82,
+    0x80, 0x41, 0xb8, 0x80, 0x43, 0x59, 0x80, 0x42,
+    0xef, 0x80, 0xfe, 0x80, 0x49, 0x42, 0x80, 0xb7,
+    0x80, 0x42, 0x62, 0x80, 0x41, 0x8d, 0x80, 0xc3,
+    0x80, 0x53, 0x88, 0x80, 0xaa, 0x84, 0xe6, 0x81,
+    0xdc, 0x82, 0x60, 0x6f, 0x15, 0x80, 0x45, 0xf5,
+    0x80, 0x43, 0xc1, 0x80, 0x95, 0x80, 0x40, 0x88,
+    0x80, 0xeb, 0x80, 0x94, 0x81, 0x60, 0x54, 0x7a,
+    0x80, 0x53, 0xeb, 0x80, 0x42, 0x67, 0x82, 0x44,
+    0xce, 0x80, 0x60, 0x50, 0xa8, 0x81, 0x44, 0x9b,
+    0x08, 0x80, 0x60, 0x71, 0x57, 0x81, 0x48, 0x05,
+    0x82,
 };
 
 static const uint8_t unicode_prop_Hex_Digit_table[12] = {
@@ -3787,15 +3836,16 @@ static const uint8_t unicode_prop_IDS_Trinary_Operator_table[4] = {
     0x60, 0x2f, 0xf1, 0x81,
 };
 
-static const uint8_t unicode_prop_Ideographic_table[58] = {
+static const uint8_t unicode_prop_Ideographic_table[66] = {
     0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82,
-    0x43, 0xc4, 0x59, 0xb5, 0xc9, 0x60, 0x51, 0xef,
-    0x60, 0x59, 0x0f, 0x41, 0x6d, 0x81, 0xe9, 0x60,
-    0x75, 0x25, 0x57, 0xf7, 0x87, 0x42, 0xf2, 0x60,
-    0x26, 0x7c, 0x41, 0x8b, 0x60, 0x4d, 0x03, 0x60,
-    0xa6, 0xd6, 0xa8, 0x50, 0x34, 0x8a, 0x40, 0xdd,
-    0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e,
-    0x42, 0x1d,
+    0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xfc,
+    0x60, 0x59, 0x02, 0x41, 0x6d, 0x81, 0xe9, 0x60,
+    0x75, 0x09, 0x80, 0x9a, 0x57, 0xf7, 0x87, 0x44,
+    0xd5, 0xa9, 0x88, 0x60, 0x24, 0x66, 0x41, 0x8b,
+    0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdd, 0xa1, 0x50,
+    0x34, 0x8a, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
+    0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1,
+    0x53, 0x4a,
 };
 
 static const uint8_t unicode_prop_Join_Control_table[4] = {
@@ -3851,7 +3901,7 @@ static const uint8_t unicode_prop_Regional_Indicator_table[4] = {
     0x61, 0xf1, 0xe5, 0x99,
 };
 
-static const uint8_t unicode_prop_Sentence_Terminal_table[184] = {
+static const uint8_t unicode_prop_Sentence_Terminal_table[188] = {
     0xa0, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0x45, 0x48,
     0x80, 0x40, 0x93, 0x81, 0x40, 0xb3, 0x80, 0xaa,
     0x82, 0x40, 0xf5, 0x80, 0xbc, 0x00, 0x02, 0x81,
@@ -3871,10 +3921,11 @@ static const uint8_t unicode_prop_Sentence_Terminal_table[184] = {
     0x82, 0x40, 0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7,
     0x08, 0x81, 0xeb, 0x80, 0x41, 0xa0, 0x81, 0x41,
     0x74, 0x0c, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82,
-    0x43, 0x02, 0x81, 0xd6, 0x81, 0x41, 0xa3, 0x81,
-    0x42, 0xb3, 0x81, 0x60, 0x4b, 0x74, 0x81, 0x40,
-    0x84, 0x80, 0xc0, 0x81, 0x8a, 0x80, 0x43, 0x52,
-    0x80, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe7, 0x80,
+    0x42, 0x04, 0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6,
+    0x81, 0x41, 0xa3, 0x81, 0x42, 0xb3, 0x81, 0x60,
+    0x4b, 0x74, 0x81, 0x40, 0x84, 0x80, 0xc0, 0x81,
+    0x8a, 0x80, 0x43, 0x52, 0x80, 0x60, 0x4e, 0x05,
+    0x80, 0x5d, 0xe7, 0x80,
 };
 
 static const uint8_t unicode_prop_Soft_Dotted_table[71] = {
@@ -3889,7 +3940,7 @@ static const uint8_t unicode_prop_Soft_Dotted_table[71] = {
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81,
 };
 
-static const uint8_t unicode_prop_Terminal_Punctuation_table[237] = {
+static const uint8_t unicode_prop_Terminal_Punctuation_table[241] = {
     0xa0, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
     0x43, 0x3d, 0x07, 0x80, 0x42, 0x00, 0x80, 0xb8,
     0x80, 0xc7, 0x80, 0x8d, 0x01, 0x81, 0x40, 0xb3,
@@ -3913,21 +3964,23 @@ static const uint8_t unicode_prop_Terminal_Punctuation_table[237] = {
     0x85, 0xc3, 0x85, 0xd8, 0x83, 0x43, 0xb7, 0x84,
     0x40, 0xec, 0x86, 0xef, 0x83, 0xfe, 0x82, 0x40,
     0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x84, 0xeb,
-    0x80, 0x41, 0xa0, 0x82, 0x8c, 0x80, 0x41, 0x65,
-    0x1a, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x43,
-    0x02, 0x81, 0xd6, 0x0b, 0x81, 0x41, 0x9d, 0x82,
-    0xac, 0x80, 0x42, 0x84, 0x81, 0x45, 0x76, 0x84,
-    0x60, 0x45, 0xf8, 0x81, 0x40, 0x84, 0x80, 0xc0,
-    0x82, 0x89, 0x80, 0x43, 0x51, 0x81, 0x60, 0x4e,
-    0x05, 0x80, 0x5d, 0xe6, 0x83,
+    0x80, 0x41, 0xa0, 0x82, 0x8b, 0x81, 0x41, 0x65,
+    0x1a, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42,
+    0x04, 0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6, 0x0b,
+    0x81, 0x41, 0x9d, 0x82, 0xac, 0x80, 0x42, 0x84,
+    0x81, 0x45, 0x76, 0x84, 0x60, 0x45, 0xf8, 0x81,
+    0x40, 0x84, 0x80, 0xc0, 0x82, 0x89, 0x80, 0x43,
+    0x51, 0x81, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe6,
+    0x83,
 };
 
-static const uint8_t unicode_prop_Unified_Ideograph_table[38] = {
-    0x60, 0x33, 0xff, 0x59, 0xb5, 0xc9, 0x60, 0x51,
-    0xef, 0x60, 0x5a, 0x1d, 0x08, 0x00, 0x81, 0x89,
+static const uint8_t unicode_prop_Unified_Ideograph_table[42] = {
+    0x60, 0x33, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x51,
+    0xfc, 0x60, 0x5a, 0x10, 0x08, 0x00, 0x81, 0x89,
     0x00, 0x00, 0x09, 0x82, 0x61, 0x05, 0xd5, 0x60,
-    0xa6, 0xd6, 0xa8, 0x50, 0x34, 0x8a, 0x40, 0xdd,
-    0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30,
+    0xa6, 0xdd, 0xa1, 0x50, 0x34, 0x8a, 0x40, 0xdd,
+    0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x54, 0x1e,
+    0x53, 0x4a,
 };
 
 static const uint8_t unicode_prop_Variation_Selector_table[12] = {
@@ -3966,7 +4019,7 @@ static const uint8_t unicode_prop_Bidi_Mirrored_table[171] = {
     0x80, 0xb8, 0x80,
 };
 
-static const uint8_t unicode_prop_Emoji_table[236] = {
+static const uint8_t unicode_prop_Emoji_table[238] = {
     0xa2, 0x05, 0x04, 0x89, 0xee, 0x03, 0x80, 0x5f,
     0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95,
     0x80, 0xd9, 0x85, 0x8e, 0x81, 0x41, 0x6e, 0x81,
@@ -3976,27 +4029,27 @@ static const uint8_t unicode_prop_Emoji_table[236] = {
     0x09, 0x03, 0x01, 0x00, 0x09, 0x02, 0x02, 0x0f,
     0x14, 0x00, 0x04, 0x8b, 0x8a, 0x09, 0x00, 0x08,
     0x80, 0x91, 0x01, 0x81, 0x91, 0x28, 0x00, 0x0a,
-    0x0f, 0x0b, 0x81, 0x8a, 0x0c, 0x09, 0x04, 0x08,
-    0x00, 0x81, 0x93, 0x0c, 0x28, 0x19, 0x03, 0x01,
-    0x01, 0x28, 0x01, 0x00, 0x00, 0x05, 0x02, 0x05,
-    0x80, 0x89, 0x81, 0x8e, 0x01, 0x03, 0x00, 0x03,
-    0x10, 0x80, 0x8a, 0x81, 0xaf, 0x82, 0x88, 0x80,
-    0x8d, 0x80, 0x8d, 0x80, 0x41, 0x73, 0x81, 0x41,
-    0xce, 0x82, 0x92, 0x81, 0xb2, 0x03, 0x80, 0x44,
-    0xd9, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00, 0x80,
-    0x61, 0xbd, 0x69, 0x80, 0x40, 0xc9, 0x80, 0x40,
-    0x9f, 0x81, 0x8b, 0x81, 0x8d, 0x01, 0x89, 0xca,
-    0x99, 0x01, 0x96, 0x80, 0x93, 0x01, 0x88, 0x94,
-    0x81, 0x40, 0xad, 0xa1, 0x81, 0xef, 0x09, 0x02,
-    0x81, 0xd2, 0x0a, 0x80, 0x41, 0x06, 0x80, 0xbe,
-    0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01, 0x19,
-    0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88, 0x04,
-    0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05, 0x02,
-    0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x08, 0x89, 0x2a,
-    0x00, 0x0a, 0x01, 0x87, 0x40, 0xe4, 0x8b, 0x41,
-    0x20, 0xad, 0x80, 0x89, 0x80, 0xaa, 0x03, 0x82,
-    0xa8, 0x0d, 0x82, 0x9c, 0x81, 0xb2, 0xef, 0x1b,
-    0x14, 0x82, 0x8c, 0x85,
+    0x0c, 0x01, 0x0b, 0x81, 0x8a, 0x0c, 0x09, 0x04,
+    0x08, 0x00, 0x81, 0x93, 0x0c, 0x28, 0x19, 0x03,
+    0x01, 0x01, 0x28, 0x01, 0x00, 0x00, 0x05, 0x02,
+    0x05, 0x80, 0x89, 0x81, 0x8e, 0x01, 0x03, 0x00,
+    0x03, 0x10, 0x80, 0x8a, 0x81, 0xaf, 0x82, 0x88,
+    0x80, 0x8d, 0x80, 0x8d, 0x80, 0x41, 0x73, 0x81,
+    0x41, 0xce, 0x82, 0x92, 0x81, 0xb2, 0x03, 0x80,
+    0x44, 0xd9, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
+    0x80, 0x61, 0xbd, 0x69, 0x80, 0x40, 0xc9, 0x80,
+    0x40, 0x9f, 0x81, 0x8b, 0x81, 0x8d, 0x01, 0x89,
+    0xca, 0x99, 0x01, 0x96, 0x80, 0x93, 0x01, 0x88,
+    0x94, 0x81, 0x40, 0xad, 0xa1, 0x81, 0xef, 0x09,
+    0x02, 0x81, 0xd2, 0x0a, 0x80, 0x41, 0x06, 0x80,
+    0xbe, 0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01,
+    0x19, 0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88,
+    0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05,
+    0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x3d,
+    0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2, 0x8b,
+    0x41, 0x1f, 0xae, 0x80, 0x89, 0x80, 0xb1, 0x80,
+    0xd1, 0x80, 0xb2, 0xef, 0x22, 0x14, 0x86, 0x88,
+    0x98, 0x36, 0x88, 0x82, 0x8c, 0x86,
 };
 
 static const uint8_t unicode_prop_Emoji_Component_table[28] = {
@@ -4010,18 +4063,19 @@ static const uint8_t unicode_prop_Emoji_Modifier_table[4] = {
     0x61, 0xf3, 0xfa, 0x84,
 };
 
-static const uint8_t unicode_prop_Emoji_Modifier_Base_table[63] = {
+static const uint8_t unicode_prop_Emoji_Modifier_Base_table[66] = {
     0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
     0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
     0x82, 0xf4, 0x09, 0x8a, 0x94, 0x92, 0x10, 0x1a,
     0x02, 0x30, 0x00, 0x97, 0x80, 0x40, 0xc8, 0x0b,
     0x80, 0x94, 0x03, 0x81, 0x40, 0xad, 0x12, 0x84,
     0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a, 0x80,
-    0x42, 0x41, 0x07, 0x3d, 0x80, 0x88, 0x89, 0x0a,
-    0xf5, 0x08, 0x08, 0x80, 0x90, 0x10, 0x8c,
+    0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88, 0x89,
+    0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80, 0x90,
+    0x10, 0x8c,
 };
 
-static const uint8_t unicode_prop_Emoji_Presentation_table[143] = {
+static const uint8_t unicode_prop_Emoji_Presentation_table[144] = {
     0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
     0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
     0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
@@ -4036,13 +4090,13 @@ static const uint8_t unicode_prop_Emoji_Presentation_table[143] = {
     0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80,
     0x40, 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91,
     0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
-    0xc5, 0x28, 0x12, 0x08, 0x94, 0x0e, 0x86, 0x40,
-    0xe4, 0x8b, 0x41, 0x20, 0xad, 0x80, 0x89, 0x80,
-    0xaa, 0x03, 0x82, 0xa8, 0x0d, 0x82, 0x9c, 0x81,
-    0xb2, 0xef, 0x1b, 0x14, 0x82, 0x8c, 0x85,
+    0xc5, 0x28, 0x12, 0x0a, 0x92, 0x0e, 0x88, 0x40,
+    0xe2, 0x8b, 0x41, 0x1f, 0xae, 0x80, 0x89, 0x80,
+    0xb1, 0x80, 0xd1, 0x80, 0xb2, 0xef, 0x22, 0x14,
+    0x86, 0x88, 0x98, 0x36, 0x88, 0x82, 0x8c, 0x86,
 };
 
-static const uint8_t unicode_prop_Extended_Pictographic_table[152] = {
+static const uint8_t unicode_prop_Extended_Pictographic_table[156] = {
     0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b,
     0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
     0x8e, 0x81, 0x41, 0x6e, 0x81, 0x8b, 0x80, 0xde,
@@ -4061,7 +4115,8 @@ static const uint8_t unicode_prop_Extended_Pictographic_table[152] = {
     0x88, 0x41, 0xb1, 0x84, 0x41, 0x3d, 0x87, 0x41,
     0x09, 0xaf, 0xff, 0xf3, 0x8b, 0xd4, 0xaa, 0x8b,
     0x83, 0xb7, 0x87, 0x89, 0x85, 0xa7, 0x87, 0x9d,
-    0xd1, 0x8b, 0xae, 0x80, 0x89, 0x80, 0x46, 0xb6,
+    0xd1, 0x8b, 0xae, 0x80, 0x89, 0x80, 0x41, 0xb8,
+    0x40, 0xff, 0x43, 0xfd,
 };
 
 static const uint8_t unicode_prop_Default_Ignorable_Code_Point_table[51] = {
@@ -4175,11 +4230,11 @@ static const char unicode_prop_name_table[] =
     "White_Space,space"                  "\0"
     "Bidi_Mirrored,Bidi_M"               "\0"
     "Emoji"                              "\0"
-    "Emoji_Component"                    "\0"
-    "Emoji_Modifier"                     "\0"
-    "Emoji_Modifier_Base"                "\0"
-    "Emoji_Presentation"                 "\0"
-    "Extended_Pictographic"              "\0"
+    "Emoji_Component,EComp"              "\0"
+    "Emoji_Modifier,EMod"                "\0"
+    "Emoji_Modifier_Base,EBase"          "\0"
+    "Emoji_Presentation,EPres"           "\0"
+    "Extended_Pictographic,ExtPict"      "\0"
     "Default_Ignorable_Code_Point,DI"    "\0"
     "ID_Start,IDS"                       "\0"
     "Case_Ignorable,CI"                  "\0"
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index aff1b8911a..3ff5168a79 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -224,17 +224,15 @@ static JSValue js_printf_internal(JSContext *ctx,
                 case 'X':
                     if (i >= argc)
                         goto missing;
+                    if (JS_ToInt64Ext(ctx, &int64_arg, argv[i++]))
+                        goto fail;
                     if (modsize > 0) {
-                        if (JS_ToInt64(ctx, &int64_arg, argv[i++]))
-                            goto fail;
                         q[1] = q[-1];
                         q[-1] = q[0] = 'l';
                         q[2] = '\0';
                         dbuf_printf_fun(&dbuf, fmtbuf, (long long)int64_arg);
                     } else {
-                        if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
-                            goto fail;
-                        dbuf_printf_fun(&dbuf, fmtbuf, int32_arg);
+                        dbuf_printf_fun(&dbuf, fmtbuf, (int)int64_arg);
                     }
                     break;
 
@@ -369,6 +367,27 @@ static JSValue js_loadScript(JSContext *ctx, JSValueConst this_val,
     return ret;
 }
 
+/* load a file as a UTF-8 encoded string */
+static JSValue js_std_loadFile(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
+{
+    uint8_t *buf;
+    const char *filename;
+    JSValue ret;
+    size_t buf_len;
+    
+    filename = JS_ToCString(ctx, argv[0]);
+    if (!filename)
+        return JS_EXCEPTION;
+    buf = js_load_file(ctx, &buf_len, filename);
+    JS_FreeCString(ctx, filename);
+    if (!buf)
+        return JS_NULL;
+    ret = JS_NewStringLen(ctx, (char *)buf, buf_len);
+    js_free(ctx, buf);
+    return ret;
+}
+
 typedef JSModuleDef *(JSInitModuleFunc)(JSContext *ctx,
                                         const char *module_name);
 
@@ -633,30 +652,14 @@ static void js_std_file_finalizer(JSRuntime *rt, JSValue val)
     }
 }
 
-static JSValue js_new_std_error(JSContext *ctx, int err)
+static ssize_t js_get_errno(ssize_t ret)
 {
-    JSValue obj;
-    /* XXX: could add a specific Error prototype */
-    obj = JS_NewError(ctx);
-    JS_DefinePropertyValueStr(ctx, obj, "message",
-                              JS_NewString(ctx, strerror(err)),
-                              JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    JS_DefinePropertyValueStr(ctx, obj, "errno",
-                              JS_NewInt32(ctx, err),
-                              JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    return obj;
-}
-
-static JSValue js_std_error_constructor(JSContext *ctx, JSValueConst new_target,
-                                        int argc, JSValueConst *argv)
-{
-    int err;
-    if (JS_ToInt32(ctx, &err, argv[0]))
-        return JS_EXCEPTION;
-    return js_new_std_error(ctx, err);
+    if (ret == -1)
+        ret = -errno;
+    return ret;
 }
 
-static JSValue js_std_error_strerror(JSContext *ctx, JSValueConst this_val,
+static JSValue js_std_strerror(JSContext *ctx, JSValueConst this_val,
                                      int argc, JSValueConst *argv)
 {
     int err;
@@ -665,15 +668,6 @@ static JSValue js_std_error_strerror(JSContext *ctx, JSValueConst this_val,
     return JS_NewString(ctx, strerror(err));
 }
 
-static JSValue js_std_throw_errno(JSContext *ctx, int err)
-{
-    JSValue obj;
-    obj = js_new_std_error(ctx, err);
-    if (JS_IsException(obj))
-        obj = JS_NULL;
-    return JS_Throw(ctx, obj);
-}
-
 static JSValue js_new_std_file(JSContext *ctx, FILE *f,
                                BOOL close_in_finalizer,
                                BOOL is_popen)
@@ -695,12 +689,20 @@ static JSValue js_new_std_file(JSContext *ctx, FILE *f,
     return obj;
 }
 
+static void js_set_error_object(JSContext *ctx, JSValue obj, int err)
+{
+    if (!JS_IsUndefined(obj)) {
+        JS_SetPropertyStr(ctx, obj, "errno", JS_NewInt32(ctx, err));
+    }
+}
+
 static JSValue js_std_open(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
     const char *filename, *mode = NULL;
     FILE *f;
-
+    int err;
+    
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         goto fail;
@@ -708,15 +710,21 @@ static JSValue js_std_open(JSContext *ctx, JSValueConst this_val,
     if (!mode)
         goto fail;
     if (mode[strspn(mode, "rwa+b")] != '\0') {
-        js_std_throw_errno(ctx, EINVAL);
+        JS_ThrowTypeError(ctx, "invalid file mode");
         goto fail;
     }
 
     f = fopen(filename, mode);
+    if (!f)
+        err = errno;
+    else
+        err = 0;
+    if (argc >= 3)
+        js_set_error_object(ctx, argv[2], err);
     JS_FreeCString(ctx, filename);
     JS_FreeCString(ctx, mode);
     if (!f)
-        return js_std_throw_errno(ctx, errno);
+        return JS_NULL;
     return js_new_std_file(ctx, f, TRUE, FALSE);
  fail:
     JS_FreeCString(ctx, filename);
@@ -729,7 +737,8 @@ static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
 {
     const char *filename, *mode = NULL;
     FILE *f;
-
+    int err;
+    
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         goto fail;
@@ -737,15 +746,21 @@ static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
     if (!mode)
         goto fail;
     if (mode[strspn(mode, "rw")] != '\0') {
-        js_std_throw_errno(ctx, EINVAL);
+        JS_ThrowTypeError(ctx, "invalid file mode");
         goto fail;
     }
 
     f = popen(filename, mode);
+    if (!f)
+        err = errno;
+    else
+        err = 0;
+    if (argc >= 3)
+        js_set_error_object(ctx, argv[2], err);
     JS_FreeCString(ctx, filename);
     JS_FreeCString(ctx, mode);
     if (!f)
-        return js_std_throw_errno(ctx, errno);
+        return JS_NULL;
     return js_new_std_file(ctx, f, TRUE, TRUE);
  fail:
     JS_FreeCString(ctx, filename);
@@ -758,7 +773,7 @@ static JSValue js_std_fdopen(JSContext *ctx, JSValueConst this_val,
 {
     const char *mode;
     FILE *f;
-    int fd;
+    int fd, err;
 
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
@@ -766,14 +781,20 @@ static JSValue js_std_fdopen(JSContext *ctx, JSValueConst this_val,
     if (!mode)
         goto fail;
     if (mode[strspn(mode, "rwa+")] != '\0') {
-        js_std_throw_errno(ctx, EINVAL);
+        JS_ThrowTypeError(ctx, "invalid file mode");
         goto fail;
     }
 
     f = fdopen(fd, mode);
+    if (!f)
+        err = errno;
+    else
+        err = 0;
+    if (argc >= 3)
+        js_set_error_object(ctx, argv[2], err);
     JS_FreeCString(ctx, mode);
     if (!f)
-        return js_std_throw_errno(ctx, errno);
+        return JS_NULL;
     return js_new_std_file(ctx, f, TRUE, FALSE);
  fail:
     JS_FreeCString(ctx, mode);
@@ -785,8 +806,10 @@ static JSValue js_std_tmpfile(JSContext *ctx, JSValueConst this_val,
 {
     FILE *f;
     f = tmpfile();
+    if (argc >= 1)
+        js_set_error_object(ctx, argv[0], f ? 0 : errno);
     if (!f)
-        return js_std_throw_errno(ctx, errno);
+        return JS_NULL;
     return js_new_std_file(ctx, f, TRUE, FALSE);
 }
 
@@ -808,7 +831,7 @@ static FILE *js_std_file_get(JSContext *ctx, JSValueConst obj)
     if (!s)
         return NULL;
     if (!s->f) {
-        js_std_throw_errno(ctx, EBADF);
+        JS_ThrowTypeError(ctx, "invalid file handle");
         return NULL;
     }
     return s->f;
@@ -843,17 +866,17 @@ static JSValue js_std_file_close(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
     JSSTDFile *s = JS_GetOpaque2(ctx, this_val, js_std_file_class_id);
+    int err;
     if (!s)
         return JS_EXCEPTION;
     if (!s->f)
-        return js_std_throw_errno(ctx, EBADF);
-    /* XXX: could return exit code */
+        return JS_ThrowTypeError(ctx, "invalid file handle");
     if (s->is_popen)
-        pclose(s->f);
+        err = js_get_errno(pclose(s->f));
     else
-        fclose(s->f);
+        err = js_get_errno(fclose(s->f));
     s->f = NULL;
-    return JS_UNDEFINED;
+    return JS_NewInt32(ctx, err);
 }
 
 static JSValue js_std_file_printf(JSContext *ctx, JSValueConst this_val,
@@ -876,7 +899,7 @@ static JSValue js_std_file_flush(JSContext *ctx, JSValueConst this_val,
 }
 
 static JSValue js_std_file_tell(JSContext *ctx, JSValueConst this_val,
-                                int argc, JSValueConst *argv)
+                                int argc, JSValueConst *argv, int is_bigint)
 {
     FILE *f = js_std_file_get(ctx, this_val);
     int64_t pos;
@@ -887,7 +910,10 @@ static JSValue js_std_file_tell(JSContext *ctx, JSValueConst this_val,
 #else
     pos = ftell(f);
 #endif
-    return JS_NewInt64(ctx, pos);
+    if (is_bigint)
+        return JS_NewBigInt64(ctx, pos);
+    else
+        return JS_NewInt64(ctx, pos);
 }
 
 static JSValue js_std_file_seek(JSContext *ctx, JSValueConst this_val,
@@ -898,7 +924,7 @@ static JSValue js_std_file_seek(JSContext *ctx, JSValueConst this_val,
     int whence, ret;
     if (!f)
         return JS_EXCEPTION;
-    if (JS_ToInt64(ctx, &pos, argv[0]))
+    if (JS_ToInt64Ext(ctx, &pos, argv[0]))
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &whence, argv[1]))
         return JS_EXCEPTION;
@@ -908,8 +934,8 @@ static JSValue js_std_file_seek(JSContext *ctx, JSValueConst this_val,
     ret = fseek(f, pos, whence);
 #endif
     if (ret < 0)
-        return js_std_throw_errno(ctx, EBADF);
-    return JS_UNDEFINED;
+        ret = -errno;
+    return JS_NewInt32(ctx, ret);
 }
 
 static JSValue js_std_file_eof(JSContext *ctx, JSValueConst this_val,
@@ -921,6 +947,25 @@ static JSValue js_std_file_eof(JSContext *ctx, JSValueConst this_val,
     return JS_NewBool(ctx, feof(f));
 }
 
+static JSValue js_std_file_error(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
+{
+    FILE *f = js_std_file_get(ctx, this_val);
+    if (!f)
+        return JS_EXCEPTION;
+    return JS_NewBool(ctx, ferror(f));
+}
+
+static JSValue js_std_file_clearerr(JSContext *ctx, JSValueConst this_val,
+                                    int argc, JSValueConst *argv)
+{
+    FILE *f = js_std_file_get(ctx, this_val);
+    if (!f)
+        return JS_EXCEPTION;
+    clearerr(f);
+    return JS_UNDEFINED;
+}
+
 static JSValue js_std_file_fileno(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv)
 {
@@ -1151,7 +1196,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     f = popen((char *)cmd_buf.buf, "r");
     dbuf_free(&cmd_buf);
     if (!f) {
-        return js_std_throw_errno(ctx, errno);
+        return JS_ThrowTypeError(ctx, "could not start curl");
     }
 
     js_std_dbuf_init(ctx, data_buf);
@@ -1162,20 +1207,21 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
         goto fail;
 
     /* get the HTTP status */
-    if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, NULL) < 0)
+    if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, NULL) < 0) {
+        status = 0;
         goto bad_header;
+    }
     status = http_get_status(buf);
     if (!full_flag && !(status >= 200 && status <= 299)) {
-        js_std_throw_errno(ctx, ENOENT);
-        goto fail;
+        goto bad_header;
     }
     
     /* wait until there is an empty line */
     for(;;) {
         if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, header_buf) < 0) {
         bad_header:
-            js_std_throw_errno(ctx, EINVAL);
-            goto fail;
+            response = JS_NULL;
+            goto done;
         }
         if (!strcmp(buf, "\r\n"))
             break;
@@ -1191,11 +1237,6 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
             break;
         dbuf_put(data_buf, (uint8_t *)buf, len);
     }
-    js_free(ctx, buf);
-    buf = NULL;
-    pclose(f);
-    f = NULL;
-
     if (dbuf_error(data_buf))
         goto fail;
     if (binary_flag) {
@@ -1204,10 +1245,15 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     } else {
         response = JS_NewStringLen(ctx, (char *)data_buf->buf, data_buf->size);
     }
-    dbuf_free(data_buf);
-    data_buf = NULL;
     if (JS_IsException(response))
         goto fail;
+ done:
+    js_free(ctx, buf);
+    buf = NULL;
+    pclose(f);
+    f = NULL;
+    dbuf_free(data_buf);
+    data_buf = NULL;
 
     if (full_flag) {
         ret_obj = JS_NewObject(ctx);
@@ -1216,13 +1262,15 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
         JS_DefinePropertyValueStr(ctx, ret_obj, "response",
                                   response,
                                   JS_PROP_C_W_E);
-        JS_DefinePropertyValueStr(ctx, ret_obj, "responseHeaders",
-                                  JS_NewStringLen(ctx, (char *)header_buf->buf,
-                                                  header_buf->size),
-                                  JS_PROP_C_W_E);
-        JS_DefinePropertyValueStr(ctx, ret_obj, "status",
-                                  JS_NewInt32(ctx, status),
-                                  JS_PROP_C_W_E);
+        if (!JS_IsNull(response)) {
+            JS_DefinePropertyValueStr(ctx, ret_obj, "responseHeaders",
+                                      JS_NewStringLen(ctx, (char *)header_buf->buf,
+                                                      header_buf->size),
+                                      JS_PROP_C_W_E);
+            JS_DefinePropertyValueStr(ctx, ret_obj, "status",
+                                      JS_NewInt32(ctx, status),
+                                      JS_PROP_C_W_E);
+        }
     } else {
         ret_obj = response;
     }
@@ -1245,6 +1293,23 @@ static JSClassDef js_std_file_class = {
     .finalizer = js_std_file_finalizer,
 }; 
 
+static const JSCFunctionListEntry js_std_error_props[] = {
+    /* various errno values */
+#define DEF(x) JS_PROP_INT32_DEF(#x, x, JS_PROP_CONFIGURABLE )
+    DEF(EINVAL),
+    DEF(EIO),
+    DEF(EACCES),
+    DEF(EEXIST),
+    DEF(ENOSPC),
+    DEF(ENOSYS),
+    DEF(EBUSY),
+    DEF(ENOENT),
+    DEF(EPERM),
+    DEF(EPIPE),
+    DEF(EBADF),
+#undef DEF
+};
+
 static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("exit", 1, js_std_exit ),
     JS_CFUNC_DEF("gc", 0, js_std_gc ),
@@ -1252,7 +1317,9 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("loadScript", 1, js_loadScript ),
     JS_CFUNC_DEF("getenv", 1, js_std_getenv ),
     JS_CFUNC_DEF("urlGet", 1, js_std_urlGet ),
-
+    JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
+    JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
+    
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
     JS_CFUNC_DEF("popen", 2, js_std_popen ),
@@ -1264,49 +1331,34 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_PROP_INT32_DEF("SEEK_SET", SEEK_SET, JS_PROP_CONFIGURABLE ),
     JS_PROP_INT32_DEF("SEEK_CUR", SEEK_CUR, JS_PROP_CONFIGURABLE ),
     JS_PROP_INT32_DEF("SEEK_END", SEEK_END, JS_PROP_CONFIGURABLE ),
-
+    JS_OBJECT_DEF("Error", js_std_error_props, countof(js_std_error_props), JS_PROP_CONFIGURABLE),
     /* setenv, ... */
 };
-
-static const JSCFunctionListEntry js_std_error_funcs[] = {
-    JS_CFUNC_DEF("strerror", 1, js_std_error_strerror ),
-    /* various errno values */
-#define DEF(x) JS_PROP_INT32_DEF(#x, x, JS_PROP_CONFIGURABLE )
-    DEF(EINVAL),
-    DEF(EIO),
-    DEF(EACCES),
-    DEF(EEXIST),
-    DEF(ENOSPC),
-    DEF(ENOSYS),
-    DEF(EBUSY),
-    DEF(ENOENT),
-    DEF(EPERM),
-    DEF(EPIPE),
-    DEF(EBADF),
-#undef DEF
-};
-
+    
 static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
     JS_CFUNC_DEF("close", 0, js_std_file_close ),
     JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 1 ),
     JS_CFUNC_DEF("printf", 1, js_std_file_printf ),
     JS_CFUNC_DEF("flush", 0, js_std_file_flush ),
-    JS_CFUNC_DEF("tell", 0, js_std_file_tell ),
+    JS_CFUNC_MAGIC_DEF("tell", 0, js_std_file_tell, 0 ),
+    JS_CFUNC_MAGIC_DEF("tello", 0, js_std_file_tell, 1 ),
     JS_CFUNC_DEF("seek", 2, js_std_file_seek ),
     JS_CFUNC_DEF("eof", 0, js_std_file_eof ),
     JS_CFUNC_DEF("fileno", 0, js_std_file_fileno ),
+    JS_CFUNC_DEF("error", 0, js_std_file_error ),
+    JS_CFUNC_DEF("clearerr", 0, js_std_file_clearerr ),
     JS_CFUNC_MAGIC_DEF("read", 3, js_std_file_read_write, 0 ),
     JS_CFUNC_MAGIC_DEF("write", 3, js_std_file_read_write, 1 ),
     JS_CFUNC_DEF("getline", 0, js_std_file_getline ),
     JS_CFUNC_DEF("readAsString", 0, js_std_file_readAsString ),
     JS_CFUNC_DEF("getByte", 0, js_std_file_getByte ),
     JS_CFUNC_DEF("putByte", 1, js_std_file_putByte ),
-    /* setvbuf, ferror, clearerr, ...  */
+    /* setvbuf, ...  */
 };
 
 static int js_std_init(JSContext *ctx, JSModuleDef *m)
 {
-    JSValue proto, obj;
+    JSValue proto;
     
     /* FILE class */
     /* the class ID is created once */
@@ -1323,13 +1375,6 @@ static int js_std_init(JSContext *ctx, JSModuleDef *m)
     JS_SetModuleExport(ctx, m, "in", js_new_std_file(ctx, stdin, FALSE, FALSE));
     JS_SetModuleExport(ctx, m, "out", js_new_std_file(ctx, stdout, FALSE, FALSE));
     JS_SetModuleExport(ctx, m, "err", js_new_std_file(ctx, stderr, FALSE, FALSE));
-    
-    obj = JS_NewCFunction2(ctx, js_std_error_constructor,
-                           "Error", 1, JS_CFUNC_constructor, 0);
-    JS_SetPropertyFunctionList(ctx, obj, js_std_error_funcs,
-                               countof(js_std_error_funcs));
-    JS_SetModuleExport(ctx, m, "Error", obj);
-
     return 0;
 }
 
@@ -1343,20 +1388,12 @@ JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name)
     JS_AddModuleExport(ctx, m, "in");
     JS_AddModuleExport(ctx, m, "out");
     JS_AddModuleExport(ctx, m, "err");
-    JS_AddModuleExport(ctx, m, "Error");
     return m;
 }
 
 /**********************************************************/
 /* 'os' object */
 
-static JSValue js_os_return(JSContext *ctx, ssize_t ret)
-{
-    if (ret < 0)
-        ret = -errno;
-    return JS_NewInt64(ctx, ret);
-}
-
 static JSValue js_os_open(JSContext *ctx, JSValueConst this_val,
                           int argc, JSValueConst *argv)
 {
@@ -1382,9 +1419,9 @@ static JSValue js_os_open(JSContext *ctx, JSValueConst this_val,
     if (!(flags & O_TEXT))
         flags |= O_BINARY;
 #endif
-    ret = open(filename, flags, mode);
+    ret = js_get_errno(open(filename, flags, mode));
     JS_FreeCString(ctx, filename);
-    return js_os_return(ctx, ret);
+    return JS_NewInt32(ctx, ret);
 }
 
 static JSValue js_os_close(JSContext *ctx, JSValueConst this_val,
@@ -1393,24 +1430,31 @@ static JSValue js_os_close(JSContext *ctx, JSValueConst this_val,
     int fd, ret;
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    ret = close(fd);
-    return js_os_return(ctx, ret);
+    ret = js_get_errno(close(fd));
+    return JS_NewInt32(ctx, ret);
 }
 
 static JSValue js_os_seek(JSContext *ctx, JSValueConst this_val,
                           int argc, JSValueConst *argv)
 {
-    int fd, whence, ret;
-    int64_t pos;
+    int fd, whence;
+    int64_t pos, ret;
+    BOOL is_bigint;
     
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    if (JS_ToInt64(ctx, &pos, argv[1]))
+    is_bigint = JS_IsBigInt(ctx, argv[1]);
+    if (JS_ToInt64Ext(ctx, &pos, argv[1]))
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &whence, argv[2]))
         return JS_EXCEPTION;
     ret = lseek(fd, pos, whence);
-    return js_os_return(ctx, ret);
+    if (ret == -1)
+        ret = -errno;
+    if (is_bigint)
+        return JS_NewBigInt64(ctx, ret);
+    else
+        return JS_NewInt64(ctx, ret);
 }
 
 static JSValue js_os_read_write(JSContext *ctx, JSValueConst this_val,
@@ -1434,10 +1478,10 @@ static JSValue js_os_read_write(JSContext *ctx, JSValueConst this_val,
     if (pos + len > size)
         return JS_ThrowRangeError(ctx, "read/write array buffer overflow");
     if (magic)
-        ret = write(fd, buf + pos, len);
+        ret = js_get_errno(write(fd, buf + pos, len));
     else
-        ret = read(fd, buf + pos, len);
-    return js_os_return(ctx, ret);
+        ret = js_get_errno(read(fd, buf + pos, len));
+    return JS_NewInt64(ctx, ret);
 }
 
 static JSValue js_os_isatty(JSContext *ctx, JSValueConst this_val,
@@ -1555,9 +1599,9 @@ static JSValue js_os_remove(JSContext *ctx, JSValueConst this_val,
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         return JS_EXCEPTION;
-    ret = remove(filename);
+    ret = js_get_errno(remove(filename));
     JS_FreeCString(ctx, filename);
-    return js_os_return(ctx, ret);
+    return JS_NewInt32(ctx, ret);
 }
 
 static JSValue js_os_rename(JSContext *ctx, JSValueConst this_val,
@@ -1574,10 +1618,10 @@ static JSValue js_os_rename(JSContext *ctx, JSValueConst this_val,
         JS_FreeCString(ctx, oldpath);
         return JS_EXCEPTION;
     }
-    ret = rename(oldpath, newpath);
+    ret = js_get_errno(rename(oldpath, newpath));
     JS_FreeCString(ctx, oldpath);
     JS_FreeCString(ctx, newpath);
-    return js_os_return(ctx, ret);
+    return JS_NewInt32(ctx, ret);
 }
 
 static JSOSRWHandler *find_rh(int fd)
@@ -2018,7 +2062,7 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
     
     if (!getcwd(buf, sizeof(buf))) {
         buf[0] = '\0';
-        err = -errno;
+        err = errno;
     } else {
         err = 0;
     }
@@ -2036,9 +2080,9 @@ static JSValue js_os_chdir(JSContext *ctx, JSValueConst this_val,
     target = JS_ToCString(ctx, argv[0]);
     if (!target)
         return JS_EXCEPTION;
-    err = chdir(target);
+    err = js_get_errno(chdir(target));
     JS_FreeCString(ctx, target);
-    return js_os_return(ctx, err);
+    return JS_NewInt32(ctx, err);
 }
 
 /* return [path, errorcode] */
@@ -2056,7 +2100,7 @@ static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
     JS_FreeCString(ctx, path);
     if (!res) {
         buf[0] = '\0';
-        err = -errno;
+        err = errno;
     } else {
         err = 0;
     }
@@ -2078,9 +2122,9 @@ static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
-    ret = mkdir(path, mode);
+    ret = js_get_errno(mkdir(path, mode));
     JS_FreeCString(ctx, path);
-    return js_os_return(ctx, ret);
+    return JS_NewInt32(ctx, ret);
 }
 
 static int64_t timespec_to_ms(const struct timespec *tv)
@@ -2106,7 +2150,7 @@ static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
         res = stat(path, &st);
     JS_FreeCString(ctx, path);
     if (res < 0) {
-        err = -errno;
+        err = errno;
         obj = JS_NULL;
     } else {
         err = 0;
@@ -2179,10 +2223,10 @@ static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
         JS_FreeCString(ctx, target);
         return JS_EXCEPTION;
     }
-    err = symlink(target, linkpath);
+    err = js_get_errno(symlink(target, linkpath));
     JS_FreeCString(ctx, target);
     JS_FreeCString(ctx, linkpath);
-    return js_os_return(ctx, err);
+    return JS_NewInt32(ctx, err);
 }
 
 /* return [path, errorcode] */
@@ -2198,14 +2242,14 @@ static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
     if (!path)
         return JS_EXCEPTION;
     res = readlink(path, buf, sizeof(buf) - 1);
-    JS_FreeCString(ctx, path);
     if (res < 0) {
         buf[0] = '\0';
-        err = -errno;
+        err = errno;
     } else {
         buf[res] = '\0';
         err = 0;
     }
+    JS_FreeCString(ctx, path);
     return make_string_error(ctx, buf, err);
 }
 
@@ -2229,18 +2273,19 @@ static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     }
     f = opendir(path);
+    if (!f)
+        err = errno;
+    else
+        err = 0;
     JS_FreeCString(ctx, path);
-    err = 0;
-    if (!f) {
-        err = -errno;
+    if (!f)
         goto done;
-    }
     len = 0;
     for(;;) {
         errno = 0;
         d = readdir(f);
         if (!d) {
-            err = -errno;
+            err = errno;
             break;
         }
         JS_DefinePropertyValueUint32(ctx, obj, len++,
@@ -2275,9 +2320,9 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     ms_to_timeval(&times[0], atime);
     ms_to_timeval(&times[1], mtime);
-    ret = utimes(path, times);
+    ret = js_get_errno(utimes(path, times));
     JS_FreeCString(ctx, path);
-    return js_os_return(ctx, ret);
+    return JS_NewInt32(ctx, ret);
 }
 
 /* exec(args[, options]) -> exitcode */
@@ -2486,8 +2531,8 @@ static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &sig, argv[1]))
         return JS_EXCEPTION;
-    ret = kill(pid, sig);
-    return js_os_return(ctx, ret);
+    ret = js_get_errno(kill(pid, sig));
+    return JS_NewInt32(ctx, ret);
 }
 
 /* sleep(delay_ms) */
@@ -2502,8 +2547,8 @@ static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     ts.tv_sec = delay / 1000;
     ts.tv_nsec = (delay % 1000) * 1000000;
-    ret = nanosleep(&ts, NULL);
-    return js_os_return(ctx, ret);
+    ret = js_get_errno(nanosleep(&ts, NULL));
+    return JS_NewInt32(ctx, ret);
 }
 
 /* dup(fd) */
@@ -2514,8 +2559,8 @@ static JSValue js_os_dup(JSContext *ctx, JSValueConst this_val,
     
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    ret = dup(fd);
-    return js_os_return(ctx, ret);
+    ret = js_get_errno(dup(fd));
+    return JS_NewInt32(ctx, ret);
 }
 
 /* dup2(fd) */
@@ -2528,8 +2573,8 @@ static JSValue js_os_dup2(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &fd2, argv[1]))
         return JS_EXCEPTION;
-    ret = dup2(fd, fd2);
-    return js_os_return(ctx, ret);
+    ret = js_get_errno(dup2(fd, fd2));
+    return JS_NewInt32(ctx, ret);
 }
 
 #endif /* !_WIN32 */
@@ -2725,23 +2770,30 @@ void js_std_free_handlers(JSRuntime *rt)
     }
 }
 
-static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val,
-                               BOOL is_throw)
+static void js_dump_obj(JSContext *ctx, FILE *f, JSValueConst val)
+{
+    const char *str;
+    
+    str = JS_ToCString(ctx, val);
+    if (str) {
+        fprintf(f, "%s\n", str);
+        JS_FreeCString(ctx, str);
+    } else {
+        fprintf(f, "[exception]\n");
+    }
+}
+
+static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val)
 {
     JSValue val;
-    const char *stack;
     BOOL is_error;
     
     is_error = JS_IsError(ctx, exception_val);
-    if (is_throw && !is_error)
-        printf("Throw: ");
-    js_print(ctx, JS_NULL, 1, (JSValueConst *)&exception_val);
+    js_dump_obj(ctx, stderr, exception_val);
     if (is_error) {
         val = JS_GetPropertyStr(ctx, exception_val, "stack");
         if (!JS_IsUndefined(val)) {
-            stack = JS_ToCString(ctx, val);
-            printf("%s\n", stack);
-            JS_FreeCString(ctx, stack);
+            js_dump_obj(ctx, stderr, val);
         }
         JS_FreeValue(ctx, val);
     }
@@ -2752,7 +2804,7 @@ void js_std_dump_error(JSContext *ctx)
     JSValue exception_val;
     
     exception_val = JS_GetException(ctx);
-    js_std_dump_error1(ctx, exception_val, TRUE);
+    js_std_dump_error1(ctx, exception_val);
     JS_FreeValue(ctx, exception_val);
 }
 
@@ -2761,8 +2813,8 @@ void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                       BOOL is_handled, void *opaque)
 {
     if (!is_handled) {
-        printf("Possibly unhandled promise rejection: ");
-        js_std_dump_error1(ctx, reason, FALSE);
+        fprintf(stderr, "Possibly unhandled promise rejection: ");
+        js_std_dump_error1(ctx, reason);
     }
 }
 
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 57f6969b1e..230f6e4771 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -119,7 +119,6 @@ DEF(           eval, 5, 1, 1, npop_u16) /* func args... -> ret_val */
 DEF(     apply_eval, 3, 2, 1, u16) /* func array -> ret_eval */
 DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern and a
                                        bytecode string */
-DEF( get_super_ctor, 1, 1, 1, none)
 DEF(      get_super, 1, 1, 1, none)
 DEF(         import, 1, 1, 1, none) /* dynamic module import */
 
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index b19a4d9fdb..cabb82b084 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -284,6 +284,7 @@ struct JSRuntime {
     JSNumericOperations bigdecimal_ops;
     uint32_t operator_count;
 #endif
+    void *user_opaque;
 };
 
 struct JSClass {
@@ -1537,6 +1538,16 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     return NULL;
 }
 
+void *JS_GetRuntimeOpaque(JSRuntime *rt)
+{
+    return rt->user_opaque;
+}
+
+void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque)
+{
+    rt->user_opaque = opaque;
+}
+
 /* default memory allocation functions with memory limitation */
 static inline size_t js_def_malloc_usable_size(void *ptr)
 {
@@ -2198,26 +2209,6 @@ static inline BOOL is_math_mode(JSContext *ctx)
 }
 #endif
 
-JSValue JS_NewInt64(JSContext *ctx, int64_t v)
-{
-    if (v == (int32_t)v) {
-        return JS_NewInt32(ctx, v);
-    } else {
-        return __JS_NewFloat64(ctx, (double)v);
-    }
-}
-
-static force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
-{
-    JSValue v;
-    if (val <= 0x7fffffff) {
-        v = JS_MKVAL(JS_TAG_INT, val);
-    } else {
-        v = __JS_NewFloat64(ctx, val);
-    }
-    return v;
-}
-
 /* JSAtom support */
 
 #define JS_ATOM_TAG_INT (1U << 31)
@@ -9794,6 +9785,8 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
         if (*p == '.' && (p > p_start || to_digit((uint8_t)p[1]) < radix)) {
             is_float = TRUE;
             p++;
+            if (*p == sep)
+                goto fail;
             while (to_digit((uint8_t)*p) < radix ||
                    (*p == sep && to_digit((uint8_t)p[1]) < radix))
                 p++;
@@ -10129,7 +10122,6 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
                 ret = JS_NewInt32(ctx, 0);
             } else {
                 /* convert -0 to +0 */
-                /* XXX: should not be done here ? */
                 d = trunc(d) + 0.0;
                 ret = JS_NewFloat64(ctx, d);
             }
@@ -10385,6 +10377,14 @@ int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
     return JS_ToInt64Free(ctx, pres, JS_DupValue(ctx, val));
 }
 
+int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val)
+{
+    if (JS_IsBigInt(ctx, val))
+        return JS_ToBigInt64(ctx, pres, val);
+    else
+        return JS_ToInt64(ctx, pres, val);
+}
+
 /* return (<0, 0) in case of exception */
 static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
 {
@@ -11840,7 +11840,8 @@ static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
 }
 
 /* must be kept in sync with JSOverloadableOperatorEnum */
-static const char *js_overloadable_operator_names[JS_OVOP_COUNT] = {
+/* XXX: use atoms ? */
+static const char js_overloadable_operator_names[JS_OVOP_COUNT][4] = {
     "+",
     "-",
     "*",
@@ -12894,7 +12895,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     handle_bigint:
         if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
-    } else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
+    } else {
         double dr;
         /* float64 result */
         if (JS_ToFloat64Free(ctx, &d1, op1)) {
@@ -13031,7 +13032,11 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
     } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
         if (ctx->rt->bigfloat_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
             goto exception;
-    } else if (tag1 == JS_TAG_FLOAT64 || tag2 == JS_TAG_FLOAT64) {
+    } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+    handle_bigint:
+        if (ctx->rt->bigint_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
+            goto exception;
+    } else {
         double d1, d2;
         /* float64 result */
         if (JS_ToFloat64Free(ctx, &d1, op1)) {
@@ -13040,10 +13045,9 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         }
         if (JS_ToFloat64Free(ctx, &d2, op2))
             goto exception;
+        if (is_math_mode(ctx) && is_safe_integer(d1) && is_safe_integer(d2))
+            goto handle_bigint;
         sp[-2] = __JS_NewFloat64(ctx, d1 + d2);
-    } else {
-        if (ctx->rt->bigint_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
-            goto exception;
     }
     return 0;
  exception:
@@ -13642,6 +13646,28 @@ static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
 
 #else /* !CONFIG_BIGNUM */
 
+static JSValue JS_ThrowUnsupportedBigint(JSContext *ctx)
+{
+    return JS_ThrowTypeError(ctx, "bigint is not supported");
+}
+
+JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
+{
+    return JS_ThrowUnsupportedBigint(ctx);
+}
+
+JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
+{
+    return JS_ThrowUnsupportedBigint(ctx);
+}
+
+int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
+{
+    JS_ThrowUnsupportedBigint(ctx);
+    *pres = 0;
+    return -1;
+}
+
 static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
                                                      JSValue *sp,
                                                      OPCodeEnum op)
@@ -16280,22 +16306,6 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             }
             BREAK;
 
-        CASE(OP_get_super_ctor):
-            {
-                JSValue proto;
-                proto = JS_DupValue(ctx, JS_GetPrototype(ctx, sp[-1]));
-                if (JS_IsException(proto))
-                    goto exception;
-                if (!JS_IsConstructor(ctx, proto)) {
-                    JS_FreeValue(ctx, proto);
-                    JS_ThrowTypeError(ctx, "not a constructor");
-                    goto exception;
-                }
-                JS_FreeValue(ctx, sp[-1]);
-                sp[-1] = proto;
-            }
-            BREAK;
-
         CASE(OP_get_super):
             {
                 JSValue proto;
@@ -23821,7 +23831,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 emit_atom(s, JS_ATOM_this_active_func);
                 emit_u16(s, 0);
 
-                emit_op(s, OP_get_super_ctor);
+                emit_op(s, OP_get_super);
 
                 emit_op(s, OP_scope_get_var);
                 emit_atom(s, JS_ATOM_new_target);
@@ -31993,10 +32003,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                 js_parse_expect(s, ')');
                 goto fail;
             }
-            if (s->token.val == ',') {
-                if (next_token(s))
-                    goto fail;
-            }
+            if (s->token.val == ')')
+                break;
+            if (js_parse_expect(s, ','))
+                goto fail;
         }
         if ((func_type == JS_PARSE_FUNC_GETTER && fd->arg_count != 0) ||
             (func_type == JS_PARSE_FUNC_SETTER && fd->arg_count != 1)) {
@@ -34381,6 +34391,10 @@ int JS_SetModuleExportList(JSContext *ctx, JSModuleDef *m,
         case JS_DEF_PROP_DOUBLE:
             val = __JS_NewFloat64(ctx, e->u.f64);
             break;
+        case JS_DEF_OBJECT:
+            val = JS_NewObject(ctx);
+            JS_SetPropertyFunctionList(ctx, val, e->u.prop_list.tab, e->u.prop_list.len);
+            break;
         default:
             abort();
         }
@@ -37357,7 +37371,8 @@ static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValueConst target,
             JS_ThrowTypeError(ctx, "Array too long");
             goto fail;
         }
-        if (JS_SetPropertyInt64(ctx, target, targetIndex, element) < 0)
+        if (JS_DefinePropertyValueInt64(ctx, target, targetIndex, element,
+                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0)
             return -1;
         targetIndex++;
     }
@@ -37754,7 +37769,6 @@ static const JSCFunctionListEntry js_array_proto_funcs[] = {
     JS_CFUNC_DEF("copyWithin", 2, js_array_copyWithin ),
     JS_CFUNC_MAGIC_DEF("flatMap", 1, js_array_flatten, 1 ),
     JS_CFUNC_MAGIC_DEF("flat", 0, js_array_flatten, 0 ),
-    JS_CFUNC_MAGIC_DEF("flatten", 0, js_array_flatten, 0 ),
     JS_CFUNC_MAGIC_DEF("values", 0, js_create_array_iterator, JS_ITERATOR_KIND_VALUE ),
     JS_ALIAS_DEF("[Symbol.iterator]", "values" ),
     JS_CFUNC_MAGIC_DEF("keys", 0, js_create_array_iterator, JS_ITERATOR_KIND_KEY ),
@@ -39918,14 +39932,36 @@ static JSValue js_math_hypot(JSContext *ctx, JSValueConst this_val,
         if (JS_ToFloat64(ctx, &b, argv[1]))
             return JS_EXCEPTION;
         r = hypot(a, b);
-    } else {
+    } else if (argc == 0) {
         r = 0;
+    } else {
+        double *tab, a_max;
+        tab = js_malloc(ctx, sizeof(tab[0]) * argc);
+        if (!tab)
+            return JS_EXCEPTION;
+        /* avoid overflow by taking the maximum */
+        a_max = 0;
         for(i = 0; i < argc; i++) {
-            if (JS_ToFloat64(ctx, &a, argv[i]))
+            if (JS_ToFloat64(ctx, &a, argv[i])) {
+                js_free(ctx, tab);
                 return JS_EXCEPTION;
-            r += a;
+            }
+            a = fabs(a);
+            tab[i] = a;
+            if (a > a_max)
+                a_max = a;
+        }
+        if (a_max == 0 || !isfinite(a_max)) {
+            r = a_max;
+        } else {
+            r = 0;
+            for(i = 0; i < argc; i++) {
+                a = tab[i] / a_max;
+                r += a * a;
+            }
+            r = a_max * sqrt(r);
         }
-        r = sqrt(r);
+        js_free(ctx, tab);
     }
     return JS_NewFloat64(ctx, r);
 }
@@ -45234,10 +45270,10 @@ static JSValue js_promise_then_finally_func(JSContext *ctx, JSValueConst this_va
     }
     JS_FreeValue(ctx, ret);
     if (magic == 0) {
-        then_func = JS_NewCFunctionData(ctx, js_promise_finally_value_thunk, 1,
+        then_func = JS_NewCFunctionData(ctx, js_promise_finally_value_thunk, 0,
                                         0, 1, argv);
     } else {
-        then_func = JS_NewCFunctionData(ctx, js_promise_finally_thrower, 1,
+        then_func = JS_NewCFunctionData(ctx, js_promise_finally_thrower, 0,
                                         0, 1, argv);
     }
     if (JS_IsException(then_func)) {
@@ -50037,7 +50073,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
                                       int argc, JSValueConst *argv, int special)
 {
     JSObject *p;
-    int len, tag, is_int, is_big, k, stop, inc, res = -1;
+    int len, tag, is_int, is_bigint, k, stop, inc, res = -1;
     int64_t v64;
     double d;
     float f;
@@ -50080,7 +50116,11 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         inc = 1;
     }
 
-    is_big = 0;
+    if (validate_typed_array(ctx, this_val))
+        goto exception;
+    p = JS_VALUE_GET_OBJ(this_val);
+
+    is_bigint = 0;
     is_int = 0; /* avoid warning */
     v64 = 0; /* avoid warning */
     tag = JS_VALUE_GET_NORM_TAG(argv[0]);
@@ -50095,10 +50135,20 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         is_int = (v64 == d);
     } else
 #ifdef CONFIG_BIGNUM
-    if (tag == JS_TAG_BIG_INT || tag == JS_TAG_BIG_FLOAT) {
-        /* will a generic loop for bigint and bigfloat */
-        /* XXX: should use the generic loop in math_mode? */
-        is_big = 1;
+    if (tag == JS_TAG_BIG_INT) {
+        JSBigFloat *p1 = JS_VALUE_GET_PTR(argv[0]);
+        
+        if (p->class_id == JS_CLASS_BIG_INT64_ARRAY) {
+            if (bf_get_int64(&v64, &p1->num, 0) != 0)
+                goto done;
+        } else if (p->class_id == JS_CLASS_BIG_UINT64_ARRAY) {
+            if (bf_get_uint64((uint64_t *)&v64, &p1->num) != 0)
+                goto done;
+        } else {
+            goto done;
+        }
+        d = 0;
+        is_bigint = 1;
     } else
 #endif
     {
@@ -50172,7 +50222,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         }
         break;
     case JS_CLASS_FLOAT32_ARRAY:
-        if (is_big)
+        if (is_bigint)
             break;
         if (isnan(d)) {
             const float *pv = p->u.array.u.float_ptr;
@@ -50196,7 +50246,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         }
         break;
     case JS_CLASS_FLOAT64_ARRAY:
-        if (is_big)
+        if (is_bigint)
             break;
         if (isnan(d)) {
             const double *pv = p->u.array.u.double_ptr;
@@ -50221,20 +50271,22 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         break;
 #ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
+        if (is_bigint || (is_math_mode(ctx) && is_int &&
+                          v64 >= -MAX_SAFE_INTEGER &&
+                          v64 <= MAX_SAFE_INTEGER)) {
+            goto scan64;
+        }
+        break;
     case JS_CLASS_BIG_UINT64_ARRAY:
-        if (is_big || is_strict_mode(ctx)) {
-            /* generic loop for bignums, argv[0] is a bignum != NaN */
-            /* XXX: optimize with explicit values */
+        if (is_bigint || (is_math_mode(ctx) && is_int &&
+                          v64 >= 0 && v64 <= MAX_SAFE_INTEGER)) {
+            const uint64_t *pv;
+            uint64_t v;
+        scan64:
+            pv = p->u.array.u.uint64_ptr;
+            v = v64;
             for (; k != stop; k += inc) {
-                JSValue v = JS_GetPropertyUint32(ctx, this_val, k);
-                int ret;
-                if (JS_IsException(v))
-                    goto exception;
-                ret = js_same_value_zero(ctx, v, argv[0]);
-                JS_FreeValue(ctx, v);
-                if (ret) {
-                    if (ret < 0)
-                        goto exception;
+                if (pv[k] == v) {
                     res = k;
                     break;
                 }
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 57eded89f8..abf4d83bfc 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -335,6 +335,8 @@ void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);
 void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);
 void JS_FreeRuntime(JSRuntime *rt);
+void *JS_GetRuntimeOpaque(JSRuntime *rt);
+void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque);
 typedef void JS_MarkFunc(JSRuntime *rt, JSGCObjectHeader *gp);
 void JS_MarkValue(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
 void JS_RunGC(JSRuntime *rt);
@@ -508,7 +510,28 @@ static js_force_inline JSValue JS_NewCatchOffset(JSContext *ctx, int32_t val)
     return JS_MKVAL(JS_TAG_CATCH_OFFSET, val);
 }
 
-JSValue JS_NewInt64(JSContext *ctx, int64_t v);
+static js_force_inline JSValue JS_NewInt64(JSContext *ctx, int64_t val)
+{
+    JSValue v;
+    if (val == (int32_t)val) {
+        v = JS_NewInt32(ctx, val);
+    } else {
+        v = __JS_NewFloat64(ctx, val);
+    }
+    return v;
+}
+
+static js_force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
+{
+    JSValue v;
+    if (val <= 0x7fffffff) {
+        v = JS_NewInt32(ctx, val);
+    } else {
+        v = __JS_NewFloat64(ctx, val);
+    }
+    return v;
+}
+
 JSValue JS_NewBigInt64(JSContext *ctx, int64_t v);
 JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);
 
@@ -657,7 +680,10 @@ static int inline JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
 int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val);
 int JS_ToFloat64(JSContext *ctx, double *pres, JSValueConst val);
+/* return an exception if 'val' is a Number */
 int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
+/* same as JS_ToInt64() but allow BigInt */
+int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val);
 
 JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);
 JSValue JS_NewString(JSContext *ctx, const char *str);

From bb069704a0da99c9c48644abcc851aac817d04c1 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 21 Apr 2020 14:33:20 +0300
Subject: [PATCH 057/185] updated quickjs to 2020-04-12

---
 quickjs/VERSION        |    2 +-
 quickjs/libbf.c        |    8 +-
 quickjs/quickjs-libc.c |  180 +++++-
 quickjs/quickjs.c      | 1197 ++++++++++++++++++++++++++++------------
 quickjs/quickjs.h      |    5 +-
 5 files changed, 1033 insertions(+), 359 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 81b7bb9c01..69f162a403 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-03-16
+2020-04-12
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 14aff8f7fd..2ef51042da 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -1701,10 +1701,12 @@ static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         memset(taba, 0, d * sizeof(limb_t));
         memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
         if (bf_resize(r, n + 1))
+            goto fail1;
+        if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
+        fail1:
+            bf_free(s, taba);
             goto fail;
-        if (mp_divnorm(s, r->tab, taba, na, b->tab, nb))
-            goto fail;
-        
+        }
         /* see if non zero remainder */
         if (mp_scan_nz(taba, nb))
             r->tab[0] |= 1;
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 3ff5168a79..4e6d221525 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -239,6 +239,7 @@ static JSValue js_printf_internal(JSContext *ctx,
                 case 's':
                     if (i >= argc)
                         goto missing;
+                    /* XXX: handle strings containing null characters */
                     string_arg = JS_ToCString(ctx, argv[i++]);
                     if (!string_arg)
                         goto fail;
@@ -843,6 +844,7 @@ static JSValue js_std_file_puts(JSContext *ctx, JSValueConst this_val,
     FILE *f;
     int i;
     const char *str;
+    size_t len;
 
     if (magic == 0) {
         f = stdout;
@@ -853,10 +855,10 @@ static JSValue js_std_file_puts(JSContext *ctx, JSValueConst this_val,
     }
     
     for(i = 0; i < argc; i++) {
-        str = JS_ToCString(ctx, argv[i]);
+        str = JS_ToCStringLen(ctx, &len, argv[i]);
         if (!str)
             return JS_EXCEPTION;
-        fputs(str, f);
+        fwrite(str, 1, len, f);
         JS_FreeCString(ctx, str);
     }
     return JS_UNDEFINED;
@@ -2325,6 +2327,121 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, ret);
 }
 
+static char **build_envp(JSContext *ctx, JSValueConst obj)
+{
+    uint32_t len, i;
+    JSPropertyEnum *tab;
+    char **envp, *pair;
+    const char *key, *str;
+    JSValue val;
+    size_t key_len, str_len;
+    
+    if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
+                               JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
+        return NULL;
+    envp = js_mallocz(ctx, sizeof(envp[0]) * ((size_t)len + 1));
+    if (!envp)
+        goto fail;
+    for(i = 0; i < len; i++) {
+        val = JS_GetProperty(ctx, obj, tab[i].atom);
+        if (JS_IsException(val))
+            goto fail;
+        str = JS_ToCString(ctx, val);
+        JS_FreeValue(ctx, val);
+        if (!str)
+            goto fail;
+        key = JS_AtomToCString(ctx, tab[i].atom);
+        if (!key) {
+            JS_FreeCString(ctx, str);
+            goto fail;
+        }
+        key_len = strlen(key);
+        str_len = strlen(str);
+        pair = js_malloc(ctx, key_len + str_len + 2);
+        if (!pair) {
+            JS_FreeCString(ctx, key);
+            JS_FreeCString(ctx, str);
+            goto fail;
+        }
+        memcpy(pair, key, key_len);
+        pair[key_len] = '=';
+        memcpy(pair + key_len + 1, str, str_len);
+        pair[key_len + 1 + str_len] = '\0';
+        envp[i] = pair;
+        JS_FreeCString(ctx, key);
+        JS_FreeCString(ctx, str);
+    }
+ done:
+    for(i = 0; i < len; i++)
+        JS_FreeAtom(ctx, tab[i].atom);
+    js_free(ctx, tab);
+    return envp;
+ fail:
+    if (envp) {
+        for(i = 0; i < len; i++)
+            js_free(ctx, envp[i]);
+        js_free(ctx, envp);
+        envp = NULL;
+    }
+    goto done;
+}
+
+/* execvpe is not available on non GNU systems */
+static int my_execvpe(const char *filename, char **argv, char **envp)
+{
+    char *path, *p, *p_next, *p1;
+    char buf[PATH_MAX];
+    size_t filename_len, path_len;
+    BOOL eacces_error;
+    
+    filename_len = strlen(filename);
+    if (filename_len == 0) {
+        errno = ENOENT;
+        return -1;
+    }
+    if (strchr(filename, '/'))
+        return execve(filename, argv, envp);
+    
+    path = getenv("PATH");
+    if (!path)
+        path = "/bin:/usr/bin";
+    eacces_error = FALSE;
+    p = path;
+    for(p = path; p != NULL; p = p_next) {
+        p1 = strchr(p, ':');
+        if (!p1) {
+            p_next = NULL;
+            path_len = strlen(p);
+        } else {
+            p_next = p1 + 1;
+            path_len = p1 - p;
+        }
+        /* path too long */
+        if ((path_len + 1 + filename_len + 1) > PATH_MAX)
+            continue;
+        memcpy(buf, p, path_len);
+        buf[path_len] = '/';
+        memcpy(buf + path_len + 1, filename, filename_len);
+        buf[path_len + 1 + filename_len] = '\0';
+        
+        execve(buf, argv, envp);
+
+        switch(errno) {
+        case EACCES:
+            eacces_error = TRUE;
+            break;
+        case ENOENT:
+        case ENOTDIR:
+            break;
+        default:
+            return -1;
+        }
+    }
+    if (eacces_error)
+        errno = EACCES;
+    return -1;
+}
+
 /* exec(args[, options]) -> exitcode */
 static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
                           int argc, JSValueConst *argv)
@@ -2332,11 +2449,13 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
     JSValueConst options, args = argv[0];
     JSValue val, ret_val;
     const char **exec_argv, *file = NULL, *str, *cwd = NULL;
+    char **envp = environ;
     uint32_t exec_argc, i;
     int ret, pid, status;
     BOOL block_flag = TRUE, use_path = TRUE;
     static const char *std_name[3] = { "stdin", "stdout", "stderr" };
     int std_fds[3];
+    uint32_t uid = -1, gid = -1;
     
     val = JS_GetPropertyStr(ctx, args, "length");
     if (JS_IsException(val))
@@ -2410,6 +2529,36 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
                 std_fds[i] = fd;
             }
         }
+
+        val = JS_GetPropertyStr(ctx, options, "env");
+        if (JS_IsException(val))
+            goto exception;
+        if (!JS_IsUndefined(val)) {
+            envp = build_envp(ctx, val);
+            JS_FreeValue(ctx, val);
+            if (!envp)
+                goto exception;
+        }
+        
+        val = JS_GetPropertyStr(ctx, options, "uid");
+        if (JS_IsException(val))
+            goto exception;
+        if (!JS_IsUndefined(val)) {
+            ret = JS_ToUint32(ctx, &uid, val);
+            JS_FreeValue(ctx, val);
+            if (ret)
+                goto exception;
+        }
+
+        val = JS_GetPropertyStr(ctx, options, "gid");
+        if (JS_IsException(val))
+            goto exception;
+        if (!JS_IsUndefined(val)) {
+            ret = JS_ToUint32(ctx, &gid, val);
+            JS_FreeValue(ctx, val);
+            if (ret)
+                goto exception;
+        }
     }
 
     pid = fork();
@@ -2435,12 +2584,21 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
             if (chdir(cwd) < 0)
                 _exit(127);
         }
+        if (uid != -1) {
+            if (setuid(uid) < 0)
+                _exit(127);
+        }
+        if (gid != -1) {
+            if (setgid(gid) < 0)
+                _exit(127);
+        }
+
         if (!file)
             file = exec_argv[0];
         if (use_path)
-            ret = execvp(file, (char **)exec_argv);
+            ret = my_execvpe(file, (char **)exec_argv, envp);
         else
-            ret = execv(file, (char **)exec_argv);
+            ret = execve(file, (char **)exec_argv, envp);
         _exit(127);
     }
     /* parent */
@@ -2467,6 +2625,15 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
     for(i = 0; i < exec_argc; i++)
         JS_FreeCString(ctx, exec_argv[i]);
     js_free(ctx, exec_argv);
+    if (envp != environ) {
+        char **p;
+        p = envp;
+        while (*p != NULL) {
+            js_free(ctx, *p);
+            p++;
+        }
+        js_free(ctx, envp);
+    }
     return ret_val;
  exception:
     ret_val = JS_EXCEPTION;
@@ -2700,14 +2867,15 @@ static JSValue js_print(JSContext *ctx, JSValueConst this_val,
 {
     int i;
     const char *str;
+    size_t len;
 
     for(i = 0; i < argc; i++) {
         if (i != 0)
             putchar(' ');
-        str = JS_ToCString(ctx, argv[i]);
+        str = JS_ToCStringLen(ctx, &len, argv[i]);
         if (!str)
             return JS_EXCEPTION;
-        fputs(str, stdout);
+        fwrite(str, 1, len, stdout);
         JS_FreeCString(ctx, str);
     }
     putchar('\n');
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index cabb82b084..7da72531b1 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -187,7 +187,8 @@ typedef enum JSErrorEnum {
     JS_TYPE_ERROR,
     JS_URI_ERROR,
     JS_INTERNAL_ERROR,
-
+    JS_AGGREGATE_ERROR,
+    
     JS_NATIVE_ERROR_COUNT, /* number of different NativeError objects */
 } JSErrorEnum;
 
@@ -257,6 +258,15 @@ struct JSRuntime {
 #ifdef DUMP_LEAKS
     struct list_head string_list; /* list of JSString.link */
 #endif
+    /* stack limitation */
+    const uint8_t *stack_top;
+    size_t stack_size; /* in bytes */
+
+    JSValue current_exception;
+    /* true if inside an out of memory error, to avoid recursing */
+    BOOL in_out_of_memory : 8;
+
+    struct JSStackFrame *current_stack_frame;
 
     JSInterruptHandler *interrupt_handler;
     void *interrupt_opaque;
@@ -322,6 +332,7 @@ typedef enum {
     JS_GC_OBJ_TYPE_SHAPE,
     JS_GC_OBJ_TYPE_VAR_REF,
     JS_GC_OBJ_TYPE_ASYNC_FUNCTION,
+    JS_GC_OBJ_TYPE_JS_CONTEXT,
 } JSGCObjectTypeEnum;
 
 /* header for GC objects. GC objects are C data structures with a
@@ -378,29 +389,30 @@ typedef struct JSBigDecimal {
 } JSBigDecimal;
 #endif
 
+typedef enum {
+    JS_AUTOINIT_ID_PROTOTYPE,
+    JS_AUTOINIT_ID_MODULE_NS,
+    JS_AUTOINIT_ID_PROP, /* must be last */
+} JSAutoInitIDEnum;
+
 /* must be large enough to have a negligible runtime cost and small
    enough to call the interrupt callback often. */
 #define JS_INTERRUPT_COUNTER_INIT 10000
 
 struct JSContext {
+    JSGCObjectHeader header; /* must come first */
     JSRuntime *rt;
     struct list_head link;
-    const uint8_t *stack_top;
-    size_t stack_size; /* in bytes */
 
-    JSValue current_exception;
-    /* true if inside an out of memory error, to avoid recursing */
-    BOOL in_out_of_memory : 8;
     uint16_t binary_object_count;
     int binary_object_size;
 
     JSShape *array_shape;   /* initial shape for Array objects */
 
-    JSStackFrame *current_stack_frame;
-
     JSValue *class_proto;
     JSValue function_proto;
     JSValue function_ctor;
+    JSValue array_ctor;
     JSValue regexp_ctor;
     JSValue promise_ctor;
     JSValue native_error_proto[JS_NATIVE_ERROR_COUNT];
@@ -570,6 +582,7 @@ typedef struct JSFunctionBytecode {
     uint16_t var_count;
     uint16_t defined_arg_count; /* for length function property */
     uint16_t stack_size; /* maximum stack size */
+    JSContext *realm; /* function realm */
     JSValue *cpool; /* constant pool (self pointer) */
     int cpool_count;
     int closure_var_count;
@@ -784,8 +797,12 @@ typedef struct JSProperty {
         } getset;
         JSVarRef *var_ref;  /* JS_PROP_VARREF */
         struct {            /* JS_PROP_AUTOINIT */
-            int (*init_func)(JSContext *ctx, JSObject *obj,
-                             JSAtom prop, void *opaque);
+            /* in order to use only 2 pointers, we compress the realm
+               and the init function pointer */
+            union {
+                JSContext *realm; /* for JS_AUTOINIT_ID_PROP */
+                uintptr_t init_id; /* JS_AUTOINIT_ID_x */
+            } u;
             void *opaque;
         } init;
     } u;
@@ -872,7 +889,8 @@ struct JSObject {
             JSVarRef **var_refs;
             JSObject *home_object; /* for 'super' access */
         } func;
-        struct { /* JS_CLASS_C_FUNCTION: 8/12 bytes */
+        struct { /* JS_CLASS_C_FUNCTION: 12/20 bytes */
+            JSContext *realm;
             JSCFunctionType c_function;
             uint8_t length;
             uint8_t cproto;
@@ -999,6 +1017,9 @@ static void js_array_mark(JSRuntime *rt, JSValueConst val,
 static void js_object_data_finalizer(JSRuntime *rt, JSValue val);
 static void js_object_data_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
+static void js_c_function_finalizer(JSRuntime *rt, JSValue val);
+static void js_c_function_mark(JSRuntime *rt, JSValueConst val,
+                               JS_MarkFunc *mark_func);
 static void js_bytecode_function_finalizer(JSRuntime *rt, JSValue val);
 static void js_bytecode_function_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
@@ -1131,6 +1152,8 @@ static JSValue JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                const char *input, size_t input_len,
                                const char *filename, int flags, int scope_idx);
 static void js_free_module_def(JSContext *ctx, JSModuleDef *m);
+static void js_mark_module_def(JSRuntime *rt, JSModuleDef *m,
+                               JS_MarkFunc *mark_func);
 static JSValue js_import_meta(JSContext *ctx);
 static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier);
 static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref);
@@ -1184,6 +1207,11 @@ static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
                           JSGCObjectTypeEnum type);
 static void remove_gc_object(JSGCObjectHeader *h);
 static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s);
+static int js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
+static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
+                                 void *opaque);
+static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
+                                          JSAtom atom, void *opaque);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
 static const JSClassExoticMethods js_string_exotic_methods;
@@ -1351,7 +1379,7 @@ typedef struct JSClassShortDef {
 static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Object, NULL, NULL },                             /* JS_CLASS_OBJECT */
     { JS_ATOM_Array, js_array_finalizer, js_array_mark },       /* JS_CLASS_ARRAY */
-    { JS_ATOM_Error, NULL, NULL },                              /* JS_CLASS_ERROR */
+    { JS_ATOM_Error, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_ERROR */
     { JS_ATOM_Number, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_NUMBER */
     { JS_ATOM_String, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_STRING */
     { JS_ATOM_Boolean, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_BOOLEAN */
@@ -1360,7 +1388,7 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Arguments, NULL, NULL },                          /* JS_CLASS_MAPPED_ARGUMENTS */
     { JS_ATOM_Date, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_DATE */
     { JS_ATOM_Object, NULL, NULL },                             /* JS_CLASS_MODULE_NS */
-    { JS_ATOM_Function, NULL, NULL },                           /* JS_CLASS_C_FUNCTION */
+    { JS_ATOM_Function, js_c_function_finalizer, js_c_function_mark }, /* JS_CLASS_C_FUNCTION */
     { JS_ATOM_Function, js_bytecode_function_finalizer, js_bytecode_function_mark }, /* JS_CLASS_BYTECODE_FUNCTION */
     { JS_ATOM_Function, js_bound_function_finalizer, js_bound_function_mark }, /* JS_CLASS_BOUND_FUNCTION */
     { JS_ATOM_Function, js_c_function_data_finalizer, js_c_function_data_mark }, /* JS_CLASS_C_FUNCTION_DATA */
@@ -1477,6 +1505,32 @@ static void set_dummy_numeric_ops(JSNumericOperations *ops)
 
 #endif /* CONFIG_BIGNUM */
 
+#if defined(EMSCRIPTEN)
+/* currently no stack limitation */
+static inline uint8_t *js_get_stack_pointer(void)
+{
+    return NULL;
+}
+
+static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
+{
+    return FALSE;
+}
+#else
+/* Note: OS and CPU dependent */
+static inline uint8_t *js_get_stack_pointer(void)
+{
+    return __builtin_frame_address(0);
+}
+
+static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
+{
+    size_t size;
+    size = rt->stack_top - js_get_stack_pointer();
+    return unlikely((size + alloca_size) > rt->stack_size);
+}
+#endif
+
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
 {
     JSRuntime *rt;
@@ -1532,6 +1586,11 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->class_array[JS_CLASS_GENERATOR_FUNCTION].call = js_generator_function_call;
     if (init_shape_hash(rt))
         goto fail;
+
+    rt->stack_top = js_get_stack_pointer();
+    rt->stack_size = JS_DEFAULT_STACK_SIZE;
+    rt->current_exception = JS_NULL;
+
     return rt;
  fail:
     JS_FreeRuntime(rt);
@@ -1798,10 +1857,7 @@ void JS_FreeRuntime(JSRuntime *rt)
     struct list_head *el, *el1;
     int i;
 
-    list_for_each_safe(el, el1, &rt->context_list) {
-        JSContext *ctx = list_entry(el, JSContext, link);
-        JS_FreeContext(ctx);
-    }
+    JS_FreeValueRT(rt, rt->current_exception);
 
     list_for_each_safe(el, el1, &rt->job_list) {
         JSJobEntry *e = list_entry(el, JSJobEntry, link);
@@ -1984,32 +2040,6 @@ void JS_FreeRuntime(JSRuntime *rt)
     }
 }
 
-#if defined(EMSCRIPTEN)
-/* currently no stack limitation */
-static inline uint8_t *js_get_stack_pointer(void)
-{
-    return NULL;
-}
-
-static inline BOOL js_check_stack_overflow(JSContext *ctx, size_t alloca_size)
-{
-    return FALSE;
-}
-#else
-/* Note: OS and CPU dependent */
-static inline uint8_t *js_get_stack_pointer(void)
-{
-    return __builtin_frame_address(0);
-}
-
-static inline BOOL js_check_stack_overflow(JSContext *ctx, size_t alloca_size)
-{
-    size_t size;
-    size = ctx->stack_top - js_get_stack_pointer();
-    return unlikely((size + alloca_size) > ctx->stack_size);
-}
-#endif
-
 JSContext *JS_NewContextRaw(JSRuntime *rt)
 {
     JSContext *ctx;
@@ -2018,6 +2048,9 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
     ctx = js_mallocz_rt(rt, sizeof(JSContext));
     if (!ctx)
         return NULL;
+    ctx->header.ref_count = 1;
+    add_gc_object(rt, &ctx->header, JS_GC_OBJ_TYPE_JS_CONTEXT);
+
     ctx->class_proto = js_malloc_rt(rt, sizeof(ctx->class_proto[0]) *
                                     rt->class_count);
     if (!ctx->class_proto) {
@@ -2026,9 +2059,6 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
     }
     ctx->rt = rt;
     list_add_tail(&ctx->link, &rt->context_list);
-    ctx->stack_top = js_get_stack_pointer();
-    ctx->stack_size = JS_DEFAULT_STACK_SIZE;
-    ctx->current_exception = JS_NULL;
 #ifdef CONFIG_BIGNUM
     ctx->bf_ctx = &rt->bf_ctx;
     ctx->fp_env.prec = 113;
@@ -2036,6 +2066,7 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
 #endif
     for(i = 0; i < rt->class_count; i++)
         ctx->class_proto[i] = JS_NULL;
+    ctx->array_ctor = JS_NULL;
     ctx->regexp_ctor = JS_NULL;
     ctx->promise_ctor = JS_NULL;
     init_list_head(&ctx->loaded_modules);
@@ -2122,11 +2153,60 @@ static void js_free_modules(JSContext *ctx, JSFreeModuleEnum flag)
     }
 }
 
+JSContext *JS_DupContext(JSContext *ctx)
+{
+    ctx->header.ref_count++;
+    return ctx;
+}
+
+/* used by the GC */
+static void JS_MarkContext(JSRuntime *rt, JSContext *ctx,
+                           JS_MarkFunc *mark_func)
+{
+    int i;
+    struct list_head *el;
+
+    /* modules are not seen by the GC, so we directly mark the objects
+       referenced by each module */
+    list_for_each(el, &ctx->loaded_modules) {
+        JSModuleDef *m = list_entry(el, JSModuleDef, link);
+        js_mark_module_def(rt, m, mark_func);
+    }
+
+    JS_MarkValue(rt, ctx->global_obj, mark_func);
+    JS_MarkValue(rt, ctx->global_var_obj, mark_func);
+
+    JS_MarkValue(rt, ctx->throw_type_error, mark_func);
+    JS_MarkValue(rt, ctx->eval_obj, mark_func);
+
+    JS_MarkValue(rt, ctx->array_proto_values, mark_func);
+    for(i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
+        JS_MarkValue(rt, ctx->native_error_proto[i], mark_func);
+    }
+    for(i = 0; i < rt->class_count; i++) {
+        JS_MarkValue(rt, ctx->class_proto[i], mark_func);
+    }
+    JS_MarkValue(rt, ctx->iterator_proto, mark_func);
+    JS_MarkValue(rt, ctx->async_iterator_proto, mark_func);
+    JS_MarkValue(rt, ctx->promise_ctor, mark_func);
+    JS_MarkValue(rt, ctx->array_ctor, mark_func);
+    JS_MarkValue(rt, ctx->regexp_ctor, mark_func);
+    JS_MarkValue(rt, ctx->function_ctor, mark_func);
+    JS_MarkValue(rt, ctx->function_proto, mark_func);
+
+    if (ctx->array_shape)
+        mark_func(rt, &ctx->array_shape->header);
+}
+
 void JS_FreeContext(JSContext *ctx)
 {
     JSRuntime *rt = ctx->rt;
     int i;
 
+    if (--ctx->header.ref_count > 0)
+        return;
+    assert(ctx->header.ref_count == 0);
+    
 #ifdef DUMP_ATOMS
     JS_DumpAtoms(ctx->rt);
 #endif
@@ -2156,8 +2236,6 @@ void JS_FreeContext(JSContext *ctx)
 
     js_free_modules(ctx, JS_FREE_MODULE_ALL);
 
-    JS_FreeValue(ctx, ctx->current_exception);
-
     JS_FreeValue(ctx, ctx->global_obj);
     JS_FreeValue(ctx, ctx->global_var_obj);
 
@@ -2175,6 +2253,7 @@ void JS_FreeContext(JSContext *ctx)
     JS_FreeValue(ctx, ctx->iterator_proto);
     JS_FreeValue(ctx, ctx->async_iterator_proto);
     JS_FreeValue(ctx, ctx->promise_ctor);
+    JS_FreeValue(ctx, ctx->array_ctor);
     JS_FreeValue(ctx, ctx->regexp_ctor);
     JS_FreeValue(ctx, ctx->function_ctor);
     JS_FreeValue(ctx, ctx->function_proto);
@@ -2182,6 +2261,7 @@ void JS_FreeContext(JSContext *ctx)
     js_free_shape_null(ctx->rt, ctx->array_shape);
 
     list_del(&ctx->link);
+    remove_gc_object(&ctx->header);
     js_free_rt(ctx->rt, ctx);
 }
 
@@ -2190,21 +2270,21 @@ JSRuntime *JS_GetRuntime(JSContext *ctx)
     return ctx->rt;
 }
 
-void JS_SetMaxStackSize(JSContext *ctx, size_t stack_size)
+void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size)
 {
-    ctx->stack_size = stack_size;
+    rt->stack_size = stack_size;
 }
 
 static inline BOOL is_strict_mode(JSContext *ctx)
 {
-    JSStackFrame *sf = ctx->current_stack_frame;
+    JSStackFrame *sf = ctx->rt->current_stack_frame;
     return (sf && (sf->js_mode & JS_MODE_STRICT));
 }
 
 #ifdef CONFIG_BIGNUM
 static inline BOOL is_math_mode(JSContext *ctx)
 {
-    JSStackFrame *sf = ctx->current_stack_frame;
+    JSStackFrame *sf = ctx->rt->current_stack_frame;
     return (sf && (sf->js_mode & JS_MODE_MATH));
 }
 #endif
@@ -4541,6 +4621,7 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
         p->u.array.u.ptr = NULL;
         p->u.array.count = 0;
         break;
+    case JS_CLASS_ERROR:
     case JS_CLASS_NUMBER:
     case JS_CLASS_STRING:
     case JS_CLASS_BOOLEAN:
@@ -4775,6 +4856,7 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
     if (JS_IsException(func_obj))
         return func_obj;
     p = JS_VALUE_GET_OBJ(func_obj);
+    p->u.cfunc.realm = JS_DupContext(ctx);
     p->u.cfunc.c_function.generic = func;
     p->u.cfunc.length = length;
     p->u.cfunc.cproto = cproto;
@@ -4885,6 +4967,21 @@ JSValue JS_NewCFunctionData(JSContext *ctx, JSCFunctionData *func,
     return func_obj;
 }
 
+static void js_autoinit_free(JSRuntime *rt, JSProperty *pr)
+{
+    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
+        JS_FreeContext(pr->u.init.u.realm);
+    }
+}
+
+static void js_autoinit_mark(JSRuntime *rt, JSProperty *pr,
+                             JS_MarkFunc *mark_func)
+{
+    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
+        mark_func(rt, &pr->u.init.u.realm->header);
+    }
+}
+
 static void free_property(JSRuntime *rt, JSProperty *pr, int prop_flags)
 {
     if (unlikely(prop_flags & JS_PROP_TMASK)) {
@@ -4896,7 +4993,7 @@ static void free_property(JSRuntime *rt, JSProperty *pr, int prop_flags)
         } else if ((prop_flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
             free_var_ref(rt, pr->u.var_ref);
         } else if ((prop_flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-            /* nothing to do */
+            js_autoinit_free(rt, pr);
         }
     } else {
         JS_FreeValueRT(rt, pr->u.value);
@@ -5004,6 +5101,23 @@ static void js_object_data_mark(JSRuntime *rt, JSValueConst val,
     JS_MarkValue(rt, p->u.object_data, mark_func);
 }
 
+static void js_c_function_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(val);
+
+    if (p->u.cfunc.realm)
+        JS_FreeContext(p->u.cfunc.realm);
+}
+
+static void js_c_function_mark(JSRuntime *rt, JSValueConst val,
+                               JS_MarkFunc *mark_func)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(val);
+
+    if (p->u.cfunc.realm)
+        mark_func(rt, &p->u.cfunc.realm->header);
+}
+
 static void js_bytecode_function_finalizer(JSRuntime *rt, JSValue val)
 {
     JSObject *p1, *p = JS_VALUE_GET_OBJ(val);
@@ -5315,7 +5429,7 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
                                 mark_func(rt, &pr->u.var_ref->header);
                             }
                         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                            /* nothing to do */
+                            js_autoinit_mark(rt, pr, mark_func);
                         }
                     } else {
                         JS_MarkValue(rt, pr->u.value, mark_func);
@@ -5340,6 +5454,8 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
             for(i = 0; i < b->cpool_count; i++) {
                 JS_MarkValue(rt, b->cpool[i], mark_func);
             }
+            if (b->realm)
+                mark_func(rt, &b->realm->header);
         }
         break;
     case JS_GC_OBJ_TYPE_VAR_REF:
@@ -5367,45 +5483,17 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
             }
         }
         break;
+    case JS_GC_OBJ_TYPE_JS_CONTEXT:
+        {
+            JSContext *ctx = (JSContext *)gp;
+            JS_MarkContext(rt, ctx, mark_func);
+        }
+        break;
     default:
         abort();
     }
 }
 
-#if 0
-/* not useful until realms are supported */
-static void mark_context(JSRuntime *rt, JSContext *ctx)
-{
-    int i;
-    struct list_head *el;
-
-    list_for_each(el, &ctx->loaded_modules) {
-        JSModuleDef *m = list_entry(el, JSModuleDef, link);
-        JS_MarkValue(rt, m->module_ns);
-        JS_MarkValue(rt, m->func_obj);
-    }
-
-    JS_MarkValue(rt, ctx->current_exception);
-
-    for(i = 0; i < rt->class_count; i++)
-        JS_MarkValue(rt, ctx->class_proto[i]);
-    JS_MarkValue(rt, ctx->regexp_ctor);
-    JS_MarkValue(rt, ctx->function_ctor);
-    JS_MarkValue(rt, ctx->function_proto);
-    JS_MarkValue(rt, ctx->iterator_proto);
-    JS_MarkValue(rt, ctx->async_iterator_proto);
-    JS_MarkValue(rt, ctx->array_proto_values);
-
-    for(i = 0; i < JS_NATIVE_ERROR_COUNT; i++)
-        JS_MarkValue(rt, ctx->native_error_proto[i]);
-
-    JS_MarkValue(rt, ctx->throw_type_error);
-    JS_MarkValue(rt, ctx->eval_obj);
-    JS_MarkValue(rt, ctx->global_obj);
-    JS_MarkValue(rt, ctx->global_var_obj);
-}
-#endif
-
 static void gc_decref_child(JSRuntime *rt, JSGCObjectHeader *p)
 {
     assert(p->ref_count > 0);
@@ -6056,8 +6144,9 @@ JSValue JS_GetGlobalObject(JSContext *ctx)
 /* WARNING: obj is freed */
 JSValue JS_Throw(JSContext *ctx, JSValue obj)
 {
-    JS_FreeValue(ctx, ctx->current_exception);
-    ctx->current_exception = obj;
+    JSRuntime *rt = ctx->rt;
+    JS_FreeValue(ctx, rt->current_exception);
+    rt->current_exception = obj;
     return JS_EXCEPTION;
 }
 
@@ -6065,8 +6154,9 @@ JSValue JS_Throw(JSContext *ctx, JSValue obj)
 JSValue JS_GetException(JSContext *ctx)
 {
     JSValue val;
-    val = ctx->current_exception;
-    ctx->current_exception = JS_NULL;
+    JSRuntime *rt = ctx->rt;
+    val = rt->current_exception;
+    rt->current_exception = JS_NULL;
     return val;
 }
 
@@ -6224,7 +6314,7 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
         if (backtrace_flags & JS_BACKTRACE_FLAG_SINGLE_LEVEL)
             goto done;
     }
-    for(sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
+    for(sf = ctx->rt->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
         if (backtrace_flags & JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL) {
             backtrace_flags &= ~JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL;
             continue;
@@ -6266,7 +6356,10 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
     }
  done:
     dbuf_putc(&dbuf, '\0');
-    str = JS_NewString(ctx, (char *)dbuf.buf);
+    if (dbuf_error(&dbuf))
+        str = JS_NULL;
+    else
+        str = JS_NewString(ctx, (char *)dbuf.buf);
     dbuf_free(&dbuf);
     JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_stack, str,
                            JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
@@ -6318,12 +6411,13 @@ static JSValue JS_ThrowError2(JSContext *ctx, JSErrorEnum error_num,
 static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
                              const char *fmt, va_list ap)
 {
+    JSRuntime *rt = ctx->rt;
     JSStackFrame *sf;
     BOOL add_backtrace;
 
     /* the backtrace is added later if called from a bytecode function */
-    sf = ctx->current_stack_frame;
-    add_backtrace = !ctx->in_out_of_memory &&
+    sf = rt->current_stack_frame;
+    add_backtrace = !rt->in_out_of_memory &&
         (!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
     return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
 }
@@ -6413,10 +6507,11 @@ JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *c
 
 JSValue JS_ThrowOutOfMemory(JSContext *ctx)
 {
-    if (!ctx->in_out_of_memory) {
-        ctx->in_out_of_memory = TRUE;
+    JSRuntime *rt = ctx->rt;
+    if (!rt->in_out_of_memory) {
+        rt->in_out_of_memory = TRUE;
         JS_ThrowInternalError(ctx, "out of memory");
-        ctx->in_out_of_memory = FALSE;
+        rt->in_out_of_memory = FALSE;
     }
     return JS_EXCEPTION;
 }
@@ -6674,7 +6769,27 @@ int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj)
 
 static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop, JSProperty *pr)
 {
-    return (*pr->u.init.init_func)(ctx, p, prop, pr->u.init.opaque);
+    int ret;
+    JSContext *realm;
+
+    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
+        realm = pr->u.init.u.realm;
+        ret = JS_InstantiateFunctionListItem(realm, p, prop, pr->u.init.opaque);
+        if (ret)
+            return ret;
+    } else {
+        switch(pr->u.init.u.init_id) {
+        case JS_AUTOINIT_ID_PROTOTYPE:
+            ret = js_instantiate_prototype(ctx, p, prop, pr->u.init.opaque);
+            break;
+        case JS_AUTOINIT_ID_MODULE_NS:
+            ret = js_module_ns_autoinit(ctx, p, prop, pr->u.init.opaque);
+            break;
+        default:
+            abort();
+        }
+    }
+    return ret;
 }
 
 JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
@@ -7742,6 +7857,7 @@ static int call_setter(JSContext *ctx, JSObject *setter,
         if (JS_IsException(ret))
             return -1;
         JS_FreeValue(ctx, ret);
+        return TRUE;
     } else {
         JS_FreeValue(ctx, val);
         if ((flags & JS_PROP_THROW) ||
@@ -7749,9 +7865,8 @@ static int call_setter(JSContext *ctx, JSObject *setter,
             JS_ThrowTypeError(ctx, "no setter for property");
             return -1;
         }
-        /* XXX: should return FALSE? */
+        return FALSE;
     }
-    return TRUE;
 }
 
 /* set the array length and remove the array elements if necessary. */
@@ -8626,6 +8741,7 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                         /* clear property and update */
                         if (js_shape_prepare_update(ctx, p, &prs))
                             return -1;
+                        js_autoinit_free(ctx->rt, pr);
                         prs->flags &= ~JS_PROP_TMASK;
                         pr->u.value = JS_UNDEFINED;
                         goto retry;
@@ -8680,6 +8796,7 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                     /* clear property and update */
                     if (js_shape_prepare_update(ctx, p, &prs))
                         return -1;
+                    js_autoinit_free(ctx->rt, pr);
                     prs->flags &= ~JS_PROP_TMASK;
                     pr->u.value = JS_UNDEFINED;
                 } else {
@@ -8835,8 +8952,7 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
 }
 
 static int JS_DefineAutoInitProperty(JSContext *ctx, JSValueConst this_obj,
-                                     JSAtom prop, int (*init_func)(JSContext *ctx, JSObject *obj,
-                                                                   JSAtom prop, void *opaque),
+                                     JSAtom prop, JSAutoInitIDEnum id,
                                      void *opaque, int flags)
 {
     JSObject *p;
@@ -8857,8 +8973,11 @@ static int JS_DefineAutoInitProperty(JSContext *ctx, JSValueConst this_obj,
     pr = add_property(ctx, p, prop, (flags & JS_PROP_C_W_E) | JS_PROP_AUTOINIT);
     if (unlikely(!pr))
         return -1;
-
-    pr->u.init.init_func = init_func;
+    if (id == JS_AUTOINIT_ID_PROP) {
+        pr->u.init.u.realm = JS_DupContext(ctx);
+    } else {
+        pr->u.init.u.init_id = id;
+    }
     pr->u.init.opaque = opaque;
     return TRUE;
 }
@@ -9334,7 +9453,7 @@ void JS_SetUncatchableError(JSContext *ctx, JSValueConst val, BOOL flag)
 
 void JS_ResetUncatchableError(JSContext *ctx)
 {
-    JS_SetUncatchableError(ctx, ctx->current_exception, FALSE);
+    JS_SetUncatchableError(ctx, ctx->rt->current_exception, FALSE);
 }
 
 void JS_SetOpaque(JSValue obj, void *opaque)
@@ -11276,7 +11395,7 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
                     printf("[varref %p]", (void *)pr->u.var_ref);
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                    printf("[autoinit %p %p]", (void *)pr->u.init.init_func,
+                    printf("[autoinit %p %p]", (void *)pr->u.init.u.realm,
                            (void *)pr->u.init.opaque);
                 } else {
                     JS_DumpValueShort(rt, pr->u.value);
@@ -11327,6 +11446,9 @@ static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p)
         case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
             printf("[async_function]");
             break;
+        case JS_GC_OBJ_TYPE_JS_CONTEXT:
+            printf("[js_context]");
+            break;
         default:
             printf("[unknown %d]", p->gc_obj_type);
             break;
@@ -14500,7 +14622,7 @@ static JSValue js_build_mapped_arguments(JSContext *ctx, int argc,
                            JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
     /* callee returns this function in non strict mode */
     JS_DefinePropertyValue(ctx, val, JS_ATOM_callee,
-                           JS_DupValue(ctx, ctx->current_stack_frame->cur_func),
+                           JS_DupValue(ctx, ctx->rt->current_stack_frame->cur_func),
                            JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
     return val;
  fail:
@@ -14822,8 +14944,8 @@ static int JS_IteratorClose(JSContext *ctx, JSValueConst enum_obj,
     int res;
 
     if (is_exception_pending) {
-        ex_obj = ctx->current_exception;
-        ctx->current_exception = JS_NULL;
+        ex_obj = ctx->rt->current_exception;
+        ctx->rt->current_exception = JS_NULL;
         res = -1;
     } else {
         ex_obj = JS_UNDEFINED;
@@ -15139,7 +15261,7 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
 /* only valid inside C functions */
 static JSValueConst JS_GetActiveFunction(JSContext *ctx)
 {
-    return ctx->current_stack_frame->cur_func;
+    return ctx->rt->current_stack_frame->cur_func;
 }
 
 static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf,
@@ -15231,6 +15353,13 @@ static int js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, vo
     return 0;
 }
 
+static const uint16_t func_kind_to_class_id[] = {
+    [JS_FUNC_NORMAL] = JS_CLASS_BYTECODE_FUNCTION,
+    [JS_FUNC_GENERATOR] = JS_CLASS_GENERATOR_FUNCTION,
+    [JS_FUNC_ASYNC] = JS_CLASS_ASYNC_FUNCTION,
+    [JS_FUNC_ASYNC_GENERATOR] = JS_CLASS_ASYNC_GENERATOR_FUNCTION,
+};
+
 static JSValue js_closure(JSContext *ctx, JSValue bfunc,
                           JSVarRef **cur_var_refs,
                           JSStackFrame *sf)
@@ -15238,12 +15367,6 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
     JSFunctionBytecode *b;
     JSValue func_obj;
     JSAtom name_atom;
-    static const uint16_t func_kind_to_class_id[] = {
-        [JS_FUNC_NORMAL] = JS_CLASS_BYTECODE_FUNCTION,
-        [JS_FUNC_GENERATOR] = JS_CLASS_GENERATOR_FUNCTION,
-        [JS_FUNC_ASYNC] = JS_CLASS_ASYNC_FUNCTION,
-        [JS_FUNC_ASYNC_GENERATOR] = JS_CLASS_ASYNC_GENERATOR_FUNCTION,
-    };
 
     b = JS_VALUE_GET_PTR(bfunc);
     func_obj = JS_NewObjectClass(ctx, func_kind_to_class_id[b->func_kind]);
@@ -15282,7 +15405,7 @@ static JSValue js_closure(JSContext *ctx, JSValue bfunc,
            object is created on the fly when first accessed */
         JS_SetConstructorBit(ctx, func_obj, TRUE);
         JS_DefineAutoInitProperty(ctx, func_obj, JS_ATOM_prototype,
-                                  js_instantiate_prototype, NULL,
+                                  JS_AUTOINIT_ID_PROTOTYPE, NULL,
                                   JS_PROP_WRITABLE);
     }
     return func_obj;
@@ -15435,6 +15558,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
                                   JSValueConst this_obj,
                                   int argc, JSValueConst *argv, int flags)
 {
+    JSRuntime *rt = ctx->rt;
     JSCFunctionType func;
     JSObject *p;
     JSStackFrame sf_s, *sf = &sf_s, *prev_sf;
@@ -15448,12 +15572,14 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     arg_count = p->u.cfunc.length;
 
     /* better to always check stack overflow */
-    if (js_check_stack_overflow(ctx, sizeof(arg_buf[0]) * arg_count))
+    if (js_check_stack_overflow(rt, sizeof(arg_buf[0]) * arg_count))
         return JS_ThrowStackOverflow(ctx);
 
-    prev_sf = ctx->current_stack_frame;
+    prev_sf = rt->current_stack_frame;
     sf->prev_frame = prev_sf;
-    ctx->current_stack_frame = sf;
+    rt->current_stack_frame = sf;
+    ctx = p->u.cfunc.realm; /* change the current realm */
+    
 #ifdef CONFIG_BIGNUM
     /* we only propagate the bignum mode as some runtime functions
        test it */
@@ -15563,7 +15689,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
         abort();
     }
 
-    ctx->current_stack_frame = sf->prev_frame;
+    rt->current_stack_frame = sf->prev_frame;
     return ret_val;
 }
 
@@ -15579,7 +15705,7 @@ static JSValue js_call_bound_function(JSContext *ctx, JSValueConst func_obj,
     p = JS_VALUE_GET_OBJ(func_obj);
     bf = p->u.bound_function;
     arg_count = bf->argc + argc;
-    if (js_check_stack_overflow(ctx, sizeof(JSValue) * arg_count))
+    if (js_check_stack_overflow(ctx->rt, sizeof(JSValue) * arg_count))
         return JS_ThrowStackOverflow(ctx);
     arg_buf = alloca(sizeof(JSValue) * arg_count);
     for(i = 0; i < bf->argc; i++) {
@@ -15608,7 +15734,7 @@ static no_inline __exception int __js_poll_interrupts(JSContext *ctx)
         if (rt->interrupt_handler(rt, rt->interrupt_opaque)) {
             /* XXX: should set a specific flag to avoid catching */
             JS_ThrowInternalError(ctx, "interrupted");
-            JS_SetUncatchableError(ctx, ctx->current_exception, TRUE);
+            JS_SetUncatchableError(ctx, ctx->rt->current_exception, TRUE);
             return -1;
         }
     }
@@ -15640,10 +15766,12 @@ typedef enum {
 #define FUNC_RET_YIELD_STAR 2
 
 /* argv[] is modified if (flags & JS_CALL_FLAG_COPY_ARGV) = 0. */
-static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
+static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                                JSValueConst this_obj, JSValueConst new_target,
                                int argc, JSValue *argv, int flags)
 {
+    JSRuntime *rt = caller_ctx->rt;
+    JSContext *ctx;
     JSObject *p;
     JSFunctionBytecode *b;
     JSStackFrame sf_s, *sf = &sf_s;
@@ -15675,7 +15803,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 #define BREAK           SWITCH(pc)
 #endif
 
-    if (js_poll_interrupts(ctx))
+    if (js_poll_interrupts(caller_ctx))
         return JS_EXCEPTION;
     if (unlikely(JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)) {
         if (flags & JS_CALL_FLAG_GENERATOR) {
@@ -15685,6 +15813,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             sf = &s->frame;
             p = JS_VALUE_GET_OBJ(sf->cur_func);
             b = p->u.func.function_bytecode;
+            ctx = b->realm;
             var_refs = p->u.func.var_refs;
             local_buf = arg_buf = sf->arg_buf;
             var_buf = sf->var_buf;
@@ -15692,8 +15821,8 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             sp = sf->cur_sp;
             sf->cur_sp = NULL; /* cur_sp is NULL if the function is running */
             pc = sf->cur_pc;
-            sf->prev_frame = ctx->current_stack_frame;
-            ctx->current_stack_frame = sf;
+            sf->prev_frame = rt->current_stack_frame;
+            rt->current_stack_frame = sf;
             if (s->throw_flag)
                 goto exception;
             else
@@ -15705,12 +15834,12 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     p = JS_VALUE_GET_OBJ(func_obj);
     if (unlikely(p->class_id != JS_CLASS_BYTECODE_FUNCTION)) {
         JSClassCall *call_func;
-        call_func = ctx->rt->class_array[p->class_id].call;
+        call_func = rt->class_array[p->class_id].call;
         if (!call_func) {
         not_a_function:
-            return JS_ThrowTypeError(ctx, "not a function");
+            return JS_ThrowTypeError(caller_ctx, "not a function");
         }
-        return call_func(ctx, func_obj, this_obj, argc,
+        return call_func(caller_ctx, func_obj, this_obj, argc,
                          (JSValueConst *)argv, flags);
     }
     b = p->u.func.function_bytecode;
@@ -15723,8 +15852,8 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
     alloca_size = sizeof(JSValue) * (arg_allocated_size + b->var_count +
                                      b->stack_size);
-    if (js_check_stack_overflow(ctx, alloca_size))
-        return JS_ThrowStackOverflow(ctx);
+    if (js_check_stack_overflow(rt, alloca_size))
+        return JS_ThrowStackOverflow(caller_ctx);
 
     sf->js_mode = b->js_mode;
     arg_buf = argv;
@@ -15738,7 +15867,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
         int n = min_int(argc, b->arg_count);
         arg_buf = local_buf;
         for(i = 0; i < n; i++)
-            arg_buf[i] = JS_DupValue(ctx, argv[i]);
+            arg_buf[i] = JS_DupValue(caller_ctx, argv[i]);
         for(; i < b->arg_count; i++)
             arg_buf[i] = JS_UNDEFINED;
         sf->arg_count = b->arg_count;
@@ -15753,8 +15882,10 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     stack_buf = var_buf + b->var_count;
     sp = stack_buf;
     pc = b->byte_code_buf;
-    sf->prev_frame = ctx->current_stack_frame;
-    ctx->current_stack_frame = sf;
+    sf->prev_frame = rt->current_stack_frame;
+    rt->current_stack_frame = sf;
+    ctx = b->realm; /* set the current realm */
+    
  restart:
     for(;;) {
         int call_argc;
@@ -16178,7 +16309,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             /* return TRUE if 'this' should be returned */
             if (!JS_IsObject(sp[-1])) {
                 if (!JS_IsUndefined(sp[-1])) {
-                    JS_ThrowTypeError(ctx, "derived class constructor must return an object or undefined");
+                    JS_ThrowTypeError(caller_ctx, "derived class constructor must return an object or undefined");
                     goto exception;
                 }
                 sp[0] = JS_TRUE;
@@ -16189,7 +16320,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_check_ctor):
             if (JS_IsUndefined(new_target)) {
-                JS_ThrowTypeError(ctx, "class constructors must be invoked with 'new'");
+                JS_ThrowTypeError(caller_ctx, "class constructors must be invoked with 'new'");
                 goto exception;
             }
             BREAK;
@@ -16673,7 +16804,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 pr = add_property(ctx, JS_VALUE_GET_OBJ(sp[-1]), atom,
                                   JS_PROP_WRITABLE | JS_PROP_VARREF);
                 if (!pr) {
-                    free_var_ref(ctx->rt, var_ref);
+                    free_var_ref(rt, var_ref);
                     goto exception;
                 }
                 pr->u.var_ref = var_ref;
@@ -16870,6 +17001,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             BREAK;
 
         CASE(OP_iterator_close):
+            /* iter_obj next catch_offset -> */
             sp--; /* drop the catch offset to avoid getting caught by exception */
             JS_FreeValue(ctx, sp[-1]); /* drop the next method */
             sp--;
@@ -16908,24 +17040,28 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
             {
                 JSValue ret, method;
                 int ret_flag;
-                method = JS_GetProperty(ctx, sp[-3], JS_ATOM_return);
+                sp--; /* remove the catch offset */
+                method = JS_GetProperty(ctx, sp[-2], JS_ATOM_return);
                 if (JS_IsException(method))
                     goto exception;
                 if (JS_IsUndefined(method) || JS_IsNull(method)) {
                     ret = JS_UNDEFINED;
                     ret_flag = TRUE;
                 } else {
-                    ret = JS_CallFree(ctx, method, sp[-3], 0, NULL);
+                    ret = JS_CallFree(ctx, method, sp[-2], 0, NULL);
                     if (JS_IsException(ret))
                         goto exception;
+                    if (!JS_IsObject(ret)) {
+                        JS_FreeValue(ctx, ret);
+                        JS_ThrowTypeErrorNotAnObject(ctx);
+                        goto exception;
+                    }
                     ret_flag = FALSE;
                 }
-                JS_FreeValue(ctx, sp[-3]);
                 JS_FreeValue(ctx, sp[-2]);
                 JS_FreeValue(ctx, sp[-1]);
-                sp[-3] = ret;
-                sp[-2] = JS_NewBool(ctx, ret_flag);
-                sp -= 1;
+                sp[-2] = ret;
+                sp[-1] = JS_NewBool(ctx, ret_flag);
             }
             BREAK;
 
@@ -16949,6 +17085,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                 BOOL ret_flag;
                 int flags;
                 flags = *pc++;
+                /* XXX: use another opcode such as OP_throw_var */
                 if (flags == 2) {
                     JS_ThrowTypeError(ctx, "iterator does not have a throw method");
                     goto exception;
@@ -17856,7 +17993,7 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
 
 #ifdef CONFIG_BIGNUM
         CASE(OP_mul_pow10):
-            if (ctx->rt->bigfloat_ops.mul_pow10(ctx, sp))
+            if (rt->bigfloat_ops.mul_pow10(ctx, sp))
                 goto exception;
             sp--;
             BREAK;
@@ -18101,14 +18238,14 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
         }
     }
  exception:
-    if (is_backtrace_needed(ctx, ctx->current_exception)) {
+    if (is_backtrace_needed(ctx, rt->current_exception)) {
         /* add the backtrace information now (it is not done
            before if the exception happens in a bytecode
            operation */
         sf->cur_pc = pc;
-        build_backtrace(ctx, ctx->current_exception, NULL, 0, 0);
+        build_backtrace(ctx, rt->current_exception, NULL, 0, 0);
     }
-    if (!JS_IsUncatchableError(ctx, ctx->current_exception)) {
+    if (!JS_IsUncatchableError(ctx, rt->current_exception)) {
         while (sp > stack_buf) {
             JSValue val = *--sp;
             JS_FreeValue(ctx, val);
@@ -18120,8 +18257,8 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
                     sp--;
                     JS_IteratorClose(ctx, sp[-1], TRUE);
                 } else {
-                    *sp++ = ctx->current_exception;
-                    ctx->current_exception = JS_NULL;
+                    *sp++ = rt->current_exception;
+                    rt->current_exception = JS_NULL;
                     pc = b->byte_code_buf + pos;
                     goto restart;
                 }
@@ -18140,14 +18277,14 @@ static JSValue JS_CallInternal(JSContext *ctx, JSValueConst func_obj,
     done:
         if (unlikely(!list_empty(&sf->var_ref_list))) {
             /* variable references reference the stack: must close them */
-            close_var_refs(ctx->rt, sf);
+            close_var_refs(rt, sf);
         }
         /* free the local variables and stack */
         for(pval = local_buf; pval < sp; pval++) {
             JS_FreeValue(ctx, *pval);
         }
     }
-    ctx->current_stack_frame = sf->prev_frame;
+    rt->current_stack_frame = sf->prev_frame;
     return ret_val;
 }
 
@@ -18167,24 +18304,62 @@ static JSValue JS_CallFree(JSContext *ctx, JSValue func_obj, JSValueConst this_o
     return res;
 }
 
-static JSValue js_get_prototype_from_ctor(JSContext *ctx, JSValueConst ctor,
-                                          JSValueConst def_proto)
+/* warning: the refcount of the context is not incremented. Return
+   NULL in case of exception (case of revoked proxy only) */
+static JSContext *JS_GetFunctionRealm(JSContext *ctx, JSValueConst func_obj)
 {
-    JSValue proto;
-    proto = JS_GetProperty(ctx, ctor, JS_ATOM_prototype);
-    if (JS_IsException(proto))
-        return proto;
-    if (!JS_IsObject(proto)) {
-        JS_FreeValue(ctx, proto);
-        proto = JS_DupValue(ctx, def_proto);
+    JSObject *p;
+    JSContext *realm;
+    
+    if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
+        return ctx;
+    p = JS_VALUE_GET_OBJ(func_obj);
+    switch(p->class_id) {
+    case JS_CLASS_C_FUNCTION:
+        realm = p->u.cfunc.realm;
+        break;
+    case JS_CLASS_BYTECODE_FUNCTION:
+    case JS_CLASS_GENERATOR_FUNCTION:
+    case JS_CLASS_ASYNC_FUNCTION:
+    case JS_CLASS_ASYNC_GENERATOR_FUNCTION:
+        {
+            JSFunctionBytecode *b;
+            b = p->u.func.function_bytecode;
+            realm = b->realm;
+        }
+        break;
+    case JS_CLASS_PROXY:
+        {
+            JSProxyData *s = p->u.opaque;
+            if (!s)
+                return ctx;
+            if (s->is_revoked) {
+                JS_ThrowTypeErrorRevokedProxy(ctx);
+                return NULL;
+            } else {
+                realm = JS_GetFunctionRealm(ctx, s->target);
+            }
+        }
+        break;
+    case JS_CLASS_BOUND_FUNCTION:
+        {
+            JSBoundFunction *bf = p->u.bound_function;
+            realm = JS_GetFunctionRealm(ctx, bf->func_obj);
+        }
+        break;
+    default:
+        realm = ctx;
+        break;
     }
-    return proto;
+    return realm;
 }
 
 static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
                                    int class_id)
 {
     JSValue proto, obj;
+    JSContext *realm;
+    
     if (JS_IsUndefined(ctor)) {
         proto = JS_DupValue(ctx, ctx->class_proto[class_id]);
     } else {
@@ -18193,14 +18368,10 @@ static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
             return proto;
         if (!JS_IsObject(proto)) {
             JS_FreeValue(ctx, proto);
-            /* check if revoked proxy */
-            {
-                JSProxyData *s = JS_GetOpaque(ctor, JS_CLASS_PROXY);
-                if (s && s->is_revoked)
-                    return JS_ThrowTypeErrorRevokedProxy(ctx);
-            }
-            /* XXX: should use the ctor realm instead of 'ctx' */
-            proto = JS_DupValue(ctx, ctx->class_proto[class_id]);
+            realm = JS_GetFunctionRealm(ctx, ctor);
+            if (!realm)
+                return JS_EXCEPTION;
+            proto = JS_DupValue(ctx, realm->class_proto[class_id]);
         }
     }
     obj = JS_NewObjectProtoClass(ctx, proto, class_id);
@@ -19709,7 +19880,7 @@ int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const
     backtrace_flags = 0;
     if (s->cur_func && s->cur_func->backtrace_barrier)
         backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
-    build_backtrace(ctx, ctx->current_exception, s->filename, s->line_num,
+    build_backtrace(ctx, ctx->rt->current_exception, s->filename, s->line_num,
                     backtrace_flags);
     return -1;
 }
@@ -20039,14 +20210,90 @@ static __exception int js_parse_regexp(JSParseState *s)
     return -1;
 }
 
+static __exception int ident_realloc(JSContext *ctx, char **pbuf, size_t *psize,
+                                     char *static_buf)
+{
+    char *buf, *new_buf;
+    size_t size, new_size;
+    
+    buf = *pbuf;
+    size = *psize;
+    if (size >= (SIZE_MAX / 3) * 2)
+        new_size = SIZE_MAX;
+    else
+        new_size = size + (size >> 1);
+    if (buf == static_buf) {
+        new_buf = js_malloc(ctx, new_size);
+        if (!new_buf)
+            return -1;
+        memcpy(new_buf, buf, size);
+    } else {
+        new_buf = js_realloc(ctx, buf, new_size);
+        if (!new_buf)
+            return -1;
+    }
+    *pbuf = new_buf;
+    *psize = new_size;
+    return 0;
+}
+
+/* 'c' is the first character. Return JS_ATOM_NULL in case of error */
+static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
+                          BOOL *pident_has_escape, int c, BOOL is_private)
+{
+    const uint8_t *p, *p1;
+    char ident_buf[128], *buf;
+    size_t ident_size, ident_pos;
+    JSAtom atom;
+    
+    p = *pp;
+    buf = ident_buf;
+    ident_size = sizeof(ident_buf);
+    ident_pos = 0;
+    if (is_private)
+        buf[ident_pos++] = '#';
+    for(;;) {
+        p1 = p;
+        
+        if (c < 128) {
+            buf[ident_pos++] = c;
+        } else {
+            ident_pos += unicode_to_utf8((uint8_t*)buf + ident_pos, c);
+        }
+        c = *p1++;
+        if (c == '\\' && *p1 == 'u') {
+            c = lre_parse_escape(&p1, TRUE);
+            *pident_has_escape = TRUE;
+        } else if (c >= 128) {
+            c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
+        }
+        if (!lre_js_is_ident_next(c))
+            break;
+        p = p1;
+        if (unlikely(ident_pos >= ident_size - UTF8_CHAR_LEN_MAX)) {
+            if (ident_realloc(s->ctx, &buf, &ident_size, ident_buf)) {
+                atom = JS_ATOM_NULL;
+                goto done;
+            }
+        }
+    }
+    atom = JS_NewAtomLen(s->ctx, buf, ident_pos);
+ done:
+    if (unlikely(buf != ident_buf))
+        js_free(s->ctx, buf);
+    *pp = p;
+    return atom;
+}
+
+
 static __exception int next_token(JSParseState *s)
 {
     const uint8_t *p;
     int c;
-    char buf[4096], *q;
     BOOL ident_has_escape;
-
-    if (js_check_stack_overflow(s->ctx, 0)) {
+    JSAtom atom;
+    
+    if (js_check_stack_overflow(s->ctx->rt, 0)) {
         return js_parse_error(s, "stack overflow");
     }
     
@@ -20128,6 +20375,8 @@ static __exception int next_token(JSParseState *s)
                     c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
                     if (c == CP_LS || c == CP_PS) {
                         s->got_lf = TRUE; /* considered as LF for ASI */
+                    } else if (c == -1) {
+                        p++; /* skip invalid UTF-8 */
                     }
                 } else {
                     p++;
@@ -20146,8 +20395,11 @@ static __exception int next_token(JSParseState *s)
                 if (*p >= 0x80) {
                     c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
                     /* LS or PS are considered as line terminator */
-                    if (c == CP_LS || c == CP_PS)
+                    if (c == CP_LS || c == CP_PS) {
                         break;
+                    } else if (c == -1) {
+                        p++; /* skip invalid UTF-8 */
+                    }
                 } else {
                     p++;
                 }
@@ -20183,33 +20435,10 @@ static __exception int next_token(JSParseState *s)
         p++;
         ident_has_escape = FALSE;
     has_ident:
-        q = buf;
-        for(;;) {
-            const uint8_t *p1 = p;
-
-            if (c < 128) {
-                *q++ = c;
-            } else {
-                q += unicode_to_utf8((uint8_t*)q, c);
-            }
-            c = *p1++;
-            if (c == '\\' && *p1 == 'u') {
-                c = lre_parse_escape(&p1, TRUE);
-                ident_has_escape = TRUE;
-            } else if (c >= 128) {
-                c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
-            }
-            /* XXX: check if c >= 0 and c <= 0x10FFFF */
-            if (!lre_js_is_ident_next(c))
-                break;
-            p = p1;
-            if ((q - buf) >= sizeof(buf) - UTF8_CHAR_LEN_MAX) {
-                js_parse_error(s, "identifier too long");
-                goto fail;
-            }
-        }
-        *q = '\0';
-        s->token.u.ident.atom = JS_NewAtomLen(s->ctx, buf, q - buf);
+        atom = parse_ident(s, &p, &ident_has_escape, c, FALSE);
+        if (atom == JS_ATOM_NULL)
+            goto fail;
+        s->token.u.ident.atom = atom;
         s->token.u.ident.has_escape = ident_has_escape;
         s->token.u.ident.is_reserved = FALSE;
         if (s->token.u.ident.atom <= JS_ATOM_LAST_KEYWORD ||
@@ -20243,8 +20472,6 @@ static __exception int next_token(JSParseState *s)
         {
             const uint8_t *p1;
             p++;
-            q = buf;
-            *q++ = '#';
             p1 = p;
             c = *p1++;
             if (c == '\\' && *p1 == 'u') {
@@ -20257,31 +20484,11 @@ static __exception int next_token(JSParseState *s)
                 goto fail;
             }
             p = p1;
-            for(;;) {
-                if (c < 128) {
-                    *q++ = c;
-                } else {
-                    q += unicode_to_utf8((uint8_t*)q, c);
-                }
-                p1 = p;
-                c = *p1++;
-                if (c == '\\' && *p1 == 'u') {
-                    c = lre_parse_escape(&p1, TRUE);
-                    ident_has_escape = TRUE;
-                } else if (c >= 128) {
-                    c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
-                }
-                /* XXX: check if c >= 0 and c <= 0x10FFFF */
-                if (!lre_js_is_ident_next(c))
-                    break;
-                p = p1;
-                if ((q - buf) >= sizeof(buf) - UTF8_CHAR_LEN_MAX) {
-                    js_parse_error(s, "private name too long");
-                    goto fail;
-                }
-            }
-            *q = '\0';
-            s->token.u.ident.atom = JS_NewAtomLen(s->ctx, buf, q - buf);
+            ident_has_escape = FALSE; /* not used */
+            atom = parse_ident(s, &p, &ident_has_escape, c, TRUE);
+            if (atom == JS_ATOM_NULL)
+                goto fail;
+            s->token.u.ident.atom = atom;
             s->token.val = TOK_PRIVATE_NAME;
         }
         break;
@@ -22175,16 +22382,25 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
             continue;
         }
         is_static = (s->token.val == TOK_STATIC);
+        prop_type = -1;
         if (is_static) {
             if (next_token(s))
                 goto fail;
+            /* allow "static" field name */
+            if (s->token.val == ';' || s->token.val == '=') {
+                is_static = FALSE;
+                name = JS_DupAtom(ctx, JS_ATOM_static);
+                prop_type = PROP_TYPE_IDENT;
+            }
         }
         if (is_static)
             emit_op(s, OP_swap);
         start_ptr = s->token.ptr;
-        prop_type = js_parse_property_name(s, &name, TRUE, FALSE, TRUE);
-        if (prop_type < 0)
-            goto fail;
+        if (prop_type < 0) {
+            prop_type = js_parse_property_name(s, &name, TRUE, FALSE, TRUE);
+            if (prop_type < 0)
+                goto fail;
+        }
         is_private = prop_type & PROP_TYPE_PRIVATE;
         prop_type &= ~PROP_TYPE_PRIVATE;
         
@@ -22980,7 +23196,7 @@ static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
     return js_parse_error(s, "duplicate parameter names not allowed in this context");
 }
 
-static JSAtom js_parse_destructing_var(JSParseState *s, int tok, int is_arg)
+static JSAtom js_parse_destructuring_var(JSParseState *s, int tok, int is_arg)
 {
     JSAtom name;
 
@@ -23002,7 +23218,7 @@ static JSAtom js_parse_destructing_var(JSParseState *s, int tok, int is_arg)
     return JS_ATOM_NULL;
 }
 
-static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
+static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                                         int hasval, int has_ellipsis,
                                         BOOL allow_initializer)
 {
@@ -23055,7 +23271,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                 if (next_token(s))
                     return -1;
                 if (tok) {
-                    var_name = js_parse_destructing_var(s, tok, is_arg);
+                    var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         return -1;
                     opcode = OP_scope_get_var;
@@ -23119,7 +23335,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                         emit_op(s, OP_get_field2);
                         emit_u32(s, prop_name);
                     }
-                    if (js_parse_destructing_element(s, tok, is_arg, TRUE, -1, TRUE))
+                    if (js_parse_destructuring_element(s, tok, is_arg, TRUE, -1, TRUE))
                         return -1;
                     if (s->token.val == '}')
                         break;
@@ -23152,7 +23368,7 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                     emit_op(s, OP_dup);
                 }
                 if (tok) {
-                    var_name = js_parse_destructing_var(s, tok, is_arg);
+                    var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         goto prop_error;
                 } else {
@@ -23316,13 +23532,13 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
                     emit_u8(s, 0);
                     emit_op(s, OP_drop);
                 }
-                if (js_parse_destructing_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 var_name = JS_ATOM_NULL;
                 enum_depth = 0;
                 if (tok) {
-                    var_name = js_parse_destructing_var(s, tok, is_arg);
+                    var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         goto var_error;
                     if (js_define_var(s, var_name, tok))
@@ -23393,7 +23609,13 @@ static int js_parse_destructing_element(JSParseState *s, int tok, int is_arg,
         emit_goto(s, OP_goto, label_assign);
         emit_label(s, label_done);
     } else {
-        assert(hasval);
+        /* normally hasval is true except if
+           js_parse_skip_parens_token() was wrong in the parsing */
+        //        assert(hasval);
+        if (!hasval) {
+            js_parse_error(s, "too complicated destructuring expression");
+            return -1;
+        }
         /* remove test and decrement label ref count */
         memset(s->cur_func->byte_code.buf + start_addr, OP_nop,
                assign_addr - start_addr);
@@ -23515,7 +23737,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 backtrace_flags = 0;
                 if (s->cur_func && s->cur_func->backtrace_barrier)
                     backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
-                build_backtrace(s->ctx, s->ctx->current_exception,
+                build_backtrace(s->ctx, s->ctx->rt->current_exception,
                                 s->filename, s->token.line_num,
                                 backtrace_flags);
                 return -1;
@@ -23633,7 +23855,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         {
             int skip_bits;
             if (js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
-                if (js_parse_destructing_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 if (s->token.val == '{') {
@@ -24851,6 +25073,8 @@ static void emit_return(JSParseState *s, BOOL hasval)
             label_return = -1;
         }
 
+        /* XXX: if this is not initialized, should throw the
+           ReferenceError in the caller realm */
         emit_op(s, OP_scope_get_var);
         emit_atom(s, JS_ATOM_this);
         emit_u16(s, 0);
@@ -24977,7 +25201,7 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
             if ((s->token.val == '[' || s->token.val == '{')
             &&  js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
                 emit_op(s, OP_undefined);
-                if (js_parse_destructing_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                     return -1;
             } else {
                 return js_parse_error(s, "variable name expected");
@@ -25106,7 +25330,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
 
         if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
             if (s->token.val == '[' || s->token.val == '{') {
-                if (js_parse_destructing_element(s, tok, 0, TRUE, -1, FALSE))
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, -1, FALSE))
                     return -1;
                 has_destructuring = TRUE;
             } else {
@@ -25132,7 +25356,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
         int skip_bits;
         if ((s->token.val == '[' || s->token.val == '{')
         &&  ((tok1 = js_parse_skip_parens_token(s, &skip_bits, FALSE)) == TOK_IN || tok1 == TOK_OF)) {
-            if (js_parse_destructing_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+            if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                 return -1;
         } else {
             int lvalue_label, depth;
@@ -25815,7 +26039,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                     if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
                         if (s->token.val == '[' || s->token.val == '{') {
                             /* XXX: TOK_LET is not completely correct */
-                            if (js_parse_destructing_element(s, TOK_LET, 0, TRUE, -1, TRUE))
+                            if (js_parse_destructuring_element(s, TOK_LET, 0, TRUE, -1, TRUE))
                                 goto fail;
                         } else {
                             js_parse_error(s, "identifier expected");
@@ -26038,6 +26262,25 @@ static JSModuleDef *js_new_module_def(JSContext *ctx, JSAtom name)
     return m;
 }
 
+static void js_mark_module_def(JSRuntime *rt, JSModuleDef *m,
+                               JS_MarkFunc *mark_func)
+{
+    int i;
+
+    for(i = 0; i < m->export_entries_count; i++) {
+        JSExportEntry *me = &m->export_entries[i];
+        if (me->export_type == JS_EXPORT_TYPE_LOCAL &&
+            me->u.local.var_ref) {
+            mark_func(rt, &me->u.local.var_ref->header);
+        }
+    }
+
+    JS_MarkValue(rt, m->module_ns, mark_func);
+    JS_MarkValue(rt, m->func_obj, mark_func);
+    JS_MarkValue(rt, m->eval_exception, mark_func);
+    JS_MarkValue(rt, m->meta_obj, mark_func);
+}
+
 static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
 {
     int i;
@@ -26769,7 +27012,7 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
             /* the exported namespace must be created on demand */
             if (JS_DefineAutoInitProperty(ctx, obj,
                                           en->export_name,
-                                          js_module_ns_autoinit,
+                                          JS_AUTOINIT_ID_MODULE_NS,
                                           en->u.module, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
                 goto fail;
             break;
@@ -27075,7 +27318,7 @@ static JSAtom js_get_script_or_module_name(JSContext *ctx)
     /* XXX: currently we just use the filename of the englobing
        function. It does not work for eval(). Need to add a
        ScriptOrModule info in JSFunctionBytecode */
-    sf = ctx->current_stack_frame;
+    sf = ctx->rt->current_stack_frame;
     assert(sf != NULL);
     assert(JS_VALUE_GET_TAG(sf->cur_func) == JS_TAG_OBJECT);
     p = JS_VALUE_GET_OBJ(sf->cur_func);
@@ -27125,22 +27368,23 @@ static JSValue js_import_meta(JSContext *ctx)
     return JS_GetImportMeta(ctx, m);
 }
 
-static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+static JSValue js_dynamic_import_job(JSContext *ctx,
+                                     int argc, JSValueConst *argv)
 {
+    JSValueConst *resolving_funcs = argv;
+    JSValueConst basename_val = argv[2];
+    JSValueConst specifier = argv[3];
     JSModuleDef *m;
-    JSAtom basename, filename;
-    JSValue promise, resolving_funcs[2];
+    JSAtom basename = JS_ATOM_NULL, filename;
     JSValue specifierString, ret, func_obj, err, ns;
-    
-    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
-    if (JS_IsException(promise))
-        return promise;
-    
-    basename = js_get_script_or_module_name(ctx);
-    if (basename == JS_ATOM_NULL) {
+
+    if (!JS_IsString(basename_val)) {
         JS_ThrowTypeError(ctx, "no function filename for import()");
         goto exception;
     }
+    basename = JS_ValueToAtom(ctx, basename_val);
+    if (basename == JS_ATOM_NULL)
+        goto exception;
 
     specifierString = JS_ToString(ctx, specifier);
     if (JS_IsException(specifierString))
@@ -27177,16 +27421,47 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
                    1, (JSValueConst *)&ns);
     JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
     JS_FreeValue(ctx, ns);
-    JS_FreeValue(ctx, resolving_funcs[0]);
-    JS_FreeValue(ctx, resolving_funcs[1]);
-    return promise;
-
+    JS_FreeAtom(ctx, basename);
+    return JS_UNDEFINED;
  exception:
+
     err = JS_GetException(ctx);
     ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
                    1, (JSValueConst *)&err);
     JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
     JS_FreeValue(ctx, err);
+    JS_FreeAtom(ctx, basename);
+    return JS_UNDEFINED;
+}
+
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+{
+    JSAtom basename;
+    JSValue promise, resolving_funcs[2], basename_val;
+    JSValueConst args[4];
+
+    basename = js_get_script_or_module_name(ctx);
+    if (basename == JS_ATOM_NULL)
+        basename_val = JS_NULL;
+    else
+        basename_val = JS_AtomToValue(ctx, basename);
+    if (JS_IsException(basename_val))
+        return basename_val;
+    
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise)) {
+        JS_FreeValue(ctx, basename_val);
+        return promise;
+    }
+
+    args[0] = resolving_funcs[0];
+    args[1] = resolving_funcs[1];
+    args[2] = basename_val;
+    args[3] = specifier;
+    
+    JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
+
+    JS_FreeValue(ctx, basename_val);
     JS_FreeValue(ctx, resolving_funcs[0]);
     JS_FreeValue(ctx, resolving_funcs[1]);
     return promise;
@@ -27241,7 +27516,7 @@ static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
     if (JS_IsException(ret_val)) {
         /* save the thrown exception value */
         m->eval_has_exception = TRUE;
-        m->eval_exception = JS_DupValue(ctx, ctx->current_exception);
+        m->eval_exception = JS_DupValue(ctx, ctx->rt->current_exception);
     }
     m->eval_mark = FALSE;
     m->evaluated = TRUE;
@@ -27521,6 +27796,10 @@ static __exception int js_parse_import(JSParseState *s)
                 return js_parse_error(s, "expecting 'as'");
             if (next_token(s))
                 return -1;
+            if (!token_is_ident(s->token.val)) {
+                js_parse_error(s, "identifier expected");
+                return -1;
+            }
             local_name = JS_DupAtom(ctx, s->token.u.ident.atom);
             import_name = JS_ATOM__star_;
             if (next_token(s))
@@ -31469,6 +31748,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     b->super_allowed = fd->super_allowed;
     b->arguments_allowed = fd->arguments_allowed;
     b->backtrace_barrier = fd->backtrace_barrier;
+    b->realm = JS_DupContext(ctx);
 
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
     
@@ -31515,6 +31795,8 @@ static void free_function_bytecode(JSRuntime *rt, JSFunctionBytecode *b)
         JSClosureVar *cv = &b->closure_var[i];
         JS_FreeAtomRT(rt, cv->var_name);
     }
+    if (b->realm)
+        JS_FreeContext(b->realm);
 
     JS_FreeAtomRT(rt, b->func_name);
     if (b->has_debug) {
@@ -31910,7 +32192,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     emit_op(s, OP_get_arg);
                     emit_u16(s, idx);
                 }
-                if (js_parse_destructing_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
+                if (js_parse_destructuring_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
                     goto fail;
             } else if (s->token.val == TOK_IDENT) {
                 if (s->token.u.ident.is_reserved) {
@@ -32309,8 +32591,11 @@ static void skip_shebang(JSParseState *s)
                 break;
             } else if (*p >= 0x80) {
                 c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
-                if (c == CP_LS || c == CP_PS)
+                if (c == CP_LS || c == CP_PS) {
                     break;
+                } else if (c == -1) {
+                    p++; /* skip invalid UTF-8 */
+                }
             } else {
                 p++;
             }
@@ -32340,7 +32625,7 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
     m = NULL;
     if (eval_type == JS_EVAL_TYPE_DIRECT) {
         JSObject *p;
-        sf = ctx->current_stack_frame;
+        sf = ctx->rt->current_stack_frame;
         assert(sf != NULL);
         assert(JS_VALUE_GET_TAG(sf->cur_func) == JS_TAG_OBJECT);
         p = JS_VALUE_GET_OBJ(sf->cur_func);
@@ -33907,6 +34192,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
                 bc_read_trace(s, "}\n");
             }
             bc_read_trace(s, "}\n");
+            b->realm = JS_DupContext(ctx);
         }
         break;
     case BC_TAG_MODULE:
@@ -34095,8 +34381,9 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
  fail:
     if (m) {
         js_free_module_def(ctx, m);
+    } else {
+        JS_FreeValue(ctx, obj);
     }
-    JS_FreeValue(ctx, obj);
     return JS_EXCEPTION;
 }
 
@@ -34336,7 +34623,7 @@ void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
         case JS_DEF_OBJECT:
             prop_flags = JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE | (e->prop_flags & JS_PROP_ENUMERABLE);
             JS_DefineAutoInitProperty(ctx, obj, atom,
-                                      JS_InstantiateFunctionListItem,
+                                      JS_AUTOINIT_ID_PROP,
                                       (void *)e, prop_flags);
             break;
         case JS_DEF_PROP_INT32:
@@ -35816,15 +36103,21 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
         goto fail1;
     if (!JS_IsUndefined(new_target)) {
         /* set the prototype */
-        proto = js_get_prototype_from_ctor(ctx, new_target, JS_UNDEFINED);
+        proto = JS_GetProperty(ctx, new_target, JS_ATOM_prototype);
         if (JS_IsException(proto))
             goto fail1;
-        if (!JS_IsUndefined(proto)) {
-            ret = JS_SetPrototypeInternal(ctx, obj, proto, TRUE);
+        if (!JS_IsObject(proto)) {
+            JSContext *realm;
             JS_FreeValue(ctx, proto);
-            if (ret < 0)
+            realm = JS_GetFunctionRealm(ctx, new_target);
+            if (!realm)
                 goto fail1;
+            proto = JS_DupValue(ctx, realm->class_proto[func_kind_to_class_id[func_kind]]);
         }
+        ret = JS_SetPrototypeInternal(ctx, obj, proto, TRUE);
+        JS_FreeValue(ctx, proto);
+        if (ret < 0)
+            goto fail1;
     }
     return obj;
 
@@ -36073,29 +36366,90 @@ static const JSCFunctionListEntry js_function_proto_funcs[] = {
 
 /* Error class */
 
+static JSValue iterator_to_array(JSContext *ctx, JSValueConst items)
+{
+    JSValue iter, next_method = JS_UNDEFINED;
+    JSValue v, r = JS_UNDEFINED;
+    int64_t k;
+    BOOL done;
+    
+    iter = JS_GetIterator(ctx, items, FALSE);
+    if (JS_IsException(iter))
+        goto exception;
+    next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        goto exception;
+    r = JS_NewArray(ctx);
+    if (JS_IsException(r))
+        goto exception;
+    for (k = 0;; k++) {
+        v = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
+        if (JS_IsException(v))
+            goto exception_close;
+        if (done)
+            break;
+        if (JS_DefinePropertyValueInt64(ctx, r, k, v,
+                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0)
+            goto exception_close;
+    }
+ done:
+    JS_FreeValue(ctx, next_method);
+    JS_FreeValue(ctx, iter);
+    return r;
+ exception_close:
+    JS_IteratorClose(ctx, iter, TRUE);
+ exception:
+    JS_FreeValue(ctx, r);
+    r = JS_EXCEPTION;
+    goto done;
+}
+
 static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
                                     int argc, JSValueConst *argv, int magic)
 {
     JSValue obj, msg, proto;
-    JSValueConst proto1;
+    JSValueConst message;
 
     if (JS_IsUndefined(new_target))
         new_target = JS_GetActiveFunction(ctx);
-    if (magic < 0) {
-        proto1 = ctx->class_proto[JS_CLASS_ERROR];
-    } else {
-        proto1 = ctx->native_error_proto[magic];
-    }
-    proto = js_get_prototype_from_ctor(ctx, new_target, proto1);
+    proto = JS_GetProperty(ctx, new_target, JS_ATOM_prototype);
     if (JS_IsException(proto))
         return proto;
+    if (!JS_IsObject(proto)) {
+        JSContext *realm;
+        JSValueConst proto1;
+        
+        JS_FreeValue(ctx, proto);
+        realm = JS_GetFunctionRealm(ctx, new_target);
+        if (!realm)
+            return JS_EXCEPTION;
+        if (magic < 0) {
+            proto1 = realm->class_proto[JS_CLASS_ERROR];
+        } else {
+            proto1 = realm->native_error_proto[magic];
+        }
+        proto = JS_DupValue(ctx, proto1);
+    }
     obj = JS_NewObjectProtoClass(ctx, proto, JS_CLASS_ERROR);
     JS_FreeValue(ctx, proto);
     if (JS_IsException(obj))
         return obj;
-    if (!JS_IsUndefined(argv[0])) {
-        msg = JS_ToString(ctx, argv[0]);
+    if (magic == JS_AGGREGATE_ERROR) {
+        JSObject *p;
+        JSValue error_list = iterator_to_array(ctx, argv[0]);
+        if (JS_IsException(error_list))
+            goto exception;
+        p = JS_VALUE_GET_OBJ(obj);
+        p->u.object_data = error_list;
+        message = argv[1];
+    } else {
+        message = argv[0];
+    }
+
+    if (!JS_IsUndefined(message)) {
+        msg = JS_ToString(ctx, message);
         if (unlikely(JS_IsException(msg))) {
+        exception:
             JS_FreeValue(ctx, obj);
             return JS_EXCEPTION;
         }
@@ -36142,6 +36496,58 @@ static const JSCFunctionListEntry js_error_proto_funcs[] = {
     JS_PROP_STRING_DEF("message", "", JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE ),
 };
 
+/* AggregateError */
+
+/* used by C code. 'errors' must be a fast array. */
+static JSValue js_aggregate_error_constructor(JSContext *ctx,
+                                              JSValueConst errors)
+{
+    JSValue obj;
+    JSObject *p;
+    
+    obj = JS_NewObjectProtoClass(ctx,
+                                 ctx->native_error_proto[JS_AGGREGATE_ERROR],
+                                 JS_CLASS_ERROR);
+    if (JS_IsException(obj))
+        return obj;
+    p = JS_VALUE_GET_OBJ(obj);
+    p->u.object_data = JS_DupValue(ctx, errors);
+    return obj;
+}
+
+static JSValue js_aggregate_error_errors(JSContext *ctx, JSValueConst this_val)
+{
+    JSObject *p;
+    JSValue r, *arr;
+    uint32_t len, i;
+    
+    if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
+        goto invalid_type;
+    p = JS_VALUE_GET_OBJ(this_val);
+    if (p->class_id != JS_CLASS_ERROR)
+        goto invalid_type;
+    if (!js_get_fast_array(ctx, p->u.object_data, &arr, &len)) {
+    invalid_type:
+        return JS_ThrowTypeError(ctx, "not an AggregateError");
+    }
+    r = JS_NewArray(ctx);
+    if (JS_IsException(r))
+        goto exception;
+    for(i = 0; i < len; i++) {
+        if (JS_DefinePropertyValueInt64(ctx, r, i, JS_DupValue(ctx, arr[i]),
+                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0)
+            goto exception;
+    }
+    return r;
+ exception:
+    JS_FreeValue(ctx, r);
+    return JS_EXCEPTION;
+}
+
+static const JSCFunctionListEntry js_aggregate_error_proto_funcs[] = {
+    JS_CGETSET_DEF("errors", js_aggregate_error_errors, NULL),
+};
+
 /* Array */
 
 static int JS_CopySubArray(JSContext *ctx,
@@ -36367,22 +36773,47 @@ static JSValue js_get_this(JSContext *ctx,
 static JSValue JS_ArraySpeciesCreate(JSContext *ctx, JSValueConst obj,
                                      JSValueConst len_val)
 {
-    JSValue ctor, ret;
+    JSValue ctor, ret, species;
     int res;
-
+    JSContext *realm;
+    
     res = JS_IsArray(ctx, obj);
     if (res < 0)
         return JS_EXCEPTION;
     if (!res)
         return js_array_constructor(ctx, JS_UNDEFINED, 1, &len_val);
-    ctor = JS_SpeciesConstructor(ctx, obj, JS_UNDEFINED);
+    ctor = JS_GetProperty(ctx, obj, JS_ATOM_constructor);
     if (JS_IsException(ctor))
-        return JS_EXCEPTION;
-    if (JS_IsUndefined(ctor))
+        return ctor;
+    if (JS_IsConstructor(ctx, ctor)) {
+        /* legacy web compatibility */
+        realm = JS_GetFunctionRealm(ctx, ctor);
+        if (!realm) {
+            JS_FreeValue(ctx, ctor);
+            return JS_EXCEPTION;
+        }
+        if (realm != ctx &&
+            js_same_value(ctx, ctor, realm->array_ctor)) {
+            JS_FreeValue(ctx, ctor);
+            ctor = JS_UNDEFINED;
+        }
+    }
+    if (JS_IsObject(ctor)) {
+        species = JS_GetProperty(ctx, ctor, JS_ATOM_Symbol_species);
+        JS_FreeValue(ctx, ctor);
+        if (JS_IsException(species))
+            return species;
+        ctor = species;
+        if (JS_IsNull(ctor))
+            ctor = JS_UNDEFINED;
+    }
+    if (JS_IsUndefined(ctor)) {
         return js_array_constructor(ctx, JS_UNDEFINED, 1, &len_val);
-    ret = JS_CallConstructor(ctx, ctor, 1, &len_val);
-    JS_FreeValue(ctx, ctor);
-    return ret;
+    } else {
+        ret = JS_CallConstructor(ctx, ctor, 1, &len_val);
+        JS_FreeValue(ctx, ctor);
+        return ret;
+    }
 }
 
 static const JSCFunctionListEntry js_array_funcs[] = {
@@ -36435,7 +36866,7 @@ static JSValue js_array_concat(JSContext *ctx, JSValueConst this_val,
         if (res) {
             if (js_get_length64(ctx, &len, e))
                 goto exception;
-            if (n + len >= MAX_SAFE_INTEGER) {
+            if (n + len > MAX_SAFE_INTEGER) {
                 JS_ThrowTypeError(ctx, "Array loo long");
                 goto exception;
             }
@@ -38221,14 +38652,31 @@ static int js_string_define_own_property(JSContext *ctx,
                                          JSValueConst setter, int flags)
 {
     uint32_t idx;
-
+    JSObject *p;
+    JSString *p1, *p2;
+    
     if (__JS_AtomIsTaggedInt(prop)) {
         idx = __JS_AtomToUInt32(prop);
-        if (idx >= js_string_obj_get_length(ctx, this_obj))
+        p = JS_VALUE_GET_OBJ(this_obj);
+        if (JS_VALUE_GET_TAG(p->u.object_data) != JS_TAG_STRING)
+            goto def;
+        p1 = JS_VALUE_GET_STRING(p->u.object_data);
+        if (idx >= p1->len)
             goto def;
         if (!check_define_prop_flags(JS_PROP_ENUMERABLE, flags))
-            return JS_ThrowTypeErrorOrFalse(ctx, flags, "property is not configurable");
-        /* XXX: should check if same value is configured */
+            goto fail;
+        /* check that the same value is configured */
+        if (flags & JS_PROP_HAS_VALUE) {
+            if (JS_VALUE_GET_TAG(val) != JS_TAG_STRING)
+                goto fail;
+            p2 = JS_VALUE_GET_STRING(val);
+            if (p2->len != 1)
+                goto fail;
+            if (string_get(p1, idx) != string_get(p2, 0)) {
+            fail:
+                return JS_ThrowTypeErrorOrFalse(ctx, flags, "property is not configurable");
+            }
+        }
         return TRUE;
     } else {
     def:
@@ -38578,12 +39026,14 @@ static int string_indexof(JSString *p1, JSString *p2, int from)
     return -1;
 }
 
-static int string_advance_index(JSString *p, int index, BOOL unicode)
+static int64_t string_advance_index(JSString *p, int64_t index, BOOL unicode)
 {
-    if (!unicode || (unsigned)index >= p->len || !p->is_wide_char) {
+    if (!unicode || index >= p->len || !p->is_wide_char) {
         index++;
     } else {
-        string_getc(p, &index);
+        int index32 = (int)index;
+        string_getc(p, &index32);
+        index = index32;
     }
     return index;
 }
@@ -38930,7 +39380,7 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
         replacer = JS_GetProperty(ctx, searchValue, JS_ATOM_Symbol_replace);
         if (JS_IsException(replacer))
             return JS_EXCEPTION;
-        if (!JS_IsUndefined(replacer)) {
+        if (!JS_IsUndefined(replacer) && !JS_IsNull(replacer)) {
             args[0] = O;
             args[1] = replaceValue;
             return JS_CallFree(ctx, replacer, searchValue, 2, args);
@@ -40162,6 +40612,20 @@ static JSValue js___date_getTimezoneOffset(JSContext *ctx, JSValueConst this_val
         return JS_NewInt32(ctx, getTimezoneOffset((int64_t)dd));
 }
 
+static JSValue js_get_prototype_from_ctor(JSContext *ctx, JSValueConst ctor,
+                                          JSValueConst def_proto)
+{
+    JSValue proto;
+    proto = JS_GetProperty(ctx, ctor, JS_ATOM_prototype);
+    if (JS_IsException(proto))
+        return proto;
+    if (!JS_IsObject(proto)) {
+        JS_FreeValue(ctx, proto);
+        proto = JS_DupValue(ctx, def_proto);
+    }
+    return proto;
+}
+
 /* create a new date object */
 static JSValue js___date_create(JSContext *ctx, JSValueConst this_val,
                                 int argc, JSValueConst *argv)
@@ -40531,13 +40995,14 @@ static JSValue js_regexp_get_flag(JSContext *ctx, JSValueConst this_val, int mas
     if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
-    if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_REGEXP]))
-        return JS_UNDEFINED;
-
-    re = js_get_regexp(ctx, this_val, TRUE);
-    if (!re)
-        return JS_EXCEPTION;
-
+    re = js_get_regexp(ctx, this_val, FALSE);
+    if (!re) {
+        if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_REGEXP]))
+            return JS_UNDEFINED;
+        else
+            return JS_ThrowTypeErrorInvalidClass(ctx, JS_CLASS_REGEXP);
+    }
+    
     flags = lre_get_flags(re->bytecode->u.str8);
     return JS_NewBool(ctx, (flags & mask) != 0);
 }
@@ -40614,7 +41079,7 @@ static JSValue js_regexp_toString(JSContext *ctx, JSValueConst this_val,
 BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size)
 {
     JSContext *ctx = opaque;
-    return js_check_stack_overflow(ctx, alloca_size);
+    return js_check_stack_overflow(ctx->rt, alloca_size);
 }
 
 void *lre_realloc(void *opaque, void *ptr, size_t size)
@@ -40753,7 +41218,7 @@ static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
-/* delete partions of a string that match a given regex */
+/* delete portions of a string that match a given regex */
 static JSValue JS_RegExpDelete(JSContext *ctx, JSValueConst this_val, JSValueConst arg)
 {
     JSRegExp *re = js_get_regexp(ctx, this_val, TRUE);
@@ -40952,9 +41417,7 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
                                     JS_GetProperty(ctx, rx, JS_ATOM_lastIndex)) < 0)
                     goto exception;
                 p = JS_VALUE_GET_STRING(S);
-                nextIndex = thisIndex + 1;
-                if (thisIndex < p->len)
-                    nextIndex = string_advance_index(p, thisIndex, fullUnicode);
+                nextIndex = string_advance_index(p, thisIndex, fullUnicode);
                 if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, JS_NewInt64(ctx, nextIndex)) < 0)
                     goto exception;
             }
@@ -41043,7 +41506,7 @@ static JSValue js_regexp_string_iterator_next(JSContext *ctx,
             sp = JS_VALUE_GET_STRING(S);
             nextIndex = string_advance_index(sp, thisIndex, it->unicode);
             if (JS_SetProperty(ctx, R, JS_ATOM_lastIndex,
-                               JS_NewInt32(ctx, nextIndex)) < 0)
+                               JS_NewInt64(ctx, nextIndex)) < 0)
                 goto exception;
         }
         JS_FreeValue(ctx, matchStr);
@@ -41096,7 +41559,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
                         JS_GetProperty(ctx, R, JS_ATOM_lastIndex)))
         goto exception;
     if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex,
-                       JS_NewInt32(ctx, lastIndex)) < 0)
+                       JS_NewInt64(ctx, lastIndex)) < 0)
         goto exception;
     
     iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
@@ -41284,7 +41747,7 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
             if (JS_ToLengthFree(ctx, &thisIndex, JS_GetProperty(ctx, rx, JS_ATOM_lastIndex)) < 0)
                 goto exception;
             nextIndex = string_advance_index(sp, thisIndex, fullUnicode);
-            if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, JS_NewInt32(ctx, nextIndex)) < 0)
+            if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, JS_NewInt64(ctx, nextIndex)) < 0)
                 goto exception;
         }
     }
@@ -41343,14 +41806,23 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
             JS_FreeValue(ctx, rep_str);
             rep_str = JS_ToStringFree(ctx, js_function_apply(ctx, rep, 2, args, 0));
         } else {
+            JSValue namedCaptures1;
+            if (!JS_IsUndefined(namedCaptures)) {
+                namedCaptures1 = JS_ToObject(ctx, namedCaptures);
+                if (JS_IsException(namedCaptures1))
+                    goto exception;
+            } else {
+                namedCaptures1 = JS_UNDEFINED;
+            }
             args[0] = matched;
             args[1] = str;
             args[2] = JS_NewInt32(ctx, position);
             args[3] = tab;
-            args[4] = namedCaptures;
+            args[4] = namedCaptures1;
             args[5] = rep_val;
             JS_FreeValue(ctx, rep_str);
             rep_str = js_string___GetSubstitution(ctx, JS_UNDEFINED, 6, args);
+            JS_FreeValue(ctx, namedCaptures1);
         }
         if (JS_IsException(rep_str))
             goto exception;
@@ -41790,7 +42262,7 @@ static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
     JSAtom prop;
     JSPropertyEnum *atoms = NULL;
 
-    if (js_check_stack_overflow(ctx, 0)) {
+    if (js_check_stack_overflow(ctx->rt, 0)) {
         return JS_ThrowStackOverflow(ctx);
     }
 
@@ -42516,7 +42988,7 @@ static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
     JSValue method;
 
     /* safer to test recursion in all proxy methods */
-    if (js_check_stack_overflow(ctx, 0)) {
+    if (js_check_stack_overflow(ctx->rt, 0)) {
         JS_ThrowStackOverflow(ctx);
         return NULL;
     }
@@ -43346,14 +43818,6 @@ static JSValue js_proxy_constructor(JSContext *ctx, JSValueConst this_val,
     if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
         JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    s = JS_GetOpaque(target, JS_CLASS_PROXY);
-    if (s && s->is_revoked)
-        goto revoked_proxy;
-    s = JS_GetOpaque(handler, JS_CLASS_PROXY);
-    if (s && s->is_revoked) {
-    revoked_proxy:
-        return JS_ThrowTypeErrorRevokedProxy(ctx);
-    }
 
     obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
     if (JS_IsException(obj))
@@ -44872,14 +45336,18 @@ static __exception int remainingElementsCount_add(JSContext *ctx,
     return (remainingElementsCount == 0);
 }
 
+#define PROMISE_MAGIC_all        0
+#define PROMISE_MAGIC_allSettled 1
+#define PROMISE_MAGIC_any        2
+
 static JSValue js_promise_all_resolve_element(JSContext *ctx,
                                               JSValueConst this_val,
                                               int argc, JSValueConst *argv,
                                               int magic,
                                               JSValue *func_data)
 {
-    int is_allSettled = magic & 1;
-    int is_reject = magic & 2;
+    int resolve_type = magic & 3;
+    int is_reject = magic & 4;
     BOOL alreadyCalled = JS_ToBool(ctx, func_data[0]);
     JSValueConst values = func_data[2];
     JSValueConst resolve = func_data[3];
@@ -44893,7 +45361,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
         return JS_UNDEFINED;
     func_data[0] = JS_NewBool(ctx, TRUE);
 
-    if (is_allSettled) {
+    if (resolve_type == PROMISE_MAGIC_allSettled) {
         JSValue str;
         
         obj = JS_NewObject(ctx);
@@ -44925,7 +45393,16 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     if (is_zero < 0)
         return JS_EXCEPTION;
     if (is_zero) {
-        ret = JS_Call(ctx, resolve, JS_UNDEFINED, 1, (JSValueConst *)&values);
+        if (resolve_type == PROMISE_MAGIC_any) {
+            JSValue error;
+            error = js_aggregate_error_constructor(ctx, values);
+            if (JS_IsException(error))
+                return JS_EXCEPTION;
+            ret = JS_Call(ctx, resolve, JS_UNDEFINED, 1, (JSValueConst *)&error);
+            JS_FreeValue(ctx, error);
+        } else {
+            ret = JS_Call(ctx, resolve, JS_UNDEFINED, 1, (JSValueConst *)&values);
+        }
         if (JS_IsException(ret))
             return ret;
         JS_FreeValue(ctx, ret);
@@ -44942,8 +45419,8 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
     JSValue resolve_element_env = JS_UNDEFINED, resolve_element, reject_element;
     JSValue promise_resolve = JS_UNDEFINED;
     JSValueConst then_args[2], resolve_element_data[5];
-    BOOL done, is_allSettled = magic;
-    int index, is_zero;
+    BOOL done;
+    int index, is_zero, is_promise_any = (magic == PROMISE_MAGIC_any);
     
     if (!JS_IsObject(this_val))
         return JS_ThrowTypeErrorNotAnObject(ctx);
@@ -45002,24 +45479,30 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
             resolve_element_data[0] = JS_NewBool(ctx, FALSE);
             resolve_element_data[1] = (JSValueConst)JS_NewInt32(ctx, index);
             resolve_element_data[2] = values;
-            resolve_element_data[3] = resolving_funcs[0];
+            resolve_element_data[3] = resolving_funcs[is_promise_any];
             resolve_element_data[4] = resolve_element_env;
             resolve_element =
                 JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
-                                    is_allSettled, 5, resolve_element_data);
+                                    magic, 5, resolve_element_data);
             if (JS_IsException(resolve_element)) {
                 JS_FreeValue(ctx, next_promise);
                 goto fail_reject1;
             }
             
-            if (is_allSettled) {
+            if (magic == PROMISE_MAGIC_allSettled) {
                 reject_element =
                     JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
-                                        is_allSettled | 2, 5, resolve_element_data);
+                                        magic | 4, 5, resolve_element_data);
                 if (JS_IsException(reject_element)) {
                     JS_FreeValue(ctx, next_promise);
                     goto fail_reject1;
                 }
+            } else if (magic == PROMISE_MAGIC_any) {
+                if (JS_DefinePropertyValueUint32(ctx, values, index,
+                                                 JS_UNDEFINED, JS_PROP_C_W_E) < 0)
+                    goto fail_reject1;
+                reject_element = resolve_element;
+                resolve_element = JS_DupValue(ctx, resolving_funcs[0]);
             } else {
                 reject_element = JS_DupValue(ctx, resolving_funcs[1]);
             }
@@ -45045,7 +45528,15 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
         if (is_zero < 0)
             goto fail_reject;
         if (is_zero) {
-            ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
+            if (magic == PROMISE_MAGIC_any) {
+                JSValue error;
+                error = js_aggregate_error_constructor(ctx, values);
+                if (JS_IsException(error))
+                    goto fail_reject;
+                JS_FreeValue(ctx, values);
+                values = error;
+            }
+            ret = JS_Call(ctx, resolving_funcs[is_promise_any], JS_UNDEFINED,
                           1, (JSValueConst *)&values);
             if (check_exception_free(ctx, ret))
                 goto fail_reject;
@@ -45323,8 +45814,9 @@ static JSValue js_promise_finally(JSContext *ctx, JSValueConst this_val,
 static const JSCFunctionListEntry js_promise_funcs[] = {
     JS_CFUNC_MAGIC_DEF("resolve", 1, js_promise_resolve, 0 ),
     JS_CFUNC_MAGIC_DEF("reject", 1, js_promise_resolve, 1 ),
-    JS_CFUNC_MAGIC_DEF("all", 1, js_promise_all, 0 ),
-    JS_CFUNC_MAGIC_DEF("allSettled", 1, js_promise_all, 1 ),
+    JS_CFUNC_MAGIC_DEF("all", 1, js_promise_all, PROMISE_MAGIC_all ),
+    JS_CFUNC_MAGIC_DEF("allSettled", 1, js_promise_all, PROMISE_MAGIC_allSettled ),
+    JS_CFUNC_MAGIC_DEF("any", 1, js_promise_all, PROMISE_MAGIC_any ),
     JS_CFUNC_DEF("race", 1, js_promise_race ),
     //JS_CFUNC_DEF("__newPromiseCapability", 1, js_promise___newPromiseCapability ),
     JS_CGETSET_DEF("[Symbol.species]", js_get_this, NULL),
@@ -45459,7 +45951,8 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
             goto done_resolve;
         }
     }
-    value = JS_IteratorNext2(ctx, s->sync_iter, method, 1, argv, &done);
+    value = JS_IteratorNext2(ctx, s->sync_iter, method,
+                             argc >= 1 ? 1 : 0, argv, &done);
     JS_FreeValue(ctx, method);
     if (JS_IsException(value))
         goto reject;
@@ -48852,7 +49345,7 @@ void JS_EnableBignumExt(JSContext *ctx, BOOL enable)
 static const char * const native_error_name[JS_NATIVE_ERROR_COUNT] = {
     "EvalError", "RangeError", "ReferenceError",
     "SyntaxError", "TypeError", "URIError",
-    "InternalError",
+    "InternalError", "AggregateError",
 };
 
 /* Minimum amount of objects to be able to compile code and display
@@ -48892,6 +49385,9 @@ static void JS_AddIntrinsicBasicObjects(JSContext *ctx)
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
         ctx->native_error_proto[i] = proto;
     }
+    JS_SetPropertyFunctionList(ctx, ctx->native_error_proto[JS_AGGREGATE_ERROR],
+                               js_aggregate_error_proto_funcs,
+                               countof(js_aggregate_error_proto_funcs));
 
     /* the array prototype is an array */
     ctx->class_proto[JS_CLASS_ARRAY] =
@@ -48957,9 +49453,12 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                               "Error", ctx->class_proto[JS_CLASS_ERROR]);
 
     for(i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
-        JSValue func_obj = JS_NewCFunction3(ctx, (JSCFunction *)js_error_constructor,
-                                            native_error_name[i], 1,
-                                            JS_CFUNC_constructor_or_func_magic, i, obj1);
+        JSValue func_obj;
+        int n_args;
+        n_args = 1 + (i == JS_AGGREGATE_ERROR);
+        func_obj = JS_NewCFunction3(ctx, (JSCFunction *)js_error_constructor,
+                                    native_error_name[i], n_args,
+                                    JS_CFUNC_constructor_or_func_magic, i, obj1);
         JS_NewGlobalCConstructor2(ctx, func_obj, native_error_name[i],
                                   ctx->native_error_proto[i]);
     }
@@ -48977,6 +49476,7 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
 
     obj = JS_NewGlobalCConstructor(ctx, "Array", js_array_constructor, 1,
                                    ctx->class_proto[JS_CLASS_ARRAY]);
+    ctx->array_ctor = JS_DupValue(ctx, obj);
     JS_SetPropertyFunctionList(ctx, obj, js_array_funcs,
                                countof(js_array_funcs));
 
@@ -49004,6 +49504,12 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                                js_array_iterator_proto_funcs,
                                countof(js_array_iterator_proto_funcs));
 
+    /* parseFloat and parseInteger must be defined before Number
+       because of the Number.parseFloat and Number.parseInteger
+       aliases */
+    JS_SetPropertyFunctionList(ctx, ctx->global_obj, js_global_funcs,
+                               countof(js_global_funcs));
+
     /* Number */
     ctx->class_proto[JS_CLASS_NUMBER] = JS_NewObjectProtoClass(ctx, ctx->class_proto[JS_CLASS_OBJECT],
                                                                JS_CLASS_NUMBER);
@@ -49093,9 +49599,6 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                            JS_DupValue(ctx, ctx->eval_obj),
                            JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
 
-    JS_SetPropertyFunctionList(ctx, ctx->global_obj, js_global_funcs,
-                               countof(js_global_funcs));
-
     JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_globalThis,
                            JS_DupValue(ctx, ctx->global_obj),
                            JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index abf4d83bfc..f6bfdb022e 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -333,6 +333,7 @@ JSRuntime *JS_NewRuntime(void);
 void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);
 void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);
 void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);
+void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size);
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);
 void JS_FreeRuntime(JSRuntime *rt);
 void *JS_GetRuntimeOpaque(JSRuntime *rt);
@@ -344,10 +345,10 @@ JS_BOOL JS_IsLiveObject(JSRuntime *rt, JSValueConst obj);
 
 JSContext *JS_NewContext(JSRuntime *rt);
 void JS_FreeContext(JSContext *s);
+JSContext *JS_DupContext(JSContext *ctx);
 void *JS_GetContextOpaque(JSContext *ctx);
 void JS_SetContextOpaque(JSContext *ctx, void *opaque);
 JSRuntime *JS_GetRuntime(JSContext *ctx);
-void JS_SetMaxStackSize(JSContext *ctx, size_t stack_size);
 void JS_SetClassProto(JSContext *ctx, JSClassID class_id, JSValue obj);
 JSValue JS_GetClassProto(JSContext *ctx, JSClassID class_id);
 
@@ -673,7 +674,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
 
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
 int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val);
-static int inline JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
+static inline int JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
 {
     return JS_ToInt32(ctx, (int32_t*)pres, val);
 }

From 6c58ef1ecc92c5e1a5e9455ab87dd747908e6afe Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 21 Apr 2020 14:33:49 +0300
Subject: [PATCH 058/185] remove old patch file

---
 quickjs/msvc.patch | 45 ---------------------------------------------
 1 file changed, 45 deletions(-)
 delete mode 100644 quickjs/msvc.patch

diff --git a/quickjs/msvc.patch b/quickjs/msvc.patch
deleted file mode 100644
index f210ac5854..0000000000
--- a/quickjs/msvc.patch
+++ /dev/null
@@ -1,45 +0,0 @@
-diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
-index f6494e1..d822321 100644
---- a/quickjs/quickjs.h
-+++ b/quickjs/quickjs.h
-@@ -53,7 +53,7 @@ typedef struct JSClass JSClass;
- typedef uint32_t JSClassID;
- typedef uint32_t JSAtom;
- 
--#if defined(__x86_64__) || defined(__aarch64__)
-+#if defined(__x86_64__) || defined(__aarch64__) || defined(_WIN64)
- #define JS_PTR64
- #define JS_PTR64_DEF(a) a
- #else
-@@ -205,8 +205,13 @@ typedef struct JSValue {
- #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
- #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
- 
-+#ifdef _MSC_VER
-+#define JS_MKVAL(tag, val) JSValue{ JSValueUnion{ .int32 = val }, tag }
-+#define JS_MKPTR(tag, p) JSValue{ JSValueUnion{ .ptr = p }, tag }
-+#else
- #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
- #define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
-+#endif
- 
- #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
- 
-@@ -587,7 +592,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
-         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         p->ref_count++;
-     }
--    return (JSValue)v;
-+    return v;
- }
- 
- static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
-@@ -596,7 +601,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
-         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
-         p->ref_count++;
-     }
--    return (JSValue)v;
-+    return v;
- }
- 
- int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */

From 287ef8b5e6342c3ca82ab2378b831c090ef50f46 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 21 Apr 2020 14:35:28 +0300
Subject: [PATCH 059/185] disable broken targets for now in github CI

---
 .github/workflows/cxx.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index bddf1e08d0..7179f775ec 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -47,15 +47,15 @@ jobs:
             cmake_opts: -DCMAKE_C_COMPILER=clang-9 -DCMAKE_CXX_COMPILER=clang++-9
             #cflags: -stdlib=libc++
 
-          - compiler: windows-msvs
-            os: windows-latest
+#          - compiler: windows-msvs # not supported
+#            os: windows-latest
 
           - compiler: windows-gcc
             os: windows-2019
             cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
 
-          - compiler: macos-clang
-            os: macos-latest
+#          - compiler: macos-clang # libc++ is broken
+#            os: macos-latest
 
     steps:
     - uses: actions/checkout@v2

From 45edd6553258f432a7abd5e9d716fde92ed39a35 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 15 Jun 2020 13:36:55 +0300
Subject: [PATCH 060/185] Fix #13

---
 quickjspp.hpp      |  2 +-
 test/exception.cpp | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1202aed07f..3e1cca755a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1252,7 +1252,7 @@ class Context
 template <>
 struct js_traits<Value>
 {
-    static Value unwrap(JSContext * ctx, JSValueConst v) noexcept
+    static Value unwrap(JSContext * ctx, JSValueConst v)
     {
         return Value{ctx, JS_DupValue(ctx, v)};
     }
diff --git a/test/exception.cpp b/test/exception.cpp
index c595698299..fcab41a16c 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -50,4 +50,20 @@ int main()
         auto exc = context.getException();
         std::cout << (std::string) exc << '\n' << (std::string_view) exc["stack"];
     }
+
+    try
+    {
+        qjs::Value function = context.eval("() => { let a = b; }", "<test>");
+        auto native = function.as<std::function<qjs::Value()>>();
+        qjs::Value result = native();
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+    }
+
 }

From 77f2d0b6126182f759b00ebd53d36a5269a857d9 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 16 Jun 2020 15:39:52 +0300
Subject: [PATCH 061/185] quickjs update script

---
 quickjs/update.sh | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 quickjs/update.sh

diff --git a/quickjs/update.sh b/quickjs/update.sh
new file mode 100644
index 0000000000..cc2cbd45c6
--- /dev/null
+++ b/quickjs/update.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# Download and extract latest version of quickjs
+set -euxo pipefail
+
+ver="$(curl -s --compressed -L https://bellard.org/quickjs/ | grep --perl-regexp --only-matching --max-count=1 '\d{4}-\d{2}-\d{2}')"
+
+# list of files to extract if no arguments are provided
+[ $# == 0 ] && set -- *.c *.h VERSION
+
+curl -s -L "https://bellard.org/quickjs/quickjs-${ver}.tar.xz" | unxz | tar --strip-components=1 -xf - -- "${@/#/quickjs-${ver}\/}"
+
+# commit (interactive)
+git commit -m "update quickjs to ${ver}" -e -- $@

From 55f953e5842c41e0d27b2b317f05d2fb3da909ce Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 5 Jul 2020 14:16:10 +0300
Subject: [PATCH 062/185] update quickjs to 2020-07-05

---
 quickjs/VERSION        |    2 +-
 quickjs/cutils.h       |    4 +
 quickjs/libbf.c        |   75 +-
 quickjs/libregexp.c    |   49 +-
 quickjs/quickjs-atom.h |    1 +
 quickjs/quickjs-libc.c | 1338 ++++++++++++----
 quickjs/quickjs-libc.h |    9 +
 quickjs/quickjs.c      | 3311 +++++++++++++++++++++++++---------------
 quickjs/quickjs.h      |   29 +-
 9 files changed, 3221 insertions(+), 1597 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 69f162a403..e970cf624e 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-04-12
+2020-07-05
diff --git a/quickjs/cutils.h b/quickjs/cutils.h
index 26c68ee617..31f7cd84a0 100644
--- a/quickjs/cutils.h
+++ b/quickjs/cutils.h
@@ -268,6 +268,10 @@ void dbuf_free(DynBuf *s);
 static inline BOOL dbuf_error(DynBuf *s) {
     return s->error;
 }
+static inline void dbuf_set_error(DynBuf *s)
+{
+    s->error = TRUE;
+}
 
 #define UTF8_CHAR_LEN_MAX 6
 
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 2ef51042da..3bf257a155 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -3370,12 +3370,14 @@ slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
 }
 
 /* 'n' is the number of output limbs */
-static void bf_integer_to_radix_rec(bf_t *pow_tab,
-                                    limb_t *out, const bf_t *a, limb_t n,
-                                    int level, limb_t n0, limb_t radixl,
-                                    unsigned int radixl_bits)
+static int bf_integer_to_radix_rec(bf_t *pow_tab,
+                                   limb_t *out, const bf_t *a, limb_t n,
+                                   int level, limb_t n0, limb_t radixl,
+                                   unsigned int radixl_bits)
 {
     limb_t n1, n2, q_prec;
+    int ret;
+    
     assert(n >= 1);
     if (n == 1) {
         out[0] = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
@@ -3402,63 +3404,81 @@ static void bf_integer_to_radix_rec(bf_t *pow_tab,
         n1 = n - n2;
         B = &pow_tab[2 * level];
         B_inv = &pow_tab[2 * level + 1];
+        ret = 0;
         if (B->len == 0) {
             /* compute BASE^n2 */
-            bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
+            ret |= bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
             /* we use enough bits for the maximum possible 'n1' value,
                i.e. n2 + 1 */
-            bf_set_ui(&R, 1);
-            bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
+            ret |= bf_set_ui(&R, 1);
+            ret |= bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
         }
         //        printf("%d: n1=% " PRId64 " n2=%" PRId64 "\n", level, n1, n2);
         q_prec = n1 * radixl_bits;
-        bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
-        bf_rint(&Q, BF_RNDZ);
+        ret |= bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
+        ret |= bf_rint(&Q, BF_RNDZ);
         
-        bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
-        bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
+        ret |= bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
+        ret |= bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
+
+        if (ret & BF_ST_MEM_ERROR)
+            goto fail;
         /* adjust if necessary */
         q_add = 0;
         while (R.sign && R.len != 0) {
-            bf_add(&R, &R, B, BF_PREC_INF, BF_RNDZ);
+            if (bf_add(&R, &R, B, BF_PREC_INF, BF_RNDZ))
+                goto fail;
             q_add--;
         }
         while (bf_cmpu(&R, B) >= 0) {
-            bf_sub(&R, &R, B, BF_PREC_INF, BF_RNDZ);
+            if (bf_sub(&R, &R, B, BF_PREC_INF, BF_RNDZ))
+                goto fail;
             q_add++;
         }
         if (q_add != 0) {
-            bf_add_si(&Q, &Q, q_add, BF_PREC_INF, BF_RNDZ);
+            if (bf_add_si(&Q, &Q, q_add, BF_PREC_INF, BF_RNDZ))
+                goto fail;
+        }
+        if (bf_integer_to_radix_rec(pow_tab, out + n2, &Q, n1, level + 1, n0,
+                                    radixl, radixl_bits))
+            goto fail;
+        if (bf_integer_to_radix_rec(pow_tab, out, &R, n2, level + 1, n0,
+                                    radixl, radixl_bits)) {
+        fail:
+            bf_delete(&Q);
+            bf_delete(&R);
+            return -1;
         }
-        bf_integer_to_radix_rec(pow_tab, out + n2, &Q, n1, level + 1, n0,
-                                radixl, radixl_bits);
-        bf_integer_to_radix_rec(pow_tab, out, &R, n2, level + 1, n0,
-                                radixl, radixl_bits);
         bf_delete(&Q);
         bf_delete(&R);
     }
+    return 0;
 }
 
-static void bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
+/* return 0 if OK != 0 if memory error */
+static int bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
 {
     bf_context_t *s = r->ctx;
     limb_t r_len;
     bf_t *pow_tab;
-    int i, pow_tab_len;
+    int i, pow_tab_len, ret;
     
     r_len = r->len;
     pow_tab_len = (ceil_log2(r_len) + 2) * 2; /* XXX: check */
     pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
+    if (!pow_tab)
+        return -1;
     for(i = 0; i < pow_tab_len; i++)
         bf_init(r->ctx, &pow_tab[i]);
 
-    bf_integer_to_radix_rec(pow_tab, r->tab, a, r_len, 0, r_len, radixl,
-                            ceil_log2(radixl));
+    ret = bf_integer_to_radix_rec(pow_tab, r->tab, a, r_len, 0, r_len, radixl,
+                                  ceil_log2(radixl));
 
     for(i = 0; i < pow_tab_len; i++) {
         bf_delete(&pow_tab[i]);
     }
     bf_free(s, pow_tab);
+    return ret;
 }
 
 /* a must be >= 0. 'P' is the wanted number of digits in radix
@@ -3625,8 +3645,14 @@ static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
         a = &a_s;
         bf_init(a1->ctx, a);
         n = (n_digits + digits_per_limb - 1) / digits_per_limb;
-        bf_resize(a, n);
-        bf_integer_to_radix(a, a1, radixl);
+        if (bf_resize(a, n)) {
+            dbuf_set_error(s);
+            goto done;
+        }
+        if (bf_integer_to_radix(a, a1, radixl)) {
+            dbuf_set_error(s);
+            goto done;
+        }
         radix_bits = 0;
         pos = n;
         pos_incr = 1;
@@ -3659,6 +3685,7 @@ static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
         buf_pos += l;
         i += l;
     }
+ done:
     if (a != a1)
         bf_delete(a);
 }
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index 7f6eef42a8..b455bf246f 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -110,12 +110,14 @@ static inline int is_digit(int c) {
     return c >= '0' && c <= '9';
 }
 
-/* insert 'len' bytes at position 'pos' */
-static void dbuf_insert(DynBuf *s, int pos, int len)
+/* insert 'len' bytes at position 'pos'. Return < 0 if error. */
+static int dbuf_insert(DynBuf *s, int pos, int len)
 {
-    dbuf_realloc(s, s->size + len);
+    if (dbuf_realloc(s, s->size + len))
+        return -1;
     memmove(s->buf + pos + len, s->buf + pos, s->size - pos);
     s->size += len;
+    return 0;
 }
 
 /* canonicalize with the specific JS regexp rules */
@@ -434,6 +436,11 @@ static int __attribute__((format(printf, 2, 3))) re_parse_error(REParseState *s,
     return -1;
 }
 
+static int re_parse_out_of_memory(REParseState *s)
+{
+    return re_parse_error(s, "out of memory");
+}
+
 /* If allow_overflow is false, return -1 in case of
    overflow. Otherwise return INT32_MAX. */
 static int parse_digits(const uint8_t **pp, BOOL allow_overflow)
@@ -693,7 +700,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
     *pp = p;
     return 0;
  out_of_memory:
-    return re_parse_error(s, "out of memory");
+    return re_parse_out_of_memory(s);
 }
 #endif /* CONFIG_ALL_UNICODE */
 
@@ -928,7 +935,7 @@ static int re_parse_char_class(REParseState *s, const uint8_t **pp)
     *pp = p;
     return 0;
  memory_error:
-    re_parse_error(s, "out of memory");
+    re_parse_out_of_memory(s);
  fail:
     cr_free(cr);
     return -1;
@@ -1295,6 +1302,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     return -1;
                 re_emit_op(s, REOP_match);
                 /* jump after the 'match' after the lookahead is successful */
+                if (dbuf_error(&s->byte_code))
+                    return -1;
                 put_u32(s->byte_code.buf + pos, s->byte_code.size - (pos + 4));
             } else if (p[2] == '<') {
                 p += 3;
@@ -1548,12 +1557,15 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 
                 if (quant_max > 0) {
                     /* specific optimization for simple quantifiers */
+                    if (dbuf_error(&s->byte_code))
+                        goto out_of_memory;
                     len = re_is_simple_quantifier(s->byte_code.buf + last_atom_start,
                                                  s->byte_code.size - last_atom_start);
                     if (len > 0) {
                         re_emit_op(s, REOP_match);
                         
-                        dbuf_insert(&s->byte_code, last_atom_start, 17);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 17))
+                            goto out_of_memory;
                         pos = last_atom_start;
                         s->byte_code.buf[pos++] = REOP_simple_greedy_quant;
                         put_u32(&s->byte_code.buf[pos],
@@ -1569,6 +1581,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     }
                 }
                 
+                if (dbuf_error(&s->byte_code))
+                    goto out_of_memory;
                 add_zero_advance_check = (re_check_advance(s->byte_code.buf + last_atom_start,
                                                            s->byte_code.size - last_atom_start) == 0);
             } else {
@@ -1582,7 +1596,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     /* need to reset the capture in case the atom is
                        not executed */
                     if (last_capture_count != s->capture_count) {
-                        dbuf_insert(&s->byte_code, last_atom_start, 3);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 3))
+                            goto out_of_memory;
                         s->byte_code.buf[last_atom_start++] = REOP_save_reset;
                         s->byte_code.buf[last_atom_start++] = last_capture_count;
                         s->byte_code.buf[last_atom_start++] = s->capture_count - 1;
@@ -1590,12 +1605,14 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     if (quant_max == 0) {
                         s->byte_code.size = last_atom_start;
                     } else if (quant_max == 1) {
-                        dbuf_insert(&s->byte_code, last_atom_start, 5);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 5))
+                            goto out_of_memory;
                         s->byte_code.buf[last_atom_start] = REOP_split_goto_first +
                             greedy;
                         put_u32(s->byte_code.buf + last_atom_start + 1, len);
                     } else if (quant_max == INT32_MAX) {
-                        dbuf_insert(&s->byte_code, last_atom_start, 5 + add_zero_advance_check);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 5 + add_zero_advance_check))
+                            goto out_of_memory;
                         s->byte_code.buf[last_atom_start] = REOP_split_goto_first +
                             greedy;
                         put_u32(s->byte_code.buf + last_atom_start + 1,
@@ -1611,7 +1628,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                             re_emit_goto(s, REOP_goto, last_atom_start);
                         }
                     } else {
-                        dbuf_insert(&s->byte_code, last_atom_start, 10);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 10))
+                            goto out_of_memory;
                         pos = last_atom_start;
                         s->byte_code.buf[pos++] = REOP_push_i32;
                         put_u32(s->byte_code.buf + pos, quant_max);
@@ -1629,7 +1647,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     if (quant_min == 1) {
                         /* nothing to add */
                     } else {
-                        dbuf_insert(&s->byte_code, last_atom_start, 5);
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 5))
+                            goto out_of_memory;
                         s->byte_code.buf[last_atom_start] = REOP_push_i32;
                         put_u32(s->byte_code.buf + last_atom_start + 1,
                                 quant_min);
@@ -1670,6 +1689,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
  done:
     s->buf_ptr = p;
     return 0;
+ out_of_memory:
+    return re_parse_out_of_memory(s);
 }
 
 static int re_parse_alternative(REParseState *s, BOOL is_backward_dir)
@@ -1719,7 +1740,9 @@ static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
         len = s->byte_code.size - start;
 
         /* insert a split before the first alternative */
-        dbuf_insert(&s->byte_code, start, 5);
+        if (dbuf_insert(&s->byte_code, start, 5)) {
+            return re_parse_out_of_memory(s);
+        }
         s->byte_code.buf[start] = REOP_split_next_first;
         put_u32(s->byte_code.buf + start + 1, len + 5);
 
@@ -1844,7 +1867,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     }
 
     if (dbuf_error(&s->byte_code)) {
-        re_parse_error(s, "out of memory");
+        re_parse_out_of_memory(s);
         goto error;
     }
     
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 501aa1f8db..a353ad4426 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -82,6 +82,7 @@ DEF(length, "length")
 DEF(fileName, "fileName")
 DEF(lineNumber, "lineNumber")
 DEF(message, "message")
+DEF(errors, "errors")
 DEF(stack, "stack")
 DEF(name, "name")
 DEF(toString, "toString")
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 4e6d221525..eda23c7899 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -40,28 +40,38 @@
 #if defined(_WIN32)
 #include <windows.h>
 #include <conio.h>
+#include <utime.h>
 #else
 #include <dlfcn.h>
 #include <termios.h>
 #include <sys/ioctl.h>
 #include <sys/wait.h>
+
 #if defined(__APPLE__)
 typedef sig_t sighandler_t;
+#if !defined(environ)
+#include <crt_externs.h>
+#define environ (*_NSGetEnviron())
+#endif
+#endif /* __APPLE__ */
+
+#endif
+
+#if !defined(_WIN32)
+/* enable the os.Worker API. IT relies on POSIX threads */
+#define USE_WORKER
 #endif
+
+#ifdef USE_WORKER
+#include <pthread.h>
+#include <stdatomic.h>
 #endif
 
 #include "cutils.h"
 #include "list.h"
 #include "quickjs-libc.h"
 
-static void js_std_dbuf_init(JSContext *ctx, DynBuf *s)
-{
-    dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc *)js_realloc_rt);
-}
-
 /* TODO:
-   - add worker
-   - add minimal VT100 emulation for win32
    - add socket calls
 */
 
@@ -84,14 +94,54 @@ typedef struct {
     JSValue func;
 } JSOSTimer;
 
-/* initialize the lists so js_std_free_handlers() can always be called */
-static struct list_head os_rw_handlers = LIST_HEAD_INIT(os_rw_handlers);
-static struct list_head os_signal_handlers = LIST_HEAD_INIT(os_signal_handlers);
-static struct list_head os_timers = LIST_HEAD_INIT(os_timers);
+typedef struct {
+    struct list_head link;
+    uint8_t *data;
+    size_t data_len;
+    /* list of SharedArrayBuffers, necessary to free the message */
+    uint8_t **sab_tab;
+    size_t sab_tab_len;
+} JSWorkerMessage;
+
+typedef struct {
+    int ref_count;
+#ifdef USE_WORKER
+    pthread_mutex_t mutex;
+#endif
+    struct list_head msg_queue; /* list of JSWorkerMessage.link */
+    int read_fd;
+    int write_fd;
+} JSWorkerMessagePipe;
+
+typedef struct {
+    struct list_head link;
+    JSWorkerMessagePipe *recv_pipe;
+    JSValue on_message_func;
+} JSWorkerMessageHandler;
+
+typedef struct JSThreadState {
+    struct list_head os_rw_handlers; /* list of JSOSRWHandler.link */
+    struct list_head os_signal_handlers; /* list JSOSSignalHandler.link */
+    struct list_head os_timers; /* list of JSOSTimer.link */
+    struct list_head port_list; /* list of JSWorkerMessageHandler.link */
+    int eval_script_recurse; /* only used in the main thread */
+    /* not used in the main thread */
+    JSWorkerMessagePipe *recv_pipe, *send_pipe;
+} JSThreadState;
+
 static uint64_t os_pending_signals;
-static int eval_script_recurse;
 static int (*os_poll_func)(JSContext *ctx);
 
+static void js_std_dbuf_init(JSContext *ctx, DynBuf *s)
+{
+    dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc *)js_realloc_rt);
+}
+
+static BOOL my_isdigit(int c)
+{
+    return (c >= '0' && c <= '9');
+}
+
 static JSValue js_printf_internal(JSContext *ctx,
                                   int argc, JSValueConst *argv, FILE *fp)
 {
@@ -103,14 +153,12 @@ static JSValue js_printf_internal(JSContext *ctx,
     const uint8_t *fmt, *fmt_end;
     const uint8_t *p;
     char *q;
-    int i, c, len;
+    int i, c, len, mod;
     size_t fmt_len;
     int32_t int32_arg;
     int64_t int64_arg;
     double double_arg;
     const char *string_arg;
-    enum { PART_FLAGS, PART_WIDTH, PART_DOT, PART_PREC, PART_MODIFIER } part;
-    int modsize;
     /* Use indirect call to dbuf_printf to prevent gcc warning */
     int (*dbuf_printf_fun)(DynBuf *s, const char *fmt, ...) = (void*)dbuf_printf;
 
@@ -132,150 +180,162 @@ static JSValue js_printf_internal(JSContext *ctx,
                 break;
             q = fmtbuf;
             *q++ = *fmt++;  /* copy '%' */
-            part = PART_FLAGS;
-            modsize = 0;
-            for (;;) {
-                if (q >= fmtbuf + sizeof(fmtbuf) - 1)
-                    goto invalid;
-
-                c = *fmt++;
-                *q++ = c;
-                *q = '\0';
-
-                switch (c) {
-                case '1': case '2': case '3':
-                case '4': case '5': case '6':
-                case '7': case '8': case '9':
-                    if (part != PART_PREC) {
-                        if (part <= PART_WIDTH)
-                            part = PART_WIDTH;
-                        else 
-                            goto invalid;
-                    }
-                    continue;
-
-                case '0': case '#': case '+': case '-': case ' ': case '\'':
-                    if (part > PART_FLAGS)
-                        goto invalid;
-                    continue;
-
-                case '.':
-                    if (part > PART_DOT)
+            
+            /* flags */
+            for(;;) {
+                c = *fmt;
+                if (c == '0' || c == '#' || c == '+' || c == '-' || c == ' ' ||
+                    c == '\'') {
+                    if (q >= fmtbuf + sizeof(fmtbuf) - 1)
                         goto invalid;
-                    part = PART_DOT;
-                    continue;
-
-                case '*':
-                    if (part < PART_WIDTH)
-                        part = PART_DOT;
-                    else if (part == PART_DOT)
-                        part = PART_MODIFIER;
-                    else
+                    *q++ = c;
+                    fmt++;
+                } else {
+                    break;
+                }
+            }
+            /* width */
+            if (*fmt == '*') {
+                if (i >= argc)
+                    goto missing;
+                if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
+                    goto fail;
+                q += snprintf(q, fmtbuf + sizeof(fmtbuf) - q, "%d", int32_arg);
+                fmt++;
+            } else {
+                while (my_isdigit(*fmt)) {
+                    if (q >= fmtbuf + sizeof(fmtbuf) - 1)
                         goto invalid;
-
+                    *q++ = *fmt++;
+                }
+            }
+            if (*fmt == '.') {
+                if (q >= fmtbuf + sizeof(fmtbuf) - 1)
+                    goto invalid;
+                *q++ = *fmt++;
+                if (*fmt == '*') {
                     if (i >= argc)
                         goto missing;
-
                     if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
                         goto fail;
                     q += snprintf(q, fmtbuf + sizeof(fmtbuf) - q, "%d", int32_arg);
-                    continue;
-
-                case 'h':
-                    if (modsize != 0 && modsize != -1)
-                        goto invalid;
-                    modsize--;
-                    part = PART_MODIFIER;
-                    continue;
-                case 'l':
-                    q--;
-                    if (modsize != 0 && modsize != 1)
-                        goto invalid;
-                    modsize++;
-                    part = PART_MODIFIER;
-                    continue;
-
-                case 'c':
-                    if (i >= argc)
-                        goto missing;
-                    if (JS_IsString(argv[i])) {
-                        string_arg = JS_ToCString(ctx, argv[i++]);
-                        if (!string_arg)
-                            goto fail;
-                        int32_arg = unicode_from_utf8((uint8_t *)string_arg, UTF8_CHAR_LEN_MAX, &p);
-                        JS_FreeCString(ctx, string_arg);
-                    } else {
-                        if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
-                            goto fail;
-                    }
-                    /* handle utf-8 encoding explicitly */
-                    if ((unsigned)int32_arg > 0x10FFFF)
-                        int32_arg = 0xFFFD;
-                    /* ignore conversion flags, width and precision */
-                    len = unicode_to_utf8(cbuf, int32_arg);
-                    dbuf_put(&dbuf, cbuf, len);
-                    break;
-
-                case 'd':
-                case 'i':
-                case 'o':
-                case 'u':
-                case 'x':
-                case 'X':
-                    if (i >= argc)
-                        goto missing;
-                    if (JS_ToInt64Ext(ctx, &int64_arg, argv[i++]))
-                        goto fail;
-                    if (modsize > 0) {
-                        q[1] = q[-1];
-                        q[-1] = q[0] = 'l';
-                        q[2] = '\0';
-                        dbuf_printf_fun(&dbuf, fmtbuf, (long long)int64_arg);
-                    } else {
-                        dbuf_printf_fun(&dbuf, fmtbuf, (int)int64_arg);
+                    fmt++;
+                } else {
+                    while (my_isdigit(*fmt)) {
+                        if (q >= fmtbuf + sizeof(fmtbuf) - 1)
+                            goto invalid;
+                        *q++ = *fmt++;
                     }
-                    break;
+                }
+            }
 
-                case 's':
-                    if (i >= argc)
-                        goto missing;
-                    /* XXX: handle strings containing null characters */
+            /* we only support the "l" modifier for 64 bit numbers */
+            mod = ' ';
+            if (*fmt == 'l') {
+                mod = *fmt++;
+            }
+            
+            /* type */
+            c = *fmt++;
+            if (q >= fmtbuf + sizeof(fmtbuf) - 1)
+                goto invalid;
+            *q++ = c;
+            *q = '\0';
+            
+            switch (c) {
+            case 'c':
+                if (i >= argc)
+                    goto missing;
+                if (JS_IsString(argv[i])) {
                     string_arg = JS_ToCString(ctx, argv[i++]);
                     if (!string_arg)
                         goto fail;
-                    dbuf_printf_fun(&dbuf, fmtbuf, string_arg);
+                    int32_arg = unicode_from_utf8((uint8_t *)string_arg, UTF8_CHAR_LEN_MAX, &p);
                     JS_FreeCString(ctx, string_arg);
-                    break;
-
-                case 'e':
-                case 'f':
-                case 'g':
-                case 'a':
-                case 'E':
-                case 'F':
-                case 'G':
-                case 'A':
-                    if (i >= argc)
-                        goto missing;
-                    if (JS_ToFloat64(ctx, &double_arg, argv[i++]))
+                } else {
+                    if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
                         goto fail;
-                    dbuf_printf_fun(&dbuf, fmtbuf, double_arg);
-                    break;
-
-                case '%':
-                    dbuf_putc(&dbuf, '%');
-                    break;
+                }
+                /* handle utf-8 encoding explicitly */
+                if ((unsigned)int32_arg > 0x10FFFF)
+                    int32_arg = 0xFFFD;
+                /* ignore conversion flags, width and precision */
+                len = unicode_to_utf8(cbuf, int32_arg);
+                dbuf_put(&dbuf, cbuf, len);
+                break;
+                
+            case 'd':
+            case 'i':
+            case 'o':
+            case 'u':
+            case 'x':
+            case 'X':
+                if (i >= argc)
+                    goto missing;
+                if (JS_ToInt64Ext(ctx, &int64_arg, argv[i++]))
+                    goto fail;
+                if (mod == 'l') {
+                    /* 64 bit number */
+#if defined(_WIN32)
+                    if (q >= fmtbuf + sizeof(fmtbuf) - 3)
+                        goto invalid;
+                    q[2] = q[-1];
+                    q[-1] = 'I';
+                    q[0] = '6';
+                    q[1] = '4';
+                    q[3] = '\0';
+                    dbuf_printf_fun(&dbuf, fmtbuf, (int64_t)int64_arg);
+#else
+                    if (q >= fmtbuf + sizeof(fmtbuf) - 2)
+                        goto invalid;
+                    q[1] = q[-1];
+                    q[-1] = q[0] = 'l';
+                    q[2] = '\0';
+                    dbuf_printf_fun(&dbuf, fmtbuf, (long long)int64_arg);
+#endif
+                } else {
+                    dbuf_printf_fun(&dbuf, fmtbuf, (int)int64_arg);
+                }
+                break;
 
-                default:
-                    /* XXX: should support an extension mechanism */
-                invalid:
-                    JS_ThrowTypeError(ctx, "invalid conversion specifier in format string");
+            case 's':
+                if (i >= argc)
+                    goto missing;
+                /* XXX: handle strings containing null characters */
+                string_arg = JS_ToCString(ctx, argv[i++]);
+                if (!string_arg)
                     goto fail;
-                missing:
-                    JS_ThrowReferenceError(ctx, "missing argument for conversion specifier");
+                dbuf_printf_fun(&dbuf, fmtbuf, string_arg);
+                JS_FreeCString(ctx, string_arg);
+                break;
+                
+            case 'e':
+            case 'f':
+            case 'g':
+            case 'a':
+            case 'E':
+            case 'F':
+            case 'G':
+            case 'A':
+                if (i >= argc)
+                    goto missing;
+                if (JS_ToFloat64(ctx, &double_arg, argv[i++]))
                     goto fail;
-                }
+                dbuf_printf_fun(&dbuf, fmtbuf, double_arg);
+                break;
+                
+            case '%':
+                dbuf_putc(&dbuf, '%');
                 break;
+                
+            default:
+                /* XXX: should support an extension mechanism */
+            invalid:
+                JS_ThrowTypeError(ctx, "invalid conversion specifier in format string");
+                goto fail;
+            missing:
+                JS_ThrowReferenceError(ctx, "missing argument for conversion specifier");
+                goto fail;
             }
         }
         JS_FreeCString(ctx, fmt_str);
@@ -593,6 +653,8 @@ static int get_bool_option(JSContext *ctx, BOOL *pbool,
 static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     const char *str;
     size_t len;
     JSValue ret;
@@ -610,7 +672,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
     str = JS_ToCStringLen(ctx, &len, argv[0]);
     if (!str)
         return JS_EXCEPTION;
-    if (++eval_script_recurse == 1) {
+    if (!ts->recv_pipe && ++ts->eval_script_recurse == 1) {
         /* install the interrupt handler */
         JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
     }
@@ -619,7 +681,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
         flags |= JS_EVAL_FLAG_BACKTRACE_BARRIER;
     ret = JS_Eval(ctx, str, len, "<evalScript>", flags);
     JS_FreeCString(ctx, str);
-    if (--eval_script_recurse == 0) {
+    if (!ts->recv_pipe && --ts->eval_script_recurse == 0) {
         /* remove the interrupt handler */
         JS_SetInterruptHandler(JS_GetRuntime(ctx), NULL, NULL);
         os_pending_signals &= ~((uint64_t)1 << SIGINT);
@@ -669,6 +731,21 @@ static JSValue js_std_strerror(JSContext *ctx, JSValueConst this_val,
     return JS_NewString(ctx, strerror(err));
 }
 
+static JSValue js_std_parseExtJSON(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
+{
+    JSValue obj;
+    const char *str;
+    size_t len;
+
+    str = JS_ToCStringLen(ctx, &len, argv[0]);
+    if (!str)
+        return JS_EXCEPTION;
+    obj = JS_ParseJSON2(ctx, str, len, "<input>", JS_PARSE_JSON_EXT);
+    JS_FreeCString(ctx, str);
+    return obj;
+}
+
 static JSValue js_new_std_file(JSContext *ctx, FILE *f,
                                BOOL close_in_finalizer,
                                BOOL is_popen)
@@ -1321,6 +1398,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("urlGet", 1, js_std_urlGet ),
     JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
     JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
+    JS_CFUNC_DEF("parseExtJSON", 1, js_std_parseExtJSON ),
     
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
@@ -1626,11 +1704,18 @@ static JSValue js_os_rename(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, ret);
 }
 
-static JSOSRWHandler *find_rh(int fd)
+static BOOL is_main_thread(JSRuntime *rt)
+{
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    return !ts->recv_pipe;
+}
+
+static JSOSRWHandler *find_rh(JSThreadState *ts, int fd)
 {
     JSOSRWHandler *rh;
     struct list_head *el;
-    list_for_each(el, &os_rw_handlers) {
+
+    list_for_each(el, &ts->os_rw_handlers) {
         rh = list_entry(el, JSOSRWHandler, link);
         if (rh->fd == fd)
             return rh;
@@ -1651,6 +1736,8 @@ static void free_rw_handler(JSRuntime *rt, JSOSRWHandler *rh)
 static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv, int magic)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     JSOSRWHandler *rh;
     int fd;
     JSValueConst func;
@@ -1659,7 +1746,7 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     func = argv[1];
     if (JS_IsNull(func)) {
-        rh = find_rh(fd);
+        rh = find_rh(ts, fd);
         if (rh) {
             JS_FreeValue(ctx, rh->rw_func[magic]);
             rh->rw_func[magic] = JS_NULL;
@@ -1672,7 +1759,7 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
     } else {
         if (!JS_IsFunction(ctx, func))
             return JS_ThrowTypeError(ctx, "not a function");
-        rh = find_rh(fd);
+        rh = find_rh(ts, fd);
         if (!rh) {
             rh = js_mallocz(ctx, sizeof(*rh));
             if (!rh)
@@ -1680,7 +1767,7 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
             rh->fd = fd;
             rh->rw_func[0] = JS_NULL;
             rh->rw_func[1] = JS_NULL;
-            list_add_tail(&rh->link, &os_rw_handlers);
+            list_add_tail(&rh->link, &ts->os_rw_handlers);
         }
         JS_FreeValue(ctx, rh->rw_func[magic]);
         rh->rw_func[magic] = JS_DupValue(ctx, func);
@@ -1688,11 +1775,11 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
     return JS_UNDEFINED;
 }
 
-static JSOSSignalHandler *find_sh(int sig_num)
+static JSOSSignalHandler *find_sh(JSThreadState *ts, int sig_num)
 {
     JSOSSignalHandler *sh;
     struct list_head *el;
-    list_for_each(el, &os_signal_handlers) {
+    list_for_each(el, &ts->os_signal_handlers) {
         sh = list_entry(el, JSOSSignalHandler, link);
         if (sh->sig_num == sig_num)
             return sh;
@@ -1719,10 +1806,15 @@ typedef void (*sighandler_t)(int sig_num);
 static JSValue js_os_signal(JSContext *ctx, JSValueConst this_val,
                             int argc, JSValueConst *argv)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     JSOSSignalHandler *sh;
     uint32_t sig_num;
     JSValueConst func;
     sighandler_t handler;
+
+    if (!is_main_thread(rt))
+        return JS_ThrowTypeError(ctx, "signal handler can only be set in the main thread");
     
     if (JS_ToUint32(ctx, &sig_num, argv[0]))
         return JS_EXCEPTION;
@@ -1731,7 +1823,7 @@ static JSValue js_os_signal(JSContext *ctx, JSValueConst this_val,
     func = argv[1];
     /* func = null: SIG_DFL, func = undefined, SIG_IGN */
     if (JS_IsNull(func) || JS_IsUndefined(func)) {
-        sh = find_sh(sig_num);
+        sh = find_sh(ts, sig_num);
         if (sh) {
             free_sh(JS_GetRuntime(ctx), sh);
         }
@@ -1743,13 +1835,13 @@ static JSValue js_os_signal(JSContext *ctx, JSValueConst this_val,
     } else {
         if (!JS_IsFunction(ctx, func))
             return JS_ThrowTypeError(ctx, "not a function");
-        sh = find_sh(sig_num);
+        sh = find_sh(ts, sig_num);
         if (!sh) {
             sh = js_mallocz(ctx, sizeof(*sh));
             if (!sh)
                 return JS_EXCEPTION;
             sh->sig_num = sig_num;
-            list_add_tail(&sh->link, &os_signal_handlers);
+            list_add_tail(&sh->link, &ts->os_signal_handlers);
         }
         JS_FreeValue(ctx, sh->func);
         sh->func = JS_DupValue(ctx, func);
@@ -1813,6 +1905,8 @@ static void js_os_timer_mark(JSRuntime *rt, JSValueConst val,
 static JSValue js_os_setTimeout(JSContext *ctx, JSValueConst this_val,
                                 int argc, JSValueConst *argv)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     int64_t delay;
     JSValueConst func;
     JSOSTimer *th;
@@ -1834,7 +1928,7 @@ static JSValue js_os_setTimeout(JSContext *ctx, JSValueConst this_val,
     th->has_object = TRUE;
     th->timeout = get_time_ms() + delay;
     th->func = JS_DupValue(ctx, func);
-    list_add_tail(&th->link, &os_timers);
+    list_add_tail(&th->link, &ts->os_timers);
     JS_SetOpaque(obj, th);
     return obj;
 }
@@ -1872,6 +1966,8 @@ static void call_handler(JSContext *ctx, JSValueConst func)
 
 static int js_os_poll(JSContext *ctx)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     int min_delay, console_fd;
     int64_t cur_time, delay;
     JSOSRWHandler *rh;
@@ -1879,14 +1975,14 @@ static int js_os_poll(JSContext *ctx)
     
     /* XXX: handle signals if useful */
 
-    if (list_empty(&os_rw_handlers) && list_empty(&os_timers))
+    if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers))
         return -1; /* no more events */
     
     /* XXX: only timers and basic console input are supported */
-    if (!list_empty(&os_timers)) {
+    if (!list_empty(&ts->os_timers)) {
         cur_time = get_time_ms();
         min_delay = 10000;
-        list_for_each(el, &os_timers) {
+        list_for_each(el, &ts->os_timers) {
             JSOSTimer *th = list_entry(el, JSOSTimer, link);
             delay = th->timeout - cur_time;
             if (delay <= 0) {
@@ -1894,9 +1990,9 @@ static int js_os_poll(JSContext *ctx)
                 /* the timer expired */
                 func = th->func;
                 th->func = JS_UNDEFINED;
-                unlink_timer(JS_GetRuntime(ctx), th);
+                unlink_timer(rt, th);
                 if (!th->has_object)
-                    free_timer(JS_GetRuntime(ctx), th);
+                    free_timer(rt, th);
                 call_handler(ctx, func);
                 JS_FreeValue(ctx, func);
                 return 0;
@@ -1909,7 +2005,7 @@ static int js_os_poll(JSContext *ctx)
     }
 
     console_fd = -1;
-    list_for_each(el, &os_rw_handlers) {
+    list_for_each(el, &ts->os_rw_handlers) {
         rh = list_entry(el, JSOSRWHandler, link);
         if (rh->fd == 0 && !JS_IsNull(rh->rw_func[0])) {
             console_fd = rh->fd;
@@ -1927,7 +2023,7 @@ static int js_os_poll(JSContext *ctx)
         handle = (HANDLE)_get_osfhandle(console_fd);
         ret = WaitForSingleObject(handle, ti);
         if (ret == WAIT_OBJECT_0) {
-            list_for_each(el, &os_rw_handlers) {
+            list_for_each(el, &ts->os_rw_handlers) {
                 rh = list_entry(el, JSOSRWHandler, link);
                 if (rh->fd == console_fd && !JS_IsNull(rh->rw_func[0])) {
                     call_handler(ctx, rh->rw_func[0]);
@@ -1942,8 +2038,88 @@ static int js_os_poll(JSContext *ctx)
     return 0;
 }
 #else
+
+#ifdef USE_WORKER
+
+static void js_free_message(JSWorkerMessage *msg);
+
+/* return 1 if a message was handled, 0 if no message */
+static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
+                                 JSWorkerMessageHandler *port)
+{
+    JSWorkerMessagePipe *ps = port->recv_pipe;
+    int ret;
+    struct list_head *el;
+    JSWorkerMessage *msg;
+    JSValue obj, data_obj, func, retval;
+    
+    pthread_mutex_lock(&ps->mutex);
+    if (!list_empty(&ps->msg_queue)) {
+        el = ps->msg_queue.next;
+        msg = list_entry(el, JSWorkerMessage, link);
+
+        /* remove the message from the queue */
+        list_del(&msg->link);
+
+        if (list_empty(&ps->msg_queue)) {
+            uint8_t buf[16];
+            int ret;
+            for(;;) {
+                ret = read(ps->read_fd, buf, sizeof(buf));
+                if (ret >= 0)
+                    break;
+                if (errno != EAGAIN && errno != EINTR)
+                    break;
+            }
+        }
+
+        pthread_mutex_unlock(&ps->mutex);
+
+        data_obj = JS_ReadObject(ctx, msg->data, msg->data_len,
+                                 JS_READ_OBJ_SAB | JS_READ_OBJ_REFERENCE);
+
+        js_free_message(msg);
+        
+        if (JS_IsException(data_obj))
+            goto fail;
+        obj = JS_NewObject(ctx);
+        if (JS_IsException(obj)) {
+            JS_FreeValue(ctx, data_obj);
+            goto fail;
+        }
+        JS_DefinePropertyValueStr(ctx, obj, "data", data_obj, JS_PROP_C_W_E);
+
+        /* 'func' might be destroyed when calling itself (if it frees the
+           handler), so must take extra care */
+        func = JS_DupValue(ctx, port->on_message_func);
+        retval = JS_Call(ctx, func, JS_UNDEFINED, 1, (JSValueConst *)&obj);
+        JS_FreeValue(ctx, obj);
+        JS_FreeValue(ctx, func);
+        if (JS_IsException(retval)) {
+        fail:
+            js_std_dump_error(ctx);
+        } else {
+            JS_FreeValue(ctx, retval);
+        }
+        ret = 1;
+    } else {
+        pthread_mutex_unlock(&ps->mutex);
+        ret = 0;
+    }
+    return ret;
+}
+#else
+static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
+                                 JSWorkerMessageHandler *port)
+{
+    return 0;
+}
+#endif
+
 static int js_os_poll(JSContext *ctx)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     int ret, fd_max, min_delay;
     int64_t cur_time, delay;
     fd_set rfds, wfds;
@@ -1951,11 +2127,13 @@ static int js_os_poll(JSContext *ctx)
     struct list_head *el;
     struct timeval tv, *tvp;
 
-    if (unlikely(os_pending_signals != 0)) {
+    /* only check signals in the main thread */
+    if (!ts->recv_pipe &&
+        unlikely(os_pending_signals != 0)) {
         JSOSSignalHandler *sh;
         uint64_t mask;
         
-        list_for_each(el, &os_signal_handlers) {
+        list_for_each(el, &ts->os_signal_handlers) {
             sh = list_entry(el, JSOSSignalHandler, link);
             mask = (uint64_t)1 << sh->sig_num;
             if (os_pending_signals & mask) {
@@ -1965,14 +2143,15 @@ static int js_os_poll(JSContext *ctx)
             }
         }
     }
-    
-    if (list_empty(&os_rw_handlers) && list_empty(&os_timers))
+
+    if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) &&
+        list_empty(&ts->port_list))
         return -1; /* no more events */
     
-    if (!list_empty(&os_timers)) {
+    if (!list_empty(&ts->os_timers)) {
         cur_time = get_time_ms();
         min_delay = 10000;
-        list_for_each(el, &os_timers) {
+        list_for_each(el, &ts->os_timers) {
             JSOSTimer *th = list_entry(el, JSOSTimer, link);
             delay = th->timeout - cur_time;
             if (delay <= 0) {
@@ -1980,9 +2159,9 @@ static int js_os_poll(JSContext *ctx)
                 /* the timer expired */
                 func = th->func;
                 th->func = JS_UNDEFINED;
-                unlink_timer(JS_GetRuntime(ctx), th);
+                unlink_timer(rt, th);
                 if (!th->has_object)
-                    free_timer(JS_GetRuntime(ctx), th);
+                    free_timer(rt, th);
                 call_handler(ctx, func);
                 JS_FreeValue(ctx, func);
                 return 0;
@@ -2000,7 +2179,7 @@ static int js_os_poll(JSContext *ctx)
     FD_ZERO(&rfds);
     FD_ZERO(&wfds);
     fd_max = -1;
-    list_for_each(el, &os_rw_handlers) {
+    list_for_each(el, &ts->os_rw_handlers) {
         rh = list_entry(el, JSOSRWHandler, link);
         fd_max = max_int(fd_max, rh->fd);
         if (!JS_IsNull(rh->rw_func[0]))
@@ -2008,25 +2187,46 @@ static int js_os_poll(JSContext *ctx)
         if (!JS_IsNull(rh->rw_func[1]))
             FD_SET(rh->fd, &wfds);
     }
-    
+
+    list_for_each(el, &ts->port_list) {
+        JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
+        if (!JS_IsNull(port->on_message_func)) {
+            JSWorkerMessagePipe *ps = port->recv_pipe;
+            fd_max = max_int(fd_max, ps->read_fd);
+            FD_SET(ps->read_fd, &rfds);
+        }
+    }
+
     ret = select(fd_max + 1, &rfds, &wfds, NULL, tvp);
     if (ret > 0) {
-        list_for_each(el, &os_rw_handlers) {
+        list_for_each(el, &ts->os_rw_handlers) {
             rh = list_entry(el, JSOSRWHandler, link);
             if (!JS_IsNull(rh->rw_func[0]) &&
                 FD_ISSET(rh->fd, &rfds)) {
                 call_handler(ctx, rh->rw_func[0]);
                 /* must stop because the list may have been modified */
-                break;
+                goto done;
             }
-            if (!JS_IsNull(rh->rw_func[1])) {
-                FD_SET(rh->fd, &wfds);
+            if (!JS_IsNull(rh->rw_func[1]) &&
+                FD_ISSET(rh->fd, &wfds)) {
                 call_handler(ctx, rh->rw_func[1]);
                 /* must stop because the list may have been modified */
-                break;
+                goto done;
+            }
+        }
+
+        list_for_each(el, &ts->port_list) {
+            JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
+            if (!JS_IsNull(port->on_message_func)) {
+                JSWorkerMessagePipe *ps = port->recv_pipe;
+                if (FD_ISSET(ps->read_fd, &rfds)) {
+                    if (handle_posted_message(rt, ctx, port))
+                        goto done;
+                }
             }
         }
     }
+    done:
     return 0;
 }
 #endif /* !_WIN32 */
@@ -2071,8 +2271,6 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
     return make_string_error(ctx, buf, err);
 }
 
-#if !defined(_WIN32)
-
 static JSValue js_os_chdir(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
@@ -2087,28 +2285,6 @@ static JSValue js_os_chdir(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, err);
 }
 
-/* return [path, errorcode] */
-static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
-{
-    const char *path;
-    char buf[PATH_MAX], *res;
-    int err;
-
-    path = JS_ToCString(ctx, argv[0]);
-    if (!path)
-        return JS_EXCEPTION;
-    res = realpath(path, buf);
-    JS_FreeCString(ctx, path);
-    if (!res) {
-        buf[0] = '\0';
-        err = errno;
-    } else {
-        err = 0;
-    }
-    return make_string_error(ctx, buf, err);
-}
-
 static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
@@ -2124,15 +2300,66 @@ static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
+#if defined(_WIN32)
+    (void)mode;
+    ret = js_get_errno(mkdir(path));
+#else
     ret = js_get_errno(mkdir(path, mode));
+#endif
     JS_FreeCString(ctx, path);
     return JS_NewInt32(ctx, ret);
 }
 
+/* return [array, errorcode] */
+static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    const char *path;
+    DIR *f;
+    struct dirent *d;
+    JSValue obj;
+    int err;
+    uint32_t len;
+    
+    path = JS_ToCString(ctx, argv[0]);
+    if (!path)
+        return JS_EXCEPTION;
+    obj = JS_NewArray(ctx);
+    if (JS_IsException(obj)) {
+        JS_FreeCString(ctx, path);
+        return JS_EXCEPTION;
+    }
+    f = opendir(path);
+    if (!f)
+        err = errno;
+    else
+        err = 0;
+    JS_FreeCString(ctx, path);
+    if (!f)
+        goto done;
+    len = 0;
+    for(;;) {
+        errno = 0;
+        d = readdir(f);
+        if (!d) {
+            err = errno;
+            break;
+        }
+        JS_DefinePropertyValueUint32(ctx, obj, len++,
+                                     JS_NewString(ctx, d->d_name),
+                                     JS_PROP_C_W_E);
+    }
+    closedir(f);
+ done:
+    return make_obj_error(ctx, obj, err);
+}
+
+#if !defined(_WIN32)
 static int64_t timespec_to_ms(const struct timespec *tv)
 {
     return (int64_t)tv->tv_sec * 1000 + (tv->tv_nsec / 1000000);
 }
+#endif
 
 /* return [obj, errcode] */
 static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
@@ -2146,10 +2373,14 @@ static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
+#if defined(_WIN32)
+    res = stat(path, &st);
+#else
     if (is_lstat)
         res = lstat(path, &st);
     else
         res = stat(path, &st);
+#endif
     JS_FreeCString(ctx, path);
     if (res < 0) {
         err = errno;
@@ -2183,10 +2414,22 @@ static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
         JS_DefinePropertyValueStr(ctx, obj, "size",
                                   JS_NewInt64(ctx, st.st_size),
                                   JS_PROP_C_W_E);
+#if !defined(_WIN32)
         JS_DefinePropertyValueStr(ctx, obj, "blocks",
                                   JS_NewInt64(ctx, st.st_blocks),
                                   JS_PROP_C_W_E);
-#if defined(__APPLE__)
+#endif
+#if defined(_WIN32)
+        JS_DefinePropertyValueStr(ctx, obj, "atime",
+                                  JS_NewInt64(ctx, (int64_t)st.st_atime * 1000),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "mtime",
+                                  JS_NewInt64(ctx, (int64_t)st.st_mtime * 1000),
+                                  JS_PROP_C_W_E);
+        JS_DefinePropertyValueStr(ctx, obj, "ctime",
+                                  JS_NewInt64(ctx, (int64_t)st.st_ctime * 1000),
+                                  JS_PROP_C_W_E);
+#elif defined(__APPLE__)
         JS_DefinePropertyValueStr(ctx, obj, "atime",
                                   JS_NewInt64(ctx, timespec_to_ms(&st.st_atimespec)),
                                   JS_PROP_C_W_E);
@@ -2211,120 +2454,113 @@ static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
     return make_obj_error(ctx, obj, err);
 }
 
-static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
+#if !defined(_WIN32)
+static void ms_to_timeval(struct timeval *tv, uint64_t v)
 {
-    const char *target, *linkpath;
-    int err;
-    
-    target = JS_ToCString(ctx, argv[0]);
-    if (!target)
-        return JS_EXCEPTION;
-    linkpath = JS_ToCString(ctx, argv[1]);
-    if (!linkpath) {
-        JS_FreeCString(ctx, target);
-        return JS_EXCEPTION;
-    }
-    err = js_get_errno(symlink(target, linkpath));
-    JS_FreeCString(ctx, target);
-    JS_FreeCString(ctx, linkpath);
-    return JS_NewInt32(ctx, err);
+    tv->tv_sec = v / 1000;
+    tv->tv_usec = (v % 1000) * 1000;
 }
+#endif
 
-/* return [path, errorcode] */
-static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
+static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv)
 {
     const char *path;
-    char buf[PATH_MAX];
-    int err;
-    ssize_t res;
+    int64_t atime, mtime;
+    int ret;
     
+    if (JS_ToInt64(ctx, &atime, argv[1]))
+        return JS_EXCEPTION;
+    if (JS_ToInt64(ctx, &mtime, argv[2]))
+        return JS_EXCEPTION;
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
-    res = readlink(path, buf, sizeof(buf) - 1);
-    if (res < 0) {
-        buf[0] = '\0';
-        err = errno;
-    } else {
-        buf[res] = '\0';
-        err = 0;
+#if defined(_WIN32)
+    {
+        struct _utimbuf times;
+        times.actime = atime / 1000;
+        times.modtime = mtime / 1000;
+        ret = js_get_errno(_utime(path, &times));
+    }
+#else
+    {
+        struct timeval times[2];
+        ms_to_timeval(&times[0], atime);
+        ms_to_timeval(&times[1], mtime);
+        ret = js_get_errno(utimes(path, times));
     }
+#endif
     JS_FreeCString(ctx, path);
-    return make_string_error(ctx, buf, err);
+    return JS_NewInt32(ctx, ret);
 }
 
-/* return [array, errorcode] */
-static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv)
+#if !defined(_WIN32)
+
+/* return [path, errorcode] */
+static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
 {
     const char *path;
-    DIR *f;
-    struct dirent *d;
-    JSValue obj;
+    char buf[PATH_MAX], *res;
     int err;
-    uint32_t len;
-    
+
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
-    obj = JS_NewArray(ctx);
-    if (JS_IsException(obj)) {
-        JS_FreeCString(ctx, path);
-        return JS_EXCEPTION;
-    }
-    f = opendir(path);
-    if (!f)
+    res = realpath(path, buf);
+    JS_FreeCString(ctx, path);
+    if (!res) {
+        buf[0] = '\0';
         err = errno;
-    else
+    } else {
         err = 0;
-    JS_FreeCString(ctx, path);
-    if (!f)
-        goto done;
-    len = 0;
-    for(;;) {
-        errno = 0;
-        d = readdir(f);
-        if (!d) {
-            err = errno;
-            break;
-        }
-        JS_DefinePropertyValueUint32(ctx, obj, len++,
-                                     JS_NewString(ctx, d->d_name),
-                                     JS_PROP_C_W_E);
     }
-    closedir(f);
- done:
-    return make_obj_error(ctx, obj, err);
+    return make_string_error(ctx, buf, err);
 }
 
-static void ms_to_timeval(struct timeval *tv, uint64_t v)
+static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
 {
-    tv->tv_sec = v / 1000;
-    tv->tv_usec = (v % 1000) * 1000;
+    const char *target, *linkpath;
+    int err;
+    
+    target = JS_ToCString(ctx, argv[0]);
+    if (!target)
+        return JS_EXCEPTION;
+    linkpath = JS_ToCString(ctx, argv[1]);
+    if (!linkpath) {
+        JS_FreeCString(ctx, target);
+        return JS_EXCEPTION;
+    }
+    err = js_get_errno(symlink(target, linkpath));
+    JS_FreeCString(ctx, target);
+    JS_FreeCString(ctx, linkpath);
+    return JS_NewInt32(ctx, err);
 }
 
-static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
-                            int argc, JSValueConst *argv)
+/* return [path, errorcode] */
+static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
 {
     const char *path;
-    int64_t atime, mtime;
-    int ret;
-    struct timeval times[2];
+    char buf[PATH_MAX];
+    int err;
+    ssize_t res;
     
-    if (JS_ToInt64(ctx, &atime, argv[1]))
-        return JS_EXCEPTION;
-    if (JS_ToInt64(ctx, &mtime, argv[2]))
-        return JS_EXCEPTION;
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
-    ms_to_timeval(&times[0], atime);
-    ms_to_timeval(&times[1], mtime);
-    ret = js_get_errno(utimes(path, times));
+    res = readlink(path, buf, sizeof(buf) - 1);
+    if (res < 0) {
+        buf[0] = '\0';
+        err = errno;
+    } else {
+        buf[res] = '\0';
+        err = 0;
+    }
     JS_FreeCString(ctx, path);
-    return JS_NewInt32(ctx, ret);
+    return make_string_error(ctx, buf, err);
 }
 
 static char **build_envp(JSContext *ctx, JSValueConst obj)
@@ -2404,7 +2640,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
     
     path = getenv("PATH");
     if (!path)
-        path = "/bin:/usr/bin";
+        path = (char *)"/bin:/usr/bin";
     eacces_error = FALSE;
     p = path;
     for(p = path; p != NULL; p = p_next) {
@@ -2746,6 +2982,441 @@ static JSValue js_os_dup2(JSContext *ctx, JSValueConst this_val,
 
 #endif /* !_WIN32 */
 
+#ifdef USE_WORKER
+
+/* Worker */
+
+typedef struct {
+    JSWorkerMessagePipe *recv_pipe;
+    JSWorkerMessagePipe *send_pipe;
+    JSWorkerMessageHandler *msg_handler;
+} JSWorkerData;
+
+typedef struct {
+    /* source code of the worker */
+    char *eval_buf;
+    size_t eval_buf_len;
+    JSWorkerMessagePipe *recv_pipe, *send_pipe;
+} WorkerFuncArgs;
+
+typedef struct {
+    int ref_count;
+    uint64_t buf[0];
+} JSSABHeader;
+
+static JSClassID js_worker_class_id;
+
+static int atomic_add_int(int *ptr, int v)
+{
+    return atomic_fetch_add((_Atomic(uint32_t) *)ptr, v) + v;
+}
+
+/* shared array buffer allocator */
+static void *js_sab_alloc(void *opaque, size_t size)
+{
+    JSSABHeader *sab;
+    sab = malloc(sizeof(JSSABHeader) + size);
+    if (!sab)
+        return NULL;
+    sab->ref_count = 1;
+    return sab->buf;
+}
+
+static void js_sab_free(void *opaque, void *ptr)
+{
+    JSSABHeader *sab;
+    int ref_count;
+    sab = (JSSABHeader *)((uint8_t *)ptr - sizeof(JSSABHeader));
+    ref_count = atomic_add_int(&sab->ref_count, -1);
+    assert(ref_count >= 0);
+    if (ref_count == 0) {
+        free(sab);
+    }
+}
+
+static void js_sab_dup(void *opaque, void *ptr)
+{
+    JSSABHeader *sab;
+    sab = (JSSABHeader *)((uint8_t *)ptr - sizeof(JSSABHeader));
+    atomic_add_int(&sab->ref_count, 1);
+}
+
+static JSWorkerMessagePipe *js_new_message_pipe(void)
+{
+    JSWorkerMessagePipe *ps;
+    int pipe_fds[2];
+    
+    if (pipe(pipe_fds) < 0)
+        return NULL;
+
+    ps = malloc(sizeof(*ps));
+    if (!ps) {
+        close(pipe_fds[0]);
+        close(pipe_fds[1]);
+        return NULL;
+    }
+    ps->ref_count = 1;
+    init_list_head(&ps->msg_queue);
+    pthread_mutex_init(&ps->mutex, NULL);
+    ps->read_fd = pipe_fds[0];
+    ps->write_fd = pipe_fds[1];
+    return ps;
+}
+
+static JSWorkerMessagePipe *js_dup_message_pipe(JSWorkerMessagePipe *ps)
+{
+    atomic_add_int(&ps->ref_count, 1);
+    return ps;
+}
+
+static void js_free_message(JSWorkerMessage *msg)
+{
+    size_t i;
+    /* free the SAB */
+    for(i = 0; i < msg->sab_tab_len; i++) {
+        js_sab_free(NULL, msg->sab_tab[i]);
+    }
+    free(msg->sab_tab);
+    free(msg->data);
+    free(msg);
+}
+
+static void js_free_message_pipe(JSWorkerMessagePipe *ps)
+{
+    struct list_head *el, *el1;
+    JSWorkerMessage *msg;
+    int ref_count;
+    
+    if (!ps)
+        return;
+    
+    ref_count = atomic_add_int(&ps->ref_count, -1);
+    assert(ref_count >= 0);
+    if (ref_count == 0) {
+        list_for_each_safe(el, el1, &ps->msg_queue) {
+            msg = list_entry(el, JSWorkerMessage, link);
+            js_free_message(msg);
+        }
+        pthread_mutex_destroy(&ps->mutex);
+        close(ps->read_fd);
+        close(ps->write_fd);
+        free(ps);
+    }
+}
+
+static void js_free_port(JSRuntime *rt, JSWorkerMessageHandler *port)
+{
+    if (port) {
+        js_free_message_pipe(port->recv_pipe);
+        JS_FreeValueRT(rt, port->on_message_func);
+        list_del(&port->link);
+        js_free_rt(rt, port);
+    }
+}
+
+static void js_worker_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSWorkerData *worker = JS_GetOpaque(val, js_worker_class_id);
+    if (worker) {
+        js_free_message_pipe(worker->recv_pipe);
+        js_free_message_pipe(worker->send_pipe);
+        js_free_port(rt, worker->msg_handler);
+        js_free_rt(rt, worker);
+    }
+}
+
+static JSClassDef js_worker_class = {
+    "Worker",
+    .finalizer = js_worker_finalizer,
+}; 
+
+static void *worker_func(void *opaque)
+{
+    WorkerFuncArgs *args = opaque;
+    JSRuntime *rt;
+    JSThreadState *ts;
+    JSContext *ctx;
+    JSValue retval;
+    
+    rt = JS_NewRuntime();
+    if (rt == NULL) {
+        fprintf(stderr, "JS_NewRuntime failure");
+        exit(1);
+    }        
+    js_std_init_handlers(rt);
+
+    /* set the pipe to communicate with the parent */
+    ts = JS_GetRuntimeOpaque(rt);
+    ts->recv_pipe = args->recv_pipe;
+    ts->send_pipe = args->send_pipe;
+    
+    ctx = JS_NewContext(rt);
+    if (ctx == NULL) {
+        fprintf(stderr, "JS_NewContext failure");
+    }
+
+    JS_SetCanBlock(rt, TRUE);
+
+    js_std_add_helpers(ctx, -1, NULL);
+
+    /* system modules */
+    js_init_module_std(ctx, "std");
+    js_init_module_os(ctx, "os");
+
+    retval = JS_Eval(ctx, args->eval_buf, args->eval_buf_len,
+                      "<worker>", JS_EVAL_TYPE_MODULE);
+    free(args->eval_buf);
+    free(args);
+
+    if (JS_IsException(retval))
+        js_std_dump_error(ctx);
+    JS_FreeValue(ctx, retval);
+
+    js_std_loop(ctx);
+
+    JS_FreeContext(ctx);
+    js_std_free_handlers(rt);
+    JS_FreeRuntime(rt);
+    return NULL;
+}
+
+static JSValue js_worker_ctor_internal(JSContext *ctx, JSValueConst new_target,
+                                       JSWorkerMessagePipe *recv_pipe,
+                                       JSWorkerMessagePipe *send_pipe)
+{
+    JSValue obj = JS_UNDEFINED, proto;
+    JSWorkerData *s;
+    
+    /* create the object */
+    if (JS_IsUndefined(new_target)) {
+        proto = JS_GetClassProto(ctx, js_worker_class_id);
+    } else {
+        proto = JS_GetPropertyStr(ctx, new_target, "prototype");
+        if (JS_IsException(proto))
+            goto fail;
+    }
+    obj = JS_NewObjectProtoClass(ctx, proto, js_worker_class_id);
+    JS_FreeValue(ctx, proto);
+    if (JS_IsException(obj))
+        goto fail;
+    s = js_mallocz(ctx, sizeof(*s));
+    if (!s)
+        goto fail;
+    s->recv_pipe = js_dup_message_pipe(recv_pipe);
+    s->send_pipe = js_dup_message_pipe(send_pipe);
+
+    JS_SetOpaque(obj, s);
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
+                              int argc, JSValueConst *argv)
+{
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    WorkerFuncArgs *args;
+    const char *str;
+    size_t str_len;
+    pthread_t tid;
+    pthread_attr_t attr;
+    JSValue obj = JS_UNDEFINED;
+    int ret;
+    
+    /* XXX: in order to avoid problems with resource liberation, we
+       don't support creating workers inside workers */
+    if (!is_main_thread(rt))
+        return JS_ThrowTypeError(ctx, "cannot create a worker inside a worker");
+    
+    /* script source */
+    
+    str = JS_ToCStringLen(ctx, &str_len, argv[0]);
+    if (!str)
+        return JS_EXCEPTION;
+
+    args = malloc(sizeof(*args));
+    if (!args) {
+        JS_ThrowOutOfMemory(ctx);
+        goto fail;
+    }
+    memset(args, 0, sizeof(*args));
+    args->eval_buf = malloc(str_len + 1);
+    if (!args->eval_buf) {
+        JS_ThrowOutOfMemory(ctx);
+        goto fail;
+    }
+    memcpy(args->eval_buf, str, str_len + 1);
+    args->eval_buf_len = str_len;
+    JS_FreeCString(ctx, str);
+    str = NULL;
+
+    /* ports */
+    args->recv_pipe = js_new_message_pipe();
+    if (!args->recv_pipe)
+        goto fail;
+    args->send_pipe = js_new_message_pipe();
+    if (!args->send_pipe)
+        goto fail;
+
+    obj = js_worker_ctor_internal(ctx, new_target,
+                                  args->send_pipe, args->recv_pipe);
+    if (JS_IsUndefined(obj))
+        goto fail;
+    
+    pthread_attr_init(&attr);
+    /* no join at the end */
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    ret = pthread_create(&tid, &attr, worker_func, args);
+    pthread_attr_destroy(&attr);
+    if (ret != 0) {
+        JS_ThrowTypeError(ctx, "could not create worker");
+        goto fail;
+    }
+    return obj;
+ fail:
+    JS_FreeCString(ctx, str);
+    if (args) {
+        free(args->eval_buf);
+        js_free_message_pipe(args->recv_pipe);
+        js_free_message_pipe(args->send_pipe);
+        free(args);
+    }
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
+                                     int argc, JSValueConst *argv)
+{
+    JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
+    JSWorkerMessagePipe *ps;
+    size_t data_len, sab_tab_len, i;
+    uint8_t *data;
+    JSWorkerMessage *msg;
+    uint8_t **sab_tab;
+    
+    if (!worker)
+        return JS_EXCEPTION;
+    
+    data = JS_WriteObject2(ctx, &data_len, argv[0],
+                           JS_WRITE_OBJ_SAB | JS_WRITE_OBJ_REFERENCE,
+                           &sab_tab, &sab_tab_len);
+    if (!data)
+        return JS_EXCEPTION;
+
+    msg = malloc(sizeof(*msg));
+    if (!msg)
+        goto fail;
+    msg->data = NULL;
+    msg->sab_tab = NULL;
+
+    /* must reallocate because the allocator may be different */
+    msg->data = malloc(data_len);
+    if (!msg->data)
+        goto fail;
+    memcpy(msg->data, data, data_len);
+    msg->data_len = data_len;
+
+    msg->sab_tab = malloc(sizeof(msg->sab_tab[0]) * sab_tab_len);
+    if (!msg->sab_tab)
+        goto fail;
+    memcpy(msg->sab_tab, sab_tab, sizeof(msg->sab_tab[0]) * sab_tab_len);
+    msg->sab_tab_len = sab_tab_len;
+
+    js_free(ctx, data);
+    js_free(ctx, sab_tab);
+    
+    /* increment the SAB reference counts */
+    for(i = 0; i < msg->sab_tab_len; i++) {
+        js_sab_dup(NULL, msg->sab_tab[i]);
+    }
+
+    ps = worker->send_pipe;
+    pthread_mutex_lock(&ps->mutex);
+    /* indicate that data is present */
+    if (list_empty(&ps->msg_queue)) {
+        uint8_t ch = '\0';
+        int ret;
+        for(;;) {
+            ret = write(ps->write_fd, &ch, 1);
+            if (ret == 1)
+                break;
+            if (ret < 0 && (errno != EAGAIN || errno != EINTR))
+                break;
+        }
+    }
+    list_add_tail(&msg->link, &ps->msg_queue);
+    pthread_mutex_unlock(&ps->mutex);
+    return JS_UNDEFINED;
+ fail:
+    if (msg) {
+        free(msg->data);
+        free(msg->sab_tab);
+        free(msg);
+    }
+    js_free(ctx, data);
+    js_free(ctx, sab_tab);
+    return JS_EXCEPTION;
+    
+}
+
+static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
+                                   JSValueConst func)
+{
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
+    JSWorkerMessageHandler *port;
+    
+    if (!worker)
+        return JS_EXCEPTION;
+
+    port = worker->msg_handler;
+    if (JS_IsNull(func)) {
+        if (port) {
+            js_free_port(rt, port);
+            worker->msg_handler = NULL;
+        }
+    } else {
+        if (!JS_IsFunction(ctx, func))
+            return JS_ThrowTypeError(ctx, "not a function");
+        if (!port) {
+            port = js_mallocz(ctx, sizeof(*port));
+            if (!port)
+                return JS_EXCEPTION;
+            port->recv_pipe = js_dup_message_pipe(worker->recv_pipe);
+            port->on_message_func = JS_NULL;
+            list_add_tail(&port->link, &ts->port_list);
+            worker->msg_handler = port;
+        }
+        JS_FreeValue(ctx, port->on_message_func);
+        port->on_message_func = JS_DupValue(ctx, func);
+    }
+    return JS_UNDEFINED;
+}
+
+static JSValue js_worker_get_onmessage(JSContext *ctx, JSValueConst this_val)
+{
+    JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
+    JSWorkerMessageHandler *port;
+    if (!worker)
+        return JS_EXCEPTION;
+    port = worker->msg_handler;
+    if (port) {
+        return JS_DupValue(ctx, port->on_message_func);
+    } else {
+        return JS_NULL;
+    }
+}
+
+static const JSCFunctionListEntry js_worker_proto_funcs[] = {
+    JS_CFUNC_DEF("postMessage", 1, js_worker_postMessage ),
+    JS_CGETSET_DEF("onmessage", js_worker_get_onmessage, js_worker_set_onmessage ),
+};
+
+#endif /* USE_WORKER */
+
 #if defined(_WIN32)
 #define OS_PLATFORM "win32"
 #elif defined(__APPLE__)
@@ -2806,12 +3477,9 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_CFUNC_DEF("clearTimeout", 1, js_os_clearTimeout ),
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
     JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
-#if !defined(_WIN32)
     JS_CFUNC_DEF("chdir", 0, js_os_chdir ),
-    JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
     JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
-    JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
-    JS_CFUNC_MAGIC_DEF("lstat", 1, js_os_stat, 1 ),
+    JS_CFUNC_DEF("readdir", 1, js_os_readdir ),
     /* st_mode constants */
     OS_FLAG(S_IFMT),
     OS_FLAG(S_IFIFO),
@@ -2819,14 +3487,19 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     OS_FLAG(S_IFDIR),
     OS_FLAG(S_IFBLK),
     OS_FLAG(S_IFREG),
+#if !defined(_WIN32)
     OS_FLAG(S_IFSOCK),
     OS_FLAG(S_IFLNK),
     OS_FLAG(S_ISGID),
     OS_FLAG(S_ISUID),
+#endif
+    JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
+    JS_CFUNC_DEF("utimes", 3, js_os_utimes ),
+#if !defined(_WIN32)
+    JS_CFUNC_MAGIC_DEF("lstat", 1, js_os_stat, 1 ),
+    JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
     JS_CFUNC_DEF("symlink", 2, js_os_symlink ),
     JS_CFUNC_DEF("readlink", 1, js_os_readlink ),
-    JS_CFUNC_DEF("readdir", 1, js_os_readdir ),
-    JS_CFUNC_DEF("utimes", 3, js_os_utimes ),
     JS_CFUNC_DEF("exec", 1, js_os_exec ),
     JS_CFUNC_DEF("waitpid", 2, js_os_waitpid ),
     OS_FLAG(WNOHANG),
@@ -2845,7 +3518,35 @@ static int js_os_init(JSContext *ctx, JSModuleDef *m)
     /* OSTimer class */
     JS_NewClassID(&js_os_timer_class_id);
     JS_NewClass(JS_GetRuntime(ctx), js_os_timer_class_id, &js_os_timer_class);
-    
+
+#ifdef USE_WORKER
+    {
+        JSRuntime *rt = JS_GetRuntime(ctx);
+        JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+        JSValue proto, obj;
+        /* Worker class */
+        JS_NewClassID(&js_worker_class_id);
+        JS_NewClass(JS_GetRuntime(ctx), js_worker_class_id, &js_worker_class);
+        proto = JS_NewObject(ctx);
+        JS_SetPropertyFunctionList(ctx, proto, js_worker_proto_funcs, countof(js_worker_proto_funcs));
+        
+        obj = JS_NewCFunction2(ctx, js_worker_ctor, "Worker", 1,
+                               JS_CFUNC_constructor, 0);
+        JS_SetConstructor(ctx, obj, proto);
+        
+        JS_SetClassProto(ctx, js_worker_class_id, proto);
+        
+        /* set 'Worker.parent' if necessary */
+        if (ts->recv_pipe && ts->send_pipe) {
+            JS_DefinePropertyValueStr(ctx, obj, "parent",
+                                      js_worker_ctor_internal(ctx, JS_UNDEFINED, ts->recv_pipe, ts->send_pipe),
+                                      JS_PROP_C_W_E);
+        }
+        
+        JS_SetModuleExport(ctx, m, "Worker", obj);
+    }
+#endif /* USE_WORKER */
+
     return JS_SetModuleExportList(ctx, m, js_os_funcs,
                                   countof(js_os_funcs));
 }
@@ -2857,6 +3558,9 @@ JSModuleDef *js_init_module_os(JSContext *ctx, const char *module_name)
     if (!m)
         return NULL;
     JS_AddModuleExportList(ctx, m, js_os_funcs, countof(js_os_funcs));
+#ifdef USE_WORKER
+    JS_AddModuleExport(ctx, m, "Worker");
+#endif
     return m;
 }
 
@@ -2896,46 +3600,76 @@ void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
     JS_SetPropertyStr(ctx, global_obj, "console", console);
 
     /* same methods as the mozilla JS shell */
-    args = JS_NewArray(ctx);
-    for(i = 0; i < argc; i++) {
-        JS_SetPropertyUint32(ctx, args, i, JS_NewString(ctx, argv[i]));
+    if (argc >= 0) {
+        args = JS_NewArray(ctx);
+        for(i = 0; i < argc; i++) {
+            JS_SetPropertyUint32(ctx, args, i, JS_NewString(ctx, argv[i]));
+        }
+        JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
     }
-    JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
-
+    
     JS_SetPropertyStr(ctx, global_obj, "print",
                       JS_NewCFunction(ctx, js_print, "print", 1));
     JS_SetPropertyStr(ctx, global_obj, "__loadScript",
                       JS_NewCFunction(ctx, js_loadScript, "__loadScript", 1));
     
     JS_FreeValue(ctx, global_obj);
+}
+
+void js_std_init_handlers(JSRuntime *rt)
+{
+    JSThreadState *ts;
+
+    ts = malloc(sizeof(*ts));
+    if (!ts) {
+        fprintf(stderr, "Could not allocate memory for the worker");
+        exit(1);
+    }
+    memset(ts, 0, sizeof(*ts));
+    init_list_head(&ts->os_rw_handlers);
+    init_list_head(&ts->os_signal_handlers);
+    init_list_head(&ts->os_timers);
+    init_list_head(&ts->port_list);
+
+    JS_SetRuntimeOpaque(rt, ts);
 
-    /* XXX: not multi-context */
-    init_list_head(&os_rw_handlers);
-    init_list_head(&os_signal_handlers);
-    init_list_head(&os_timers);
-    os_pending_signals = 0;
+#ifdef USE_WORKER
+    /* set the SharedArrayBuffer memory handlers */
+    {
+        JSSharedArrayBufferFunctions sf;
+        memset(&sf, 0, sizeof(sf));
+        sf.sab_alloc = js_sab_alloc;
+        sf.sab_free = js_sab_free;
+        sf.sab_dup = js_sab_dup;
+        JS_SetSharedArrayBufferFunctions(rt, &sf);
+    }
+#endif
 }
 
 void js_std_free_handlers(JSRuntime *rt)
 {
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     struct list_head *el, *el1;
 
-    list_for_each_safe(el, el1, &os_rw_handlers) {
+    list_for_each_safe(el, el1, &ts->os_rw_handlers) {
         JSOSRWHandler *rh = list_entry(el, JSOSRWHandler, link);
         free_rw_handler(rt, rh);
     }
 
-    list_for_each_safe(el, el1, &os_signal_handlers) {
+    list_for_each_safe(el, el1, &ts->os_signal_handlers) {
         JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
         free_sh(rt, sh);
     }
     
-    list_for_each_safe(el, el1, &os_timers) {
+    list_for_each_safe(el, el1, &ts->os_timers) {
         JSOSTimer *th = list_entry(el, JSOSTimer, link);
         unlink_timer(rt, th);
         if (!th->has_object)
             free_timer(rt, th);
     }
+
+    free(ts);
+    JS_SetRuntimeOpaque(rt, NULL); /* fail safe */
 }
 
 static void js_dump_obj(JSContext *ctx, FILE *f, JSValueConst val)
diff --git a/quickjs/quickjs-libc.h b/quickjs/quickjs-libc.h
index 93a53da614..b105028992 100644
--- a/quickjs/quickjs-libc.h
+++ b/quickjs/quickjs-libc.h
@@ -29,10 +29,15 @@
 
 #include "quickjs.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name);
 JSModuleDef *js_init_module_os(JSContext *ctx, const char *module_name);
 void js_std_add_helpers(JSContext *ctx, int argc, char **argv);
 void js_std_loop(JSContext *ctx);
+void js_std_init_handlers(JSRuntime *rt);
 void js_std_free_handlers(JSRuntime *rt);
 void js_std_dump_error(JSContext *ctx);
 uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename);
@@ -46,4 +51,8 @@ void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                       JSValueConst reason,
                                       JS_BOOL is_handled, void *opaque);
 
+#ifdef __cplusplus
+} /* extern "C" { */
+#endif
+
 #endif /* QUICKJS_LIBC_H */
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 7da72531b1..8fbb7a3938 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -71,6 +71,12 @@
 #define CONFIG_ATOMICS
 #endif
 
+#if !defined(EMSCRIPTEN)
+/* enable stack limitation */
+#define CONFIG_STACK_CHECK
+#endif
+
+
 /* dump object free */
 //#define DUMP_FREE
 //#define DUMP_CLOSURE
@@ -281,7 +287,9 @@ struct JSRuntime {
     void *module_loader_opaque;
 
     BOOL can_block : 8; /* TRUE if Atomics.wait can block */
-
+    /* used to allocate, free and clone SharedArrayBuffers */
+    JSSharedArrayBufferFunctions sab_funcs;
+    
     /* Shape hash table */
     int shape_hash_bits;
     int shape_hash_size;
@@ -392,7 +400,7 @@ typedef struct JSBigDecimal {
 typedef enum {
     JS_AUTOINIT_ID_PROTOTYPE,
     JS_AUTOINIT_ID_MODULE_NS,
-    JS_AUTOINIT_ID_PROP, /* must be last */
+    JS_AUTOINIT_ID_PROP,
 } JSAutoInitIDEnum;
 
 /* must be large enough to have a negligible runtime cost and small
@@ -625,7 +633,6 @@ typedef struct JSRegExp {
 typedef struct JSProxyData {
     JSValue target;
     JSValue handler;
-    JSValue proto;
     uint8_t is_func;
     uint8_t is_revoked;
 } JSProxyData;
@@ -770,6 +777,7 @@ struct JSModuleDef {
     JSValue func_obj; /* only used for JS modules */
     JSModuleInitFunc *init_func; /* only used for C modules */
     BOOL resolved : 8;
+    BOOL func_created : 8;
     BOOL instantiated : 8;
     BOOL evaluated : 8;
     BOOL eval_mark : 8; /* temporary use during js_evaluate_module() */
@@ -799,10 +807,8 @@ typedef struct JSProperty {
         struct {            /* JS_PROP_AUTOINIT */
             /* in order to use only 2 pointers, we compress the realm
                and the init function pointer */
-            union {
-                JSContext *realm; /* for JS_AUTOINIT_ID_PROP */
-                uintptr_t init_id; /* JS_AUTOINIT_ID_x */
-            } u;
+            uintptr_t realm_and_id; /* realm and init_id (JS_AUTOINIT_ID_x)
+                                       in the 2 low bits */
             void *opaque;
         } init;
     } u;
@@ -832,11 +838,13 @@ struct JSShape {
     uint32_t hash; /* current hash value */
     uint32_t prop_hash_mask;
     int prop_size; /* allocated properties */
-    int prop_count;
+    int prop_count; /* include deleted properties */
+    int deleted_prop_count;
     JSShape *shape_hash_next; /* in JSRuntime.shape_hash[h] list */
     JSObject *proto;
     JSShapeProperty prop[0]; /* prop_size elements */
 };
+
 struct JSObject {
     union {
         JSGCObjectHeader header;
@@ -850,7 +858,6 @@ struct JSObject {
             uint8_t fast_array : 1; /* TRUE if u.array is used for get/put */
             uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
             uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
-            uint8_t is_class : 1; /* TRUE if object is a class constructor */
             uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
             uint16_t class_id; /* see JS_CLASS_x */
         };
@@ -1124,7 +1131,7 @@ static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val);
 #endif
 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
 static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx);
-static JSValueConst js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj);
+static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj);
 static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
                                    JSValueConst proto_val, BOOL throw_flag);
 static int js_proxy_isExtensible(JSContext *ctx, JSValueConst obj);
@@ -1136,6 +1143,17 @@ static int JS_CreateProperty(JSContext *ctx, JSObject *p,
                              int flags);
 static int js_string_memcmp(const JSString *p1, const JSString *p2, int len);
 static void reset_weak_ref(JSRuntime *rt, JSObject *p);
+static JSValue js_array_buffer_constructor3(JSContext *ctx,
+                                            JSValueConst new_target,
+                                            uint64_t len, JSClassID class_id,
+                                            uint8_t *buf,
+                                            JSFreeArrayBufferDataFunc *free_func,
+                                            void *opaque, BOOL alloc_flag);
+static JSArrayBuffer *js_get_array_buffer(JSContext *ctx, JSValueConst obj);
+static JSValue js_typed_array_constructor(JSContext *ctx,
+                                          JSValueConst this_val,
+                                          int argc, JSValueConst *argv,
+                                          int classid);
 static BOOL typed_array_is_detached(JSContext *ctx, JSObject *p);
 static uint32_t typed_array_get_length(JSContext *ctx, JSObject *p);
 static JSValue JS_ThrowTypeErrorDetachedArrayBuffer(JSContext *ctx);
@@ -1212,6 +1230,7 @@ static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
                                  void *opaque);
 static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
                                           JSAtom atom, void *opaque);
+void JS_SetUncatchableError(JSContext *ctx, JSValueConst val, BOOL flag);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
 static const JSClassExoticMethods js_string_exotic_methods;
@@ -1361,6 +1380,33 @@ char *js_strdup(JSContext *ctx, const char *str)
     return js_strndup(ctx, str, strlen(str));
 }
 
+static no_inline int js_realloc_array(JSContext *ctx, void **parray,
+                                      int elem_size, int *psize, int req_size)
+{
+    int new_size;
+    size_t slack;
+    void *new_array;
+    /* XXX: potential arithmetic overflow */
+    new_size = max_int(req_size, *psize * 3 / 2);
+    new_array = js_realloc2(ctx, *parray, new_size * elem_size, &slack);
+    if (!new_array)
+        return -1;
+    new_size += slack / elem_size;
+    *psize = new_size;
+    *parray = new_array;
+    return 0;
+}
+
+/* resize the array and update its size if req_size > *psize */
+static inline int js_resize_array(JSContext *ctx, void **parray, int elem_size,
+                                  int *psize, int req_size)
+{
+    if (unlikely(req_size > *psize))
+        return js_realloc_array(ctx, parray, elem_size, psize, req_size);
+    else
+        return 0;
+}
+
 static inline void js_dbuf_init(JSContext *ctx, DynBuf *s)
 {
     dbuf_init2(s, ctx->rt, (DynBufReallocFunc *)js_realloc_rt);
@@ -1379,7 +1425,7 @@ typedef struct JSClassShortDef {
 static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Object, NULL, NULL },                             /* JS_CLASS_OBJECT */
     { JS_ATOM_Array, js_array_finalizer, js_array_mark },       /* JS_CLASS_ARRAY */
-    { JS_ATOM_Error, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_ERROR */
+    { JS_ATOM_Error, NULL, NULL }, /* JS_CLASS_ERROR */
     { JS_ATOM_Number, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_NUMBER */
     { JS_ATOM_String, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_STRING */
     { JS_ATOM_Boolean, js_object_data_finalizer, js_object_data_mark }, /* JS_CLASS_BOOLEAN */
@@ -1426,7 +1472,7 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Set_Iterator, js_map_iterator_finalizer, js_map_iterator_mark }, /* JS_CLASS_SET_ITERATOR */
     { JS_ATOM_Array_Iterator, js_array_iterator_finalizer, js_array_iterator_mark }, /* JS_CLASS_ARRAY_ITERATOR */
     { JS_ATOM_String_Iterator, js_array_iterator_finalizer, js_array_iterator_mark }, /* JS_CLASS_STRING_ITERATOR */
-    { JS_ATOM_RegExp_String_Iterator, js_regexp_string_iterator_finalizer, js_regexp_string_iterator_mark }, /* JS_CLASS_STRING_ITERATOR */
+    { JS_ATOM_RegExp_String_Iterator, js_regexp_string_iterator_finalizer, js_regexp_string_iterator_mark }, /* JS_CLASS_REGEXP_STRING_ITERATOR */
     { JS_ATOM_Generator, js_generator_finalizer, js_generator_mark }, /* JS_CLASS_GENERATOR */
 };
 
@@ -1505,8 +1551,8 @@ static void set_dummy_numeric_ops(JSNumericOperations *ops)
 
 #endif /* CONFIG_BIGNUM */
 
-#if defined(EMSCRIPTEN)
-/* currently no stack limitation */
+#if !defined(CONFIG_STACK_CHECK)
+/* no stack limitation */
 static inline uint8_t *js_get_stack_pointer(void)
 {
     return NULL;
@@ -1729,6 +1775,12 @@ void JS_SetCanBlock(JSRuntime *rt, BOOL can_block)
     rt->can_block = can_block;
 }
 
+void JS_SetSharedArrayBufferFunctions(JSRuntime *rt,
+                                      const JSSharedArrayBufferFunctions *sf)
+{
+    rt->sab_funcs = *sf;
+}
+
 /* return 0 if OK, < 0 if exception */
 int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
                   int argc, JSValueConst *argv)
@@ -4262,9 +4314,10 @@ static no_inline JSShape *js_new_shape2(JSContext *ctx, JSObject *proto,
     memset(sh->prop_hash_end - hash_size, 0, sizeof(sh->prop_hash_end[0]) *
            hash_size);
     sh->prop_hash_mask = hash_size - 1;
-    sh->prop_count = 0;
     sh->prop_size = prop_size;
-
+    sh->prop_count = 0;
+    sh->deleted_prop_count = 0;
+    
     /* insert in the hash table */
     sh->hash = shape_initial_hash(proto);
     sh->is_hashed = TRUE;
@@ -4415,6 +4468,74 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
     return 0;
 }
 
+/* remove the deleted properties. */
+static int compact_properties(JSContext *ctx, JSObject *p)
+{
+    JSShape *sh, *old_sh;
+    void *sh_alloc;
+    intptr_t h;
+    uint32_t new_hash_size, i, j, new_hash_mask, new_size;
+    JSShapeProperty *old_pr, *pr;
+    JSProperty *prop, *new_prop;
+    
+    sh = p->shape;
+    assert(!sh->is_hashed);
+
+    new_size = max_int(JS_PROP_INITIAL_SIZE,
+                       sh->prop_count - sh->deleted_prop_count);
+    assert(new_size <= sh->prop_size);
+
+    new_hash_size = sh->prop_hash_mask + 1;
+    while ((new_hash_size / 2) >= new_size)
+        new_hash_size = new_hash_size / 2;
+    new_hash_mask = new_hash_size - 1;
+
+    /* resize the hash table and the properties */
+    old_sh = sh;
+    sh_alloc = js_malloc(ctx, get_shape_size(new_hash_size, new_size));
+    if (!sh_alloc)
+        return -1;
+    sh = get_shape_from_alloc(sh_alloc, new_hash_size);
+    list_del(&old_sh->header.link);
+    memcpy(sh, old_sh, sizeof(JSShape));
+    list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
+    
+    memset(sh->prop_hash_end - new_hash_size, 0,
+           sizeof(sh->prop_hash_end[0]) * new_hash_size);
+
+    j = 0;
+    old_pr = old_sh->prop;
+    pr = sh->prop;
+    prop = p->prop;
+    for(i = 0; i < sh->prop_count; i++) {
+        if (old_pr->atom != JS_ATOM_NULL) {
+            pr->atom = old_pr->atom;
+            pr->flags = old_pr->flags;
+            h = ((uintptr_t)old_pr->atom & new_hash_mask);
+            pr->hash_next = sh->prop_hash_end[-h - 1];
+            sh->prop_hash_end[-h - 1] = j + 1;
+            prop[j] = prop[i];
+            j++;
+            pr++;
+        }
+        old_pr++;
+    }
+    assert(j == (sh->prop_count - sh->deleted_prop_count));
+    sh->prop_hash_mask = new_hash_mask;
+    sh->prop_size = new_size;
+    sh->deleted_prop_count = 0;
+    sh->prop_count = j;
+
+    p->shape = sh;
+    js_free(ctx, get_alloc_from_shape(old_sh));
+    
+    /* reduce the size of the object properties */
+    new_prop = js_realloc(ctx, p->prop, sizeof(new_prop[0]) * new_size);
+    if (new_prop)
+        p->prop = new_prop;
+    return 0;
+}
+
 static int add_shape_property(JSContext *ctx, JSShape **psh,
                               JSObject *p, JSAtom atom, int prop_flags)
 {
@@ -4571,7 +4692,6 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     p->fast_array = 0;
     p->is_constructor = 0;
     p->is_uncatchable_error = 0;
-    p->is_class = 0;
     p->tmp_mark = 0;
     p->first_weak_ref = NULL;
     p->u.opaque = NULL;
@@ -4621,7 +4741,6 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
         p->u.array.u.ptr = NULL;
         p->u.array.count = 0;
         break;
-    case JS_CLASS_ERROR:
     case JS_CLASS_NUMBER:
     case JS_CLASS_STRING:
     case JS_CLASS_BOOLEAN:
@@ -4967,19 +5086,25 @@ JSValue JS_NewCFunctionData(JSContext *ctx, JSCFunctionData *func,
     return func_obj;
 }
 
+static JSContext *js_autoinit_get_realm(JSProperty *pr)
+{
+    return (JSContext *)(pr->u.init.realm_and_id & ~3);
+}
+
+static JSAutoInitIDEnum js_autoinit_get_id(JSProperty *pr)
+{
+    return pr->u.init.realm_and_id & 3;
+}
+
 static void js_autoinit_free(JSRuntime *rt, JSProperty *pr)
 {
-    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
-        JS_FreeContext(pr->u.init.u.realm);
-    }
+    JS_FreeContext(js_autoinit_get_realm(pr));
 }
 
 static void js_autoinit_mark(JSRuntime *rt, JSProperty *pr,
                              JS_MarkFunc *mark_func)
 {
-    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
-        mark_func(rt, &pr->u.init.u.realm->header);
-    }
+    mark_func(rt, &js_autoinit_get_realm(pr)->header);
 }
 
 static void free_property(JSRuntime *rt, JSProperty *pr, int prop_flags)
@@ -6331,7 +6456,7 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
         backtrace_barrier = FALSE;
         if (js_class_has_bytecode(p->class_id)) {
             JSFunctionBytecode *b;
-            char atom_buf[ATOM_GET_STR_BUF_SIZE];
+            const char *atom_str;
             int line_num1;
 
             b = p->u.func.function_bytecode;
@@ -6339,9 +6464,10 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
             if (b->has_debug) {
                 line_num1 = find_line_num(ctx, b,
                                           sf->cur_pc - b->byte_code_buf - 1);
+                atom_str = JS_AtomToCString(ctx, b->debug.filename);
                 dbuf_printf(&dbuf, " (%s",
-                            JS_AtomGetStr(ctx, atom_buf, sizeof(atom_buf),
-                                          b->debug.filename));
+                            atom_str ? atom_str : "<null>");
+                JS_FreeCString(ctx, atom_str);
                 if (line_num1 != -1)
                     dbuf_printf(&dbuf, ":%d", line_num1);
                 dbuf_putc(&dbuf, ')');
@@ -6459,13 +6585,32 @@ static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSCont
     }
 }
 
+/* never use it directly */
+static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowTypeErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+{
+    char buf[ATOM_GET_STR_BUF_SIZE];
+    return JS_ThrowTypeError(ctx, fmt,
+                             JS_AtomGetStr(ctx, buf, sizeof(buf), atom));
+}
+
+/* never use it directly */
+static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowSyntaxErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+{
+    char buf[ATOM_GET_STR_BUF_SIZE];
+    return JS_ThrowSyntaxError(ctx, fmt,
+                             JS_AtomGetStr(ctx, buf, sizeof(buf), atom));
+}
+
+/* %s is replaced by 'atom'. The macro is used so that gcc can check
+    the format string. */
+#define JS_ThrowTypeErrorAtom(ctx, fmt, atom) __JS_ThrowTypeErrorAtom(ctx, atom, fmt, "")
+#define JS_ThrowSyntaxErrorAtom(ctx, fmt, atom) __JS_ThrowSyntaxErrorAtom(ctx, atom, fmt, "")
+
 static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
 {
     if ((flags & JS_PROP_THROW) ||
         ((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
-        char buf[ATOM_GET_STR_BUF_SIZE];
-        JS_ThrowTypeError(ctx, "%s is read-only",
-                          JS_AtomGetStr(ctx, buf, sizeof(buf), atom));
+        JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", atom);
         return -1;
     } else {
         return FALSE;
@@ -6534,7 +6679,7 @@ static JSValue JS_ThrowTypeErrorNotASymbol(JSContext *ctx)
 static JSValue JS_ThrowReferenceErrorNotDefined(JSContext *ctx, JSAtom name)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
-    return JS_ThrowReferenceError(ctx, "%s is not defined",
+    return JS_ThrowReferenceError(ctx, "'%s' is not defined",
                                   JS_AtomGetStr(ctx, buf, sizeof(buf), name));
 }
 
@@ -6549,11 +6694,33 @@ static JSValue JS_ThrowReferenceErrorUninitialized(JSContext *ctx, JSAtom name)
 static JSValue JS_ThrowTypeErrorInvalidClass(JSContext *ctx, int class_id)
 {
     JSRuntime *rt = ctx->rt;
-    char buf[ATOM_GET_STR_BUF_SIZE];
     JSAtom name;
     name = rt->class_array[class_id].class_name;
-    return JS_ThrowTypeError(ctx, "%s object expected",
-                             JS_AtomGetStr(ctx, buf, sizeof(buf), name));
+    return JS_ThrowTypeErrorAtom(ctx, "%s object expected", name);
+}
+
+static no_inline __exception int __js_poll_interrupts(JSContext *ctx)
+{
+    JSRuntime *rt = ctx->rt;
+    ctx->interrupt_counter = JS_INTERRUPT_COUNTER_INIT;
+    if (rt->interrupt_handler) {
+        if (rt->interrupt_handler(rt, rt->interrupt_opaque)) {
+            /* XXX: should set a specific flag to avoid catching */
+            JS_ThrowInternalError(ctx, "interrupted");
+            JS_SetUncatchableError(ctx, ctx->rt->current_exception, TRUE);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static inline __exception int js_poll_interrupts(JSContext *ctx)
+{
+    if (unlikely(--ctx->interrupt_counter <= 0)) {
+        return __js_poll_interrupts(ctx);
+    } else {
+        return 0;
+    }
 }
 
 /* return -1 (exception) or TRUE/FALSE */
@@ -6633,11 +6800,9 @@ int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val)
     return JS_SetPrototypeInternal(ctx, obj, proto_val, TRUE);
 }
 
-/* Return an Object, JS_NULL or JS_EXCEPTION in case of Proxy object. */
-JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val)
+/* Only works for primitive types, otherwise return JS_NULL. */
+static JSValueConst JS_GetPrototypePrimitive(JSContext *ctx, JSValueConst val)
 {
-    JSObject *p;
-
     switch(JS_VALUE_GET_NORM_TAG(val)) {
 #ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
@@ -6664,26 +6829,45 @@ JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val)
         val = ctx->class_proto[JS_CLASS_SYMBOL];
         break;
     case JS_TAG_OBJECT:
-        p = JS_VALUE_GET_OBJ(val);
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+    default:
+        val = JS_NULL;
+        break;
+    }
+    return val;
+}
+
+/* Return an Object, JS_NULL or JS_EXCEPTION in case of Proxy object. */
+JSValue JS_GetPrototype(JSContext *ctx, JSValueConst obj)
+{
+    JSValue val;
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
+        JSObject *p;
+        p = JS_VALUE_GET_OBJ(obj);
         if (unlikely(p->class_id == JS_CLASS_PROXY)) {
-            val = js_proxy_getPrototypeOf(ctx, val);
+            val = js_proxy_getPrototypeOf(ctx, obj);
         } else {
             p = p->shape->proto;
             if (!p)
                 val = JS_NULL;
             else
-                val = JS_MKPTR(JS_TAG_OBJECT, p);
+                val = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
         }
-        break;
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-    default:
-        val = JS_NULL;
-        break;
+    } else {
+        val = JS_DupValue(ctx, JS_GetPrototypePrimitive(ctx, obj));
     }
     return val;
 }
 
+static JSValue JS_GetPrototypeFree(JSContext *ctx, JSValue obj)
+{
+    JSValue obj1;
+    obj1 = JS_GetPrototype(ctx, obj);
+    JS_FreeValue(ctx, obj);
+    return obj1;
+}
+
 /* return TRUE, FALSE or (-1) in case of exception */
 static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValueConst val,
                                    JSValueConst obj)
@@ -6704,7 +6888,6 @@ static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValueConst val,
     /* Only explicitly boxed values are instances of constructors */
     if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
         return FALSE;
-    ret = FALSE;
     obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
     if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
         if (!JS_IsException(obj_proto))
@@ -6717,19 +6900,36 @@ static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValueConst val,
     for(;;) {
         proto1 = p->shape->proto;
         if (!proto1) {
-            if (p->class_id == JS_CLASS_PROXY) {
-                JSValueConst proto_val;
-                proto_val = JS_GetPrototype(ctx, JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
-                if (JS_IsException(proto_val)) {
-                    ret = -1;
-                    goto done;
+            /* slow case if proxy in the prototype chain */
+            if (unlikely(p->class_id == JS_CLASS_PROXY)) {
+                JSValue obj1;
+                obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
+                for(;;) {
+                    obj1 = JS_GetPrototypeFree(ctx, obj1);
+                    if (JS_IsException(obj1)) {
+                        ret = -1;
+                        break;
+                    }
+                    if (JS_IsNull(obj1)) {
+                        ret = FALSE;
+                        break;
+                    }
+                    if (proto == JS_VALUE_GET_OBJ(obj1)) {
+                        JS_FreeValue(ctx, obj1);
+                        ret = TRUE;
+                        break;
+                    }
+                    /* must check for timeout to avoid infinite loop */
+                    if (js_poll_interrupts(ctx)) {
+                        JS_FreeValue(ctx, obj1);
+                        ret = -1;
+                        break;
+                    }
                 }
-                proto1 = JS_VALUE_GET_OBJ(proto_val);
-                if (!proto1)
-                    break;
             } else {
-                break;
+                ret = FALSE;
             }
+            break;
         }
         p = proto1;
         if (proto == p) {
@@ -6767,28 +6967,24 @@ int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj)
     return JS_OrdinaryIsInstanceOf(ctx, val, obj);
 }
 
-static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop, JSProperty *pr)
+typedef int JSAutoInitFunc(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
+
+static JSAutoInitFunc *js_autoinit_func_table[] = {
+    js_instantiate_prototype, /* JS_AUTOINIT_ID_PROTOTYPE */
+    js_module_ns_autoinit, /* JS_AUTOINIT_ID_MODULE_NS */
+    JS_InstantiateFunctionListItem, /* JS_AUTOINIT_ID_PROP */
+};
+
+static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
+                               JSProperty *pr)
 {
     int ret;
     JSContext *realm;
-
-    if (pr->u.init.u.init_id >= JS_AUTOINIT_ID_PROP) {
-        realm = pr->u.init.u.realm;
-        ret = JS_InstantiateFunctionListItem(realm, p, prop, pr->u.init.opaque);
-        if (ret)
-            return ret;
-    } else {
-        switch(pr->u.init.u.init_id) {
-        case JS_AUTOINIT_ID_PROTOTYPE:
-            ret = js_instantiate_prototype(ctx, p, prop, pr->u.init.opaque);
-            break;
-        case JS_AUTOINIT_ID_MODULE_NS:
-            ret = js_module_ns_autoinit(ctx, p, prop, pr->u.init.opaque);
-            break;
-        default:
-            abort();
-        }
-    }
+    JSAutoInitFunc *func;
+    
+    realm = js_autoinit_get_realm(pr);
+    func = js_autoinit_func_table[js_autoinit_get_id(pr)];
+    ret = func(realm, p, prop, pr->u.init.opaque);
     return ret;
 }
 
@@ -6805,8 +7001,9 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
     if (unlikely(tag != JS_TAG_OBJECT)) {
         switch(tag) {
         case JS_TAG_NULL:
+            return JS_ThrowTypeErrorAtom(ctx, "cannot read property '%s' of null", prop);
         case JS_TAG_UNDEFINED:
-            return JS_ThrowTypeError(ctx, "value has no property");
+            return JS_ThrowTypeErrorAtom(ctx, "cannot read property '%s' of undefined", prop);
         case JS_TAG_EXCEPTION:
             return JS_EXCEPTION;
         case JS_TAG_STRING:
@@ -6831,7 +7028,7 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
             break;
         }
         /* cannot raise an exception */
-        p = JS_VALUE_GET_OBJ(JS_GetPrototype(ctx, obj));
+        p = JS_VALUE_GET_OBJ(JS_GetPrototypePrimitive(ctx, obj));
         if (!p)
             return JS_UNDEFINED;
     } else {
@@ -6896,15 +7093,25 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
                 const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
                 if (em) {
                     if (em->get_property) {
+                        JSValue obj1, retval;
                         /* XXX: should pass throw_ref_error */
-                        return em->get_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p),
-                                                prop, this_obj);
+                        /* Note: if 'p' is a prototype, it can be
+                           freed in the called function */
+                        obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+                        retval = em->get_property(ctx, obj1, prop, this_obj);
+                        JS_FreeValue(ctx, obj1);
+                        return retval;
                     }
                     if (em->get_own_property) {
                         JSPropertyDescriptor desc;
                         int ret;
+                        JSValue obj1;
 
-                        ret = em->get_own_property(ctx, &desc, JS_MKPTR(JS_TAG_OBJECT, p), prop);
+                        /* Note: if 'p' is a prototype, it can be
+                           freed in the called function */
+                        obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+                        ret = em->get_own_property(ctx, &desc, obj1, prop);
+                        JS_FreeValue(ctx, obj1);
                         if (ret < 0)
                             return JS_EXCEPTION;
                         if (ret) {
@@ -6932,9 +7139,8 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
 
 static JSValue JS_ThrowTypeErrorPrivateNotFound(JSContext *ctx, JSAtom atom)
 {
-    char buf[ATOM_GET_STR_BUF_SIZE];
-    return JS_ThrowTypeError(ctx, "private class field %s does not exist",
-                      JS_AtomGetStr(ctx, buf, sizeof(buf), atom));
+    return JS_ThrowTypeErrorAtom(ctx, "private class field '%s' does not exist",
+                                 atom);
 }
 
 /* Private fields can be added even on non extensible objects or
@@ -6960,9 +7166,8 @@ static int JS_DefinePrivateField(JSContext *ctx, JSValueConst obj,
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (prs) {
-        char buf[ATOM_GET_STR_BUF_SIZE];
-        JS_ThrowTypeError(ctx, "private class field %s already exists",
-                          JS_AtomGetStr(ctx, buf, sizeof(buf), prop));
+        JS_ThrowTypeErrorAtom(ctx, "private class field '%s' already exists",
+                              prop);
         goto fail;
     }
     pr = add_property(ctx, p, prop, JS_PROP_C_W_E);
@@ -7211,7 +7416,9 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
                 JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
                 return -1;
             }
-            num_keys_count += p->u.array.count;
+            if (flags & JS_GPN_STRING_MASK) {
+                num_keys_count += p->u.array.count;
+            }
         } else {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
             if (em && em->get_own_property_names) {
@@ -7293,15 +7500,17 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
 
     if (p->is_exotic) {
         if (p->fast_array) {
-            for(i = 0; i < p->u.array.count; i++) {
-                tab_atom[num_index].atom = __JS_AtomFromUInt32(i);
-                if (tab_atom[num_index].atom == JS_ATOM_NULL) {
-                    js_free_prop_enum(ctx, tab_exotic, exotic_count);
-                    js_free_prop_enum(ctx, tab_atom, num_index);
-                    return -1;
+            if (flags & JS_GPN_STRING_MASK) {
+                for(i = 0; i < p->u.array.count; i++) {
+                    tab_atom[num_index].atom = __JS_AtomFromUInt32(i);
+                    if (tab_atom[num_index].atom == JS_ATOM_NULL) {
+                        js_free_prop_enum(ctx, tab_exotic, exotic_count);
+                        js_free_prop_enum(ctx, tab_atom, num_index);
+                        return -1;
+                    }
+                    tab_atom[num_index].is_enumerable = TRUE;
+                    num_index++;
                 }
-                tab_atom[num_index].is_enumerable = TRUE;
-                num_index++;
             }
         }
         if (exotic_count > 0) {
@@ -7492,6 +7701,7 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
 {
     JSObject *p;
     int ret;
+    JSValue obj1;
 
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         return FALSE;
@@ -7499,10 +7709,18 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
     for(;;) {
         if (p->is_exotic) {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
-            if (em && em->has_property)
-                return em->has_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p), prop);
+            if (em && em->has_property) {
+                /* has_property can free the prototype */
+                obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+                ret = em->has_property(ctx, obj1, prop);
+                JS_FreeValue(ctx, obj1);
+                return ret;
+            }
         }
+        /* JS_GetOwnPropertyInternal can free the prototype */
+        JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
         ret = JS_GetOwnPropertyInternal(ctx, NULL, p, prop);
+        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
         if (ret != 0)
             return ret;
         if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
@@ -7799,6 +8017,7 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
             } else {
                 sh->prop_hash_end[-h1 - 1] = pr->hash_next;
             }
+            sh->deleted_prop_count++;
             /* free the entry */
             pr1 = &p->prop[h - 1];
             free_property(ctx->rt, pr1, pr->flags);
@@ -7807,6 +8026,12 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
             pr->flags = 0;
             pr->atom = JS_ATOM_NULL;
             pr1->u.value = JS_UNDEFINED;
+
+            /* compact the properties if too many deleted properties */
+            if (sh->deleted_prop_count >= 8 &&
+                sh->deleted_prop_count >= ((unsigned)sh->prop_count / 2)) {
+                compact_properties(ctx, p);
+            }
             return TRUE;
         }
         lpr = pr;
@@ -8016,8 +8241,12 @@ static int JS_SetPropertyGeneric(JSContext *ctx,
         if (p->is_exotic) {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
             if (em && em->set_property) {
-                ret = em->set_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p), prop,
+                JSValue obj1;
+                /* set_property can free the prototype */
+                obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+                ret = em->set_property(ctx, obj1, prop,
                                        val, this_obj, flags);
+                JS_FreeValue(ctx, obj1);
                 JS_FreeValue(ctx, val);
                 return ret;
             }
@@ -8110,14 +8339,17 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
     if (unlikely(tag != JS_TAG_OBJECT)) {
         switch(tag) {
         case JS_TAG_NULL:
+            JS_FreeValue(ctx, val);
+            JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of null", prop);
+            return -1;
         case JS_TAG_UNDEFINED:
             JS_FreeValue(ctx, val);
-            JS_ThrowTypeError(ctx, "value has no property");
+            JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of undefined", prop);
             return -1;
         default:
             /* even on a primitive type we can have setters on the prototype */
             p = NULL;
-            p1 = JS_VALUE_GET_OBJ(JS_GetPrototype(ctx, this_obj));
+            p1 = JS_VALUE_GET_OBJ(JS_GetPrototypePrimitive(ctx, this_obj));
             goto prototype_lookup;
         }
     }
@@ -8195,15 +8427,22 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
             } else {
                 const JSClassExoticMethods *em = ctx->rt->class_array[p1->class_id].exotic;
                 if (em) {
+                    JSValue obj1;
                     if (em->set_property) {
-                        ret = em->set_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p1), prop,
+                        /* set_property can free the prototype */
+                        obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p1));
+                        ret = em->set_property(ctx, obj1, prop,
                                                val, this_obj, flags);
+                        JS_FreeValue(ctx, obj1);
                         JS_FreeValue(ctx, val);
                         return ret;
                     }
                     if (em->get_own_property) {
+                        /* get_own_property can free the prototype */
+                        obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p1));
                         ret = em->get_own_property(ctx, &desc,
-                                                   JS_MKPTR(JS_TAG_OBJECT, p1), prop);
+                                                   obj1, prop);
+                        JS_FreeValue(ctx, obj1);
                         if (ret < 0) {
                             JS_FreeValue(ctx, val);
                             return ret;
@@ -8973,11 +9212,10 @@ static int JS_DefineAutoInitProperty(JSContext *ctx, JSValueConst this_obj,
     pr = add_property(ctx, p, prop, (flags & JS_PROP_C_W_E) | JS_PROP_AUTOINIT);
     if (unlikely(!pr))
         return -1;
-    if (id == JS_AUTOINIT_ID_PROP) {
-        pr->u.init.u.realm = JS_DupContext(ctx);
-    } else {
-        pr->u.init.u.init_id = id;
-    }
+    pr->u.init.realm_and_id = (uintptr_t)JS_DupContext(ctx);
+    assert((pr->u.init.realm_and_id & 3) == 0);
+    assert(id <= 3);
+    pr->u.init.realm_and_id |= id;
     pr->u.init.opaque = opaque;
     return TRUE;
 }
@@ -9114,9 +9352,7 @@ static int JS_DefineObjectNameComputed(JSContext *ctx, JSValueConst obj,
 
 static JSValue JS_ThrowSyntaxErrorVarRedeclaration(JSContext *ctx, JSAtom prop)
 {
-    char buf[ATOM_GET_STR_BUF_SIZE];
-    return JS_ThrowSyntaxError(ctx, "redeclaration of %s",
-                               JS_AtomGetStr(ctx, buf, sizeof(buf), prop));
+    return JS_ThrowSyntaxErrorAtom(ctx, "redeclaration of '%s'", prop);
 }
 
 /* flags is 0, DEFINE_GLOBAL_LEX_VAR or DEFINE_GLOBAL_FUNC_VAR */
@@ -9125,7 +9361,6 @@ static int JS_CheckDefineGlobalVar(JSContext *ctx, JSAtom prop, int flags)
 {
     JSObject *p;
     JSShapeProperty *prs;
-    char buf[ATOM_GET_STR_BUF_SIZE];
 
     p = JS_VALUE_GET_OBJ(ctx->global_obj);
     prs = find_own_property1(p, prop);
@@ -9143,8 +9378,8 @@ static int JS_CheckDefineGlobalVar(JSContext *ctx, JSAtom prop, int flags)
                      ((prs->flags & (JS_PROP_WRITABLE | JS_PROP_ENUMERABLE)) !=
                       (JS_PROP_WRITABLE | JS_PROP_ENUMERABLE)))) {
                 define_error:
-                    JS_ThrowTypeError(ctx, "cannot define variable %s",
-                                      JS_AtomGetStr(ctx, buf, sizeof(buf), prop));
+                    JS_ThrowTypeErrorAtom(ctx, "cannot define variable '%s'",
+                                          prop);
                     return -1;
                 }
             }
@@ -11395,7 +11630,9 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
                     printf("[varref %p]", (void *)pr->u.var_ref);
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                    printf("[autoinit %p %p]", (void *)pr->u.init.u.realm,
+                    printf("[autoinit %p %d %p]",
+                           (void *)js_autoinit_get_realm(pr),
+                           js_autoinit_get_id(pr),
                            (void *)pr->u.init.opaque);
                 } else {
                     JS_DumpValueShort(rt, pr->u.value);
@@ -15726,30 +15963,6 @@ static JSValue js_call_bound_function(JSContext *ctx, JSValueConst func_obj,
     }
 }
 
-static no_inline __exception int __js_poll_interrupts(JSContext *ctx)
-{
-    JSRuntime *rt = ctx->rt;
-    ctx->interrupt_counter = JS_INTERRUPT_COUNTER_INIT;
-    if (rt->interrupt_handler) {
-        if (rt->interrupt_handler(rt, rt->interrupt_opaque)) {
-            /* XXX: should set a specific flag to avoid catching */
-            JS_ThrowInternalError(ctx, "interrupted");
-            JS_SetUncatchableError(ctx, ctx->rt->current_exception, TRUE);
-            return -1;
-        }
-    }
-    return 0;
-}
-
-static inline __exception int js_poll_interrupts(JSContext *ctx)
-{
-    if (unlikely(--ctx->interrupt_counter <= 0)) {
-        return __js_poll_interrupts(ctx);
-    } else {
-        return 0;
-    }
-}
-
 /* argument of OP_special_object */
 typedef enum {
     OP_SPECIAL_OBJECT_ARGUMENTS,
@@ -16440,7 +16653,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
         CASE(OP_get_super):
             {
                 JSValue proto;
-                proto = JS_DupValue(ctx, JS_GetPrototype(ctx, sp[-1]));
+                proto = JS_GetPrototype(ctx, sp[-1]);
                 if (JS_IsException(proto))
                     goto exception;
                 JS_FreeValue(ctx, sp[-1]);
@@ -18543,6 +18756,9 @@ static JSValue async_func_resume(JSContext *ctx, JSAsyncFunctionState *s)
 {
     JSValue func_obj;
 
+    if (js_check_stack_overflow(ctx->rt, 0))
+        return JS_ThrowStackOverflow(ctx);
+
     /* the tag does not matter provided it is not an object */
     func_obj = JS_MKPTR(JS_TAG_INT, s);
     return JS_CallInternal(ctx, func_obj, s->this_val, JS_UNDEFINED,
@@ -19670,8 +19886,8 @@ typedef struct JSFunctionDef {
 
     /* constant pool (strings, functions, numbers) */
     JSValue *cpool;
-    uint32_t cpool_count;
-    uint32_t cpool_size;
+    int cpool_count;
+    int cpool_size;
 
     /* list of variables in the closure */
     int closure_var_count;
@@ -19741,6 +19957,7 @@ typedef struct JSParseState {
     JSFunctionDef *cur_func;
     BOOL is_module; /* parsing a module */
     BOOL allow_html_comments;
+    BOOL ext_json; /* true if accepting JSON superset */
 } JSParseState;
 
 typedef struct JSOpCode {
@@ -20308,23 +20525,18 @@ static __exception int next_token(JSParseState *s)
     c = *p;
     switch(c) {
     case 0:
-        s->token.val = TOK_EOF;
-        break;
-    case '`':
-        if (!s->cur_func) {
-            /* JSON does not accept templates */
+        if (p >= s->buf_end) {
+            s->token.val = TOK_EOF;
+        } else {
             goto def_token;
         }
+        break;
+    case '`':
         if (js_parse_template_part(s, p + 1))
             goto fail;
         p = s->buf_ptr;
         break;
     case '\'':
-        if (!s->cur_func) {
-            /* JSON does not accept single quoted strings */
-            goto def_token;
-        }
-        /* fall through */
     case '\"':
         if (js_parse_string(s, c, TRUE, p + 1, &s->token, &p))
             goto fail;
@@ -20342,11 +20554,6 @@ static __exception int next_token(JSParseState *s)
         goto redo;
     case '\f':
     case '\v':
-        if (!s->cur_func) {
-            /* JSONWhitespace does not match <VT>, nor <FF> */
-            goto def_token;
-        }
-        /* fall through */
     case ' ':
     case '\t':
         p++;
@@ -20443,16 +20650,15 @@ static __exception int next_token(JSParseState *s)
         s->token.u.ident.is_reserved = FALSE;
         if (s->token.u.ident.atom <= JS_ATOM_LAST_KEYWORD ||
             (s->token.u.ident.atom <= JS_ATOM_LAST_STRICT_KEYWORD &&
-             s->cur_func && (s->cur_func->js_mode & JS_MODE_STRICT)) ||
-            (s->token.u.ident.atom == JS_ATOM_yield && s->cur_func &&
+             (s->cur_func->js_mode & JS_MODE_STRICT)) ||
+            (s->token.u.ident.atom == JS_ATOM_yield &&
              ((s->cur_func->func_kind & JS_FUNC_GENERATOR) ||
               (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
                !s->cur_func->in_function_body && s->cur_func->parent &&
                (s->cur_func->parent->func_kind & JS_FUNC_GENERATOR)))) ||
             (s->token.u.ident.atom == JS_ATOM_await &&
              (s->is_module ||
-              (s->cur_func &&
-               ((s->cur_func->func_kind & JS_FUNC_ASYNC) ||
+              (((s->cur_func->func_kind & JS_FUNC_ASYNC) ||
                 (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
                  !s->cur_func->in_function_body && s->cur_func->parent &&
                  (s->cur_func->parent->func_kind & JS_FUNC_ASYNC))))))) {
@@ -20505,9 +20711,8 @@ static __exception int next_token(JSParseState *s)
         }
         break;
     case '0':
-        /* in strict or JSON parsing mode, octal literals are not accepted */
-        if (is_digit(p[1]) && (!s->cur_func ||
-                               (s->cur_func->js_mode & JS_MODE_STRICT))) {
+        /* in strict mode, octal literals are not accepted */
+        if (is_digit(p[1]) && (s->cur_func->js_mode & JS_MODE_STRICT)) {
             js_parse_error(s, "octal literals are deprecated in strict mode");
             goto fail;
         }
@@ -20519,22 +20724,17 @@ static __exception int next_token(JSParseState *s)
             JSValue ret;
             const uint8_t *p1;
             int flags, radix;
-            if (!s->cur_func) {
-                flags = 0;
-                radix = 10;
-            } else {
-                flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL |
-                    ATOD_ACCEPT_UNDERSCORES;
+            flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL |
+                ATOD_ACCEPT_UNDERSCORES;
 #ifdef CONFIG_BIGNUM
-                flags |= ATOD_ACCEPT_SUFFIX;
-                if (s->cur_func->js_mode & JS_MODE_MATH) {
-                    flags |= ATOD_MODE_BIGINT;
-                    if (s->cur_func->js_mode & JS_MODE_MATH)
-                        flags |= ATOD_TYPE_BIG_FLOAT;
-                }
-#endif
-                radix = 0;
+            flags |= ATOD_ACCEPT_SUFFIX;
+            if (s->cur_func->js_mode & JS_MODE_MATH) {
+                flags |= ATOD_MODE_BIGINT;
+                if (s->cur_func->js_mode & JS_MODE_MATH)
+                    flags |= ATOD_TYPE_BIG_FLOAT;
             }
+#endif
+            radix = 0;
 #ifdef CONFIG_BIGNUM
             s->token.u.num.exponent = 0;
             ret = js_atof2(s->ctx, (const char *)p, (const char **)&p, radix,
@@ -20699,7 +20899,7 @@ static __exception int next_token(JSParseState *s)
     case '^':
         if (p[1] == '=') {
             p += 2;
-            if (s->cur_func && (s->cur_func->js_mode & JS_MODE_MATH))
+            if (s->cur_func->js_mode & JS_MODE_MATH)
                 s->token.val = TOK_MATH_POW_ASSIGN;
             else
                 s->token.val = TOK_XOR_ASSIGN;
@@ -20713,7 +20913,7 @@ static __exception int next_token(JSParseState *s)
             }
         } else {
             p++;
-            if (s->cur_func && (s->cur_func->js_mode & JS_MODE_MATH))
+            if (s->cur_func->js_mode & JS_MODE_MATH)
                 s->token.val = TOK_MATH_POW;
             else
                 s->token.val = '^';
@@ -20758,22 +20958,12 @@ static __exception int next_token(JSParseState *s)
             switch(c) {
             case CP_PS:
             case CP_LS:
-                if (!s->cur_func) {
-                    /* <PS> and <LS> are not JSONWhitespace */
-                    goto def_token;
-                } else {
-                    /* XXX: should avoid incrementing line_number, but
-                       needed to handle HTML comments */
-                    goto line_terminator; 
-                }
+                /* XXX: should avoid incrementing line_number, but
+                   needed to handle HTML comments */
+                goto line_terminator; 
             default:
                 if (lre_is_space(c)) {
-                    if (!s->cur_func) {
-                        /* category z spaces are not JSONWhitespace */
-                        goto def_token;
-                    } else {
-                        goto redo;
-                    }
+                    goto redo;
                 } else if (lre_js_is_ident_first(c)) {
                     ident_has_escape = FALSE;
                     goto has_ident;
@@ -20798,6 +20988,220 @@ static __exception int next_token(JSParseState *s)
     return -1;
 }
 
+/* 'c' is the first character. Return JS_ATOM_NULL in case of error */
+static JSAtom json_parse_ident(JSParseState *s, const uint8_t **pp, int c)
+{
+    const uint8_t *p;
+    char ident_buf[128], *buf;
+    size_t ident_size, ident_pos;
+    JSAtom atom;
+    
+    p = *pp;
+    buf = ident_buf;
+    ident_size = sizeof(ident_buf);
+    ident_pos = 0;
+    for(;;) {
+        buf[ident_pos++] = c;
+        c = *p;
+        if (c >= 128 ||
+            !((lre_id_continue_table_ascii[c >> 5] >> (c & 31)) & 1))
+            break;
+        p++;
+        if (unlikely(ident_pos >= ident_size - UTF8_CHAR_LEN_MAX)) {
+            if (ident_realloc(s->ctx, &buf, &ident_size, ident_buf)) {
+                atom = JS_ATOM_NULL;
+                goto done;
+            }
+        }
+    }
+    atom = JS_NewAtomLen(s->ctx, buf, ident_pos);
+ done:
+    if (unlikely(buf != ident_buf))
+        js_free(s->ctx, buf);
+    *pp = p;
+    return atom;
+}
+
+static __exception int json_next_token(JSParseState *s)
+{
+    const uint8_t *p;
+    int c;
+    JSAtom atom;
+    
+    if (js_check_stack_overflow(s->ctx->rt, 0)) {
+        return js_parse_error(s, "stack overflow");
+    }
+    
+    free_token(s, &s->token);
+
+    p = s->last_ptr = s->buf_ptr;
+    s->last_line_num = s->token.line_num;
+ redo:
+    s->token.line_num = s->line_num;
+    s->token.ptr = p;
+    c = *p;
+    switch(c) {
+    case 0:
+        if (p >= s->buf_end) {
+            s->token.val = TOK_EOF;
+        } else {
+            goto def_token;
+        }
+        break;
+    case '\'':
+        if (!s->ext_json) {
+            /* JSON does not accept single quoted strings */
+            goto def_token;
+        }
+        /* fall through */
+    case '\"':
+        if (js_parse_string(s, c, TRUE, p + 1, &s->token, &p))
+            goto fail;
+        break;
+    case '\r':  /* accept DOS and MAC newline sequences */
+        if (p[1] == '\n') {
+            p++;
+        }
+        /* fall thru */
+    case '\n':
+        p++;
+        s->line_num++;
+        goto redo;
+    case '\f':
+    case '\v':
+        if (!s->ext_json) {
+            /* JSONWhitespace does not match <VT>, nor <FF> */
+            goto def_token;
+        }
+        /* fall through */
+    case ' ':
+    case '\t':
+        p++;
+        goto redo;
+    case '/':
+        if (!s->ext_json) {
+            /* JSON does not accept comments */
+            goto def_token;
+        }
+        if (p[1] == '*') {
+            /* comment */
+            p += 2;
+            for(;;) {
+                if (*p == '\0' && p >= s->buf_end) {
+                    js_parse_error(s, "unexpected end of comment");
+                    goto fail;
+                }
+                if (p[0] == '*' && p[1] == '/') {
+                    p += 2;
+                    break;
+                }
+                if (*p == '\n') {
+                    s->line_num++;
+                    p++;
+                } else if (*p == '\r') {
+                    p++;
+                } else if (*p >= 0x80) {
+                    c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+                    if (c == -1) {
+                        p++; /* skip invalid UTF-8 */
+                    }
+                } else {
+                    p++;
+                }
+            }
+            goto redo;
+        } else if (p[1] == '/') {
+            /* line comment */
+            p += 2;
+            for(;;) {
+                if (*p == '\0' && p >= s->buf_end)
+                    break;
+                if (*p == '\r' || *p == '\n')
+                    break;
+                if (*p >= 0x80) {
+                    c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+                    /* LS or PS are considered as line terminator */
+                    if (c == CP_LS || c == CP_PS) {
+                        break;
+                    } else if (c == -1) {
+                        p++; /* skip invalid UTF-8 */
+                    }
+                } else {
+                    p++;
+                }
+            }
+            goto redo;
+        } else {
+            goto def_token;
+        }
+        break;
+    case 'a' ... 'z':
+    case 'A' ... 'Z':
+    case '_':
+    case '$':
+        /* identifier : only pure ascii characters are accepted */
+        p++;
+        atom = json_parse_ident(s, &p, c);
+        if (atom == JS_ATOM_NULL)
+            goto fail;
+        s->token.u.ident.atom = atom;
+        s->token.u.ident.has_escape = FALSE;
+        s->token.u.ident.is_reserved = FALSE;
+        s->token.val = TOK_IDENT;
+        break;
+    case '+':
+        if (!s->ext_json || !is_digit(p[1]))
+            goto def_token;
+        goto parse_number;
+    case '0':
+        if (is_digit(p[1]))
+            goto def_token;
+        goto parse_number;
+    case '-':
+        if (!is_digit(p[1]))
+            goto def_token;
+        goto parse_number;
+    case '1' ... '9':
+        /* number */
+    parse_number:
+        {
+            JSValue ret;
+            int flags, radix;
+            if (!s->ext_json) {
+                flags = 0;
+                radix = 10;
+            } else {
+                flags = ATOD_ACCEPT_BIN_OCT;
+                radix = 0;
+            }
+            ret = js_atof(s->ctx, (const char *)p, (const char **)&p, radix,
+                          flags);
+            if (JS_IsException(ret))
+                goto fail;
+            s->token.val = TOK_NUMBER;
+            s->token.u.num.val = ret;
+        }
+        break;
+    default:
+        if (c >= 128) {
+            js_parse_error(s, "unexpected character");
+            goto fail;
+        }
+    def_token:
+        s->token.val = c;
+        p++;
+        break;
+    }
+    s->buf_ptr = p;
+
+    //    dump_token(s, &s->token);
+    return 0;
+
+ fail:
+    s->token.val = TOK_ERROR;
+    return -1;
+}
+
 /* only used for ':' and '=>', 'let' or 'function' look-ahead. *pp is
    only set if TOK_IMPORT is returned */
 /* XXX: handle all unicode cases */
@@ -20858,6 +21262,12 @@ static int simple_next_token(const uint8_t **pp, BOOL no_line_terminator)
                     }
                 } else if (c == 'o' && *p == 'f' && !lre_js_is_ident_next(p[1])) {
                     return TOK_OF;
+                } else if (c == 'e' &&
+                           p[0] == 'x' && p[1] == 'p' && p[2] == 'o' &&
+                           p[3] == 'r' && p[4] == 't' &&
+                           !lre_js_is_ident_next(p[5])) {
+                    *pp = p + 5;
+                    return TOK_EXPORT;
                 } else if (c == 'f' && p[0] == 'u' && p[1] == 'n' &&
                          p[2] == 'c' && p[3] == 't' && p[4] == 'i' &&
                          p[5] == 'o' && p[6] == 'n' && !lre_js_is_ident_next(p[7])) {
@@ -20881,16 +21291,21 @@ static int peek_token(JSParseState *s, BOOL no_line_terminator)
    (heuristic). 'input' must be a zero terminated.
 
    Heuristic: skip comments and expect 'import' keyword not followed
-   by '(' or '.'
+   by '(' or '.' or export keyword.
 */
 BOOL JS_DetectModule(const char *input, size_t input_len)
 {
     const uint8_t *p = (const uint8_t *)input;
     int tok;
-    if (simple_next_token(&p, FALSE) != TOK_IMPORT)
+    switch(simple_next_token(&p, FALSE)) {
+    case TOK_IMPORT:
+        tok = simple_next_token(&p, FALSE);
+        return (tok != '.' && tok != '(');
+    case TOK_EXPORT:
+        return TRUE;
+    default:
         return FALSE;
-    tok = simple_next_token(&p, FALSE);
-    return (tok != '.' && tok != '(');
+    }
 }
 
 static inline int get_prev_opcode(JSFunctionDef *fd) {
@@ -20974,20 +21389,10 @@ static int new_label_fd(JSFunctionDef *fd, int label)
     LabelSlot *ls;
 
     if (label < 0) {
-        if (fd->label_count >= fd->label_size) {
-            int new_size;
-            size_t slack;
-            LabelSlot *new_tab;
-
-            /* XXX: potential arithmetic overflow */
-            new_size = fd->label_size * 3 / 2 + 4;
-            new_tab = js_realloc2(fd->ctx, fd->label_slots, new_size * sizeof(*new_tab), &slack);
-            if (!new_tab)
-                return -1;
-            new_size += slack / sizeof(*new_tab);
-            fd->label_slots = new_tab;
-            fd->label_size = new_size;
-        }
+        if (js_resize_array(fd->ctx, (void *)&fd->label_slots,
+                            sizeof(fd->label_slots[0]),
+                            &fd->label_size, fd->label_count + 1))
+            return -1;
         label = fd->label_count++;
         ls = &fd->label_slots[label];
         ls->ref_count = 0;
@@ -21035,19 +21440,10 @@ static int emit_goto(JSParseState *s, int opcode, int label)
 static int cpool_add(JSParseState *s, JSValue val)
 {
     JSFunctionDef *fd = s->cur_func;
-    if (fd->cpool_count >= fd->cpool_size) {
-        int new_size;
-        size_t slack;
-        JSValue *new_tab;
-        /* XXX: potential arithmetic overflow */
-        new_size = max_int(fd->cpool_count + 1, fd->cpool_size * 3 / 2);
-        new_tab = js_realloc2(s->ctx, fd->cpool, new_size * sizeof(JSValue), &slack);
-        if (!new_tab)
-            return -1;
-        new_size += slack / sizeof(*new_tab);
-        fd->cpool = new_tab;
-        fd->cpool_size = new_size;
-    }
+    
+    if (js_resize_array(s->ctx, (void *)&fd->cpool, sizeof(fd->cpool[0]),
+                        &fd->cpool_size, fd->cpool_count + 1))
+        return -1;
     fd->cpool[fd->cpool_count++] = val;
     return fd->cpool_count - 1;
 }
@@ -21246,18 +21642,9 @@ static int add_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
         JS_ThrowInternalError(ctx, "too many local variables");
         return -1;
     }
-    if ((fd->var_count + 1) > fd->var_size) {
-        int new_size;
-        size_t slack;
-        JSVarDef *new_buf;
-        new_size = max_int(fd->var_count + 1, fd->var_size * 3 / 2);
-        new_buf = js_realloc2(ctx, fd->vars, new_size * sizeof(*fd->vars), &slack);
-        if (!new_buf)
-            return -1;
-        new_size += slack / sizeof(*new_buf);
-        fd->vars = new_buf;
-        fd->var_size = new_size;
-    }
+    if (js_resize_array(ctx, (void **)&fd->vars, sizeof(fd->vars[0]),
+                        &fd->var_size, fd->var_count + 1))
+        return -1;
     vd = &fd->vars[fd->var_count++];
     memset(vd, 0, sizeof(*vd));
     vd->var_name = JS_DupAtom(ctx, name);
@@ -21309,18 +21696,9 @@ static int add_arg(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
         JS_ThrowInternalError(ctx, "too many arguments");
         return -1;
     }
-    if ((fd->arg_count + 1) > fd->arg_size) {
-        int new_size;
-        size_t slack;
-        JSVarDef *new_buf;
-        new_size = max_int(fd->arg_count + 1, fd->arg_size * 3 / 2);
-        new_buf = js_realloc2(ctx, fd->args, new_size * sizeof(*fd->args), &slack);
-        if (!new_buf)
-            return -1;
-        new_size += slack / sizeof(*new_buf);
-        fd->args = new_buf;
-        fd->arg_size = new_size;
-    }
+    if (js_resize_array(ctx, (void **)&fd->args, sizeof(fd->args[0]),
+                        &fd->arg_size, fd->arg_count + 1))
+        return -1;
     vd = &fd->args[fd->arg_count++];
     memset(vd, 0, sizeof(*vd));
     vd->var_name = JS_DupAtom(ctx, name);
@@ -21335,19 +21713,10 @@ static JSHoistedDef *add_hoisted_def(JSContext *ctx,
 {
     JSHoistedDef *hf;
 
-    if (s->hoisted_def_count >= s->hoisted_def_size) {
-        int new_size;
-        size_t slack;
-        JSHoistedDef *new_tab;
-        new_size = max_int(s->hoisted_def_count + 1,
-                           s->hoisted_def_size * 3 / 2);
-        new_tab = js_realloc2(ctx, s->hoisted_def, new_size * sizeof(s->hoisted_def[0]), &slack);
-        if (!new_tab)
-            return NULL;
-        new_size += slack / sizeof(*new_tab);
-        s->hoisted_def = new_tab;
-        s->hoisted_def_size = new_size;
-    }
+    if (js_resize_array(ctx, (void **)&s->hoisted_def,
+                        sizeof(s->hoisted_def[0]),
+                        &s->hoisted_def_size, s->hoisted_def_count + 1))
+        return NULL;
     hf = &s->hoisted_def[s->hoisted_def_count++];
     hf->cpool_idx = cpool_idx;
     hf->force_init = 0;
@@ -21639,7 +22008,7 @@ static __exception int js_parse_template(JSParseState *s, int call, int *argc)
             goto done;
         if (next_token(s))
             return -1;
-        if (js_parse_assign_expr(s, TRUE))
+        if (js_parse_expr(s))
             return -1;
         depth++;
         if (s->token.val != '}') {
@@ -21647,7 +22016,8 @@ static __exception int js_parse_template(JSParseState *s, int call, int *argc)
         }
         /* XXX: should convert to string at this stage? */
         free_token(s, &s->token);
-        /* Resume TOK_TEMPLATE parsing (s->token.line_num and s->token.ptr are OK) */
+        /* Resume TOK_TEMPLATE parsing (s->token.line_num and
+         * s->token.ptr are OK) */
         s->got_lf = FALSE;
         s->last_line_num = s->token.line_num;
         if (js_parse_template_part(s, s->buf_ptr))
@@ -21875,7 +22245,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
     size_t level = 0;
     JSParsePos pos;
     int last_tok, tok = TOK_EOF;
-    int tok_len, bits = 0;
+    int c, tok_len, bits = 0;
 
     /* protect from underflow */
     state[level++] = 0;
@@ -21900,8 +22270,30 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 goto done;
             break;
         case '}':
-            if (state[--level] != '{')
+            c = state[--level];
+            if (c == '`') {
+                /* continue the parsing of the template */
+                free_token(s, &s->token);
+                /* Resume TOK_TEMPLATE parsing (s->token.line_num and
+                 * s->token.ptr are OK) */
+                s->got_lf = FALSE;
+                s->last_line_num = s->token.line_num;
+                if (js_parse_template_part(s, s->buf_ptr))
+                    goto done;
+                goto handle_template;
+            } else if (c != '{') {
                 goto done;
+            }
+            break;
+        case TOK_TEMPLATE:
+        handle_template:
+            if (s->token.u.str.sep != '`') {
+                /* '${' inside the template : closing '}' and continue
+                   parsing the template */
+                if (level >= sizeof(state))
+                    goto done;
+                state[level++] = '`';
+            } 
             break;
         case TOK_EOF:
             goto done;
@@ -24005,7 +24397,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         int scope;
                         name = get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
                         scope = get_u16(fd->byte_code.buf + fd->last_opcode_pos + 5);
-                        if (name == JS_ATOM_eval && call_type == FUNC_CALL_NORMAL) {
+                        if (name == JS_ATOM_eval && call_type == FUNC_CALL_NORMAL && !has_optional_chain) {
                             /* direct 'eval' */
                             opcode = OP_eval;
                         } else {
@@ -26318,26 +26710,6 @@ static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
     js_free(ctx, m);
 }
 
-static int js_resize_array(JSContext *ctx, void **parray, int elem_size,
-                           int *psize, int *pcount, int new_count)
-{
-    if (unlikely(new_count > *psize)) {
-        int new_size;
-        size_t slack;
-        void *new_array;
-        /* XXX: potential arithmetic overflow */
-        new_size = max_int(new_count, *psize * 3 / 2);
-        new_array = js_realloc2(ctx, *parray, new_size * elem_size, &slack);
-        if (!new_array)
-            return -1;
-        new_size += slack / elem_size;
-        *psize = new_size;
-        *parray = new_array;
-    }
-    *pcount = new_count;
-    return 0;
-}
-
 static int add_req_module_entry(JSContext *ctx, JSModuleDef *m,
                                 JSAtom module_name)
 {
@@ -26353,11 +26725,10 @@ static int add_req_module_entry(JSContext *ctx, JSModuleDef *m,
 
     if (js_resize_array(ctx, (void **)&m->req_module_entries,
                         sizeof(JSReqModuleEntry),
-                        &m->req_module_entries_size, &m->req_module_entries_count,
+                        &m->req_module_entries_size,
                         m->req_module_entries_count + 1))
         return -1;
-    i = m->req_module_entries_count - 1;
-    rme = &m->req_module_entries[i];
+    rme = &m->req_module_entries[m->req_module_entries_count++];
     rme->module_name = JS_DupAtom(ctx, module_name);
     rme->module = NULL;
     return i;
@@ -26389,18 +26760,17 @@ static JSExportEntry *add_export_entry2(JSContext *ctx,
             js_parse_error(s, "duplicate exported name '%s'",
                            JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name));
         } else {
-            JS_ThrowSyntaxError(ctx, "duplicate exported name '%s'",
-                                JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name));
+            JS_ThrowSyntaxErrorAtom(ctx, "duplicate exported name '%s'", export_name);
         }
         return NULL;
     }
 
     if (js_resize_array(ctx, (void **)&m->export_entries,
                         sizeof(JSExportEntry),
-                        &m->export_entries_size, &m->export_entries_count,
+                        &m->export_entries_size,
                         m->export_entries_count + 1))
         return NULL;
-    me = &m->export_entries[m->export_entries_count - 1];
+    me = &m->export_entries[m->export_entries_count++];
     memset(me, 0, sizeof(*me));
     me->local_name = JS_DupAtom(ctx, local_name);
     me->export_name = JS_DupAtom(ctx, export_name);
@@ -26423,10 +26793,10 @@ static int add_star_export_entry(JSContext *ctx, JSModuleDef *m,
 
     if (js_resize_array(ctx, (void **)&m->star_export_entries,
                         sizeof(JSStarExportEntry),
-                        &m->star_export_entries_size, &m->star_export_entries_count,
+                        &m->star_export_entries_size,
                         m->star_export_entries_count + 1))
         return -1;
-    se = &m->star_export_entries[m->star_export_entries_count - 1];
+    se = &m->star_export_entries[m->star_export_entries_count++];
     se->req_module_idx = req_module_idx;
     return 0;
 }
@@ -26652,10 +27022,9 @@ static int add_resolve_entry(JSContext *ctx, JSResolveState *s,
 
     if (js_resize_array(ctx, (void **)&s->array,
                         sizeof(JSResolveEntry),
-                        &s->size, &s->count,
-                        s->count + 1))
+                        &s->size, s->count + 1))
         return -1;
-    re = &s->array[s->count - 1];
+    re = &s->array[s->count++];
     re->module = m;
     re->name = JS_DupAtom(ctx, name);
     return 0;
@@ -26780,17 +27149,17 @@ static void js_resolve_export_throw_error(JSContext *ctx,
         break;
     default:
     case JS_RESOLVE_RES_NOT_FOUND:
-        JS_ThrowSyntaxError(ctx, "export '%s' in module '%s' is ambiguous",
+        JS_ThrowSyntaxError(ctx, "Could not find export '%s' in module '%s'",
                             JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
                             JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
         break;
     case JS_RESOLVE_RES_CIRCULAR:
-        JS_ThrowSyntaxError(ctx, "Could not find export '%s' in module '%s'",
+        JS_ThrowSyntaxError(ctx, "circular reference when looking for export '%s' in module '%s'",
                             JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
                             JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
         break;
     case JS_RESOLVE_RES_AMBIGUOUS:
-        JS_ThrowSyntaxError(ctx, "circular reference when looking for export '%s' in module '%s'",
+        JS_ThrowSyntaxError(ctx, "export '%s' in module '%s' is ambiguous",
                             JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
                             JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
         break;
@@ -26847,9 +27216,9 @@ static __exception int get_exported_names(JSContext *ctx,
             return 0;
     }
     if (js_resize_array(ctx, (void **)&s->modules, sizeof(s->modules[0]),
-                        &s->modules_size, &s->modules_count, s->modules_count + 1))
+                        &s->modules_size, s->modules_count + 1))
         return -1;
-    s->modules[s->modules_count - 1] = m;
+    s->modules[s->modules_count++] = m;
 
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
@@ -26858,9 +27227,10 @@ static __exception int get_exported_names(JSContext *ctx,
         j = find_exported_name(s, me->export_name);
         if (j < 0) {
             if (js_resize_array(ctx, (void **)&s->exported_names, sizeof(s->exported_names[0]),
-                                &s->exported_names_size, &s->exported_names_count, s->exported_names_count + 1))
+                                &s->exported_names_size,
+                                s->exported_names_count + 1))
                 return -1;
-            en = &s->exported_names[s->exported_names_count - 1];
+            en = &s->exported_names[s->exported_names_count++];
             en->export_name = me->export_name;
             /* avoid a second lookup for simple module exports */
             if (from_star || me->export_type != JS_EXPORT_TYPE_LOCAL)
@@ -27096,7 +27466,7 @@ static JSVarRef *js_create_module_var(JSContext *ctx, BOOL is_lexical)
 }
 
 /* Create the <eval> function associated with the module */
-static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
+static int js_create_module_bytecode_function(JSContext *ctx, JSModuleDef *m)
 {
     JSFunctionBytecode *b;
     int i;
@@ -27147,20 +27517,15 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     return -1;
 }
 
-/* Prepare a module to be executed by resolving all the imported
-   variables. */
-static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
+/* must be done before js_instantiate_module() because of cyclic references */
+static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
 {
-    int i;
-    JSImportEntry *mi;
-    JSModuleDef *m1;
-    JSVarRef **var_refs, *var_ref;
-    JSObject *p;
     BOOL is_c_module;
-
-    if (m->instantiated)
+    int i;
+    JSVarRef *var_ref;
+    
+    if (m->func_created)
         return 0;
-    m->instantiated = TRUE;
 
     is_c_module = (m->init_func != NULL);
 
@@ -27171,14 +27536,49 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
             if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
                 var_ref = js_create_module_var(ctx, FALSE);
                 if (!var_ref)
-                    goto fail;
+                    return -1;
                 me->u.local.var_ref = var_ref;
             }
         }
     } else {
-        if (js_create_module_function(ctx, m) < 0)
-            goto fail;
+        if (js_create_module_bytecode_function(ctx, m))
+            return -1;
     }
+    m->func_created = TRUE;
+
+    /* do it on the dependencies */
+    
+    for(i = 0; i < m->req_module_entries_count; i++) {
+        JSReqModuleEntry *rme = &m->req_module_entries[i];
+        if (js_create_module_function(ctx, rme->module) < 0)
+            return -1;
+    }
+
+    return 0;
+}    
+
+    
+/* Prepare a module to be executed by resolving all the imported
+   variables. */
+static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
+{
+    int i;
+    JSImportEntry *mi;
+    JSModuleDef *m1;
+    JSVarRef **var_refs, *var_ref;
+    JSObject *p;
+    BOOL is_c_module;
+
+    if (m->instantiated)
+        return 0;
+    m->instantiated = TRUE;
+
+#ifdef DUMP_MODULE_RESOLVE
+    {
+        char buf1[ATOM_GET_STR_BUF_SIZE];
+        printf("start instantiating module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
+    }
+#endif
 
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
@@ -27221,6 +27621,8 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     }
 #endif
 
+    is_c_module = (m->init_func != NULL);
+
     if (!is_c_module) {
         p = JS_VALUE_GET_OBJ(m->func_obj);
         var_refs = p->u.func.var_refs;
@@ -27740,10 +28142,10 @@ static int add_import(JSParseState *s, JSModuleDef *m,
         return -1;
     if (js_resize_array(ctx, (void **)&m->import_entries,
                         sizeof(JSImportEntry),
-                        &m->import_entries_size, &m->import_entries_count,
+                        &m->import_entries_size,
                         m->import_entries_count + 1))
         return -1;
-    mi = &m->import_entries[m->import_entries_count - 1];
+    mi = &m->import_entries[m->import_entries_count++];
     mi->import_name = JS_DupAtom(ctx, import_name);
     mi->var_idx = var_idx;
     return 0;
@@ -28474,20 +28876,10 @@ static int add_closure_var(JSContext *ctx, JSFunctionDef *s,
         return -1;
     }
 
-    if (s->closure_var_count >= s->closure_var_size) {
-        JSClosureVar *new_tab;
-        int new_size;
-        size_t slack;
-        new_size = max_int(s->closure_var_count + 1,
-                           s->closure_var_size * 3 / 2);
-        new_tab = js_realloc2(ctx, s->closure_var,
-                              new_size * sizeof(JSClosureVar), &slack);
-        if (!new_tab)
-            return -1;
-        new_size += slack / sizeof(*new_tab);
-        s->closure_var = new_tab;
-        s->closure_var_size = new_size;
-    }
+    if (js_resize_array(ctx, (void **)&s->closure_var,
+                        sizeof(s->closure_var[0]),
+                        &s->closure_var_size, s->closure_var_count + 1))
+        return -1;
     cv = &s->closure_var[s->closure_var_count++];
     cv->is_local = is_local;
     cv->is_arg = is_arg;
@@ -29243,8 +29635,6 @@ static int resolve_scope_private_field1(JSContext *ctx,
         }
         scope_level = fd->parent_scope_level;
         if (!fd->parent) {
-            char buf[ATOM_GET_STR_BUF_SIZE];
-
             if (fd->is_eval) {
                 /* closure of the eval function (top level) */
                 for (idx = 0; idx < fd->closure_var_count; idx++) {
@@ -29267,8 +29657,8 @@ static int resolve_scope_private_field1(JSContext *ctx,
                 }
             }
             /* XXX: no line number info */
-            JS_ThrowSyntaxError(ctx, "undefined private field %s",
-                                JS_AtomGetStr(ctx, buf, sizeof(buf), var_name));
+            JS_ThrowSyntaxErrorAtom(ctx, "undefined private field '%s'",
+                                    var_name);
             return -1;
         } else {
             fd = fd->parent;
@@ -31535,9 +31925,8 @@ static int add_module_variables(JSContext *ctx, JSFunctionDef *fd)
         if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
             idx = find_closure_var(ctx, fd, me->local_name);
             if (idx < 0) {
-                char buf1[ATOM_GET_STR_BUF_SIZE];
-                JS_ThrowSyntaxError(ctx, "exported variable '%s' does not exist",
-                                    JS_AtomGetStr(ctx, buf1, sizeof(buf1), me->local_name));
+                JS_ThrowSyntaxErrorAtom(ctx, "exported variable '%s' does not exist",
+                                        me->local_name);
                 return -1;
             }
             me->u.local.var_idx = idx;
@@ -32559,6 +32948,8 @@ static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
         m = JS_VALUE_GET_PTR(fun_obj);
         /* the module refcount should be >= 2 */
         JS_FreeValue(ctx, fun_obj);
+        if (js_create_module_function(ctx, m) < 0)
+            goto fail;
         if (js_instantiate_module(ctx, m) < 0)
             goto fail;
         ret_val = js_evaluate_module(ctx, m);
@@ -32769,6 +33160,110 @@ int JS_ResolveModule(JSContext *ctx, JSValueConst obj)
     return 0;
 }
 
+/*******************************************************************/
+/* object list */
+
+typedef struct {
+    JSObject *obj;
+    uint32_t hash_next; /* -1 if no next entry */
+} JSObjectListEntry;
+
+/* XXX: reuse it to optimize weak references */
+typedef struct {
+    JSObjectListEntry *object_tab;
+    int object_count;
+    int object_size;
+    uint32_t *hash_table;
+    uint32_t hash_size;
+} JSObjectList;
+
+static void js_object_list_init(JSObjectList *s)
+{
+    memset(s, 0, sizeof(*s));
+}
+
+static uint32_t js_object_list_get_hash(JSObject *p, uint32_t hash_size)
+{
+    return ((uintptr_t)p * 3163) & (hash_size - 1);
+}
+
+static int js_object_list_resize_hash(JSContext *ctx, JSObjectList *s,
+                                 uint32_t new_hash_size)
+{
+    JSObjectListEntry *e;
+    uint32_t i, h, *new_hash_table;
+
+    new_hash_table = js_malloc(ctx, sizeof(new_hash_table[0]) * new_hash_size);
+    if (!new_hash_table)
+        return -1;
+    js_free(ctx, s->hash_table);
+    s->hash_table = new_hash_table;
+    s->hash_size = new_hash_size;
+    
+    for(i = 0; i < s->hash_size; i++) {
+        s->hash_table[i] = -1;
+    }
+    for(i = 0; i < s->object_count; i++) {
+        e = &s->object_tab[i];
+        h = js_object_list_get_hash(e->obj, s->hash_size); 
+        e->hash_next = s->hash_table[h];
+        s->hash_table[h] = i;
+    }
+    return 0;
+}
+
+/* the reference count of 'obj' is not modified. Return 0 if OK, -1 if
+   memory error */
+static int js_object_list_add(JSContext *ctx, JSObjectList *s, JSObject *obj)
+{
+    JSObjectListEntry *e;
+    uint32_t h, new_hash_size;
+    
+    if (js_resize_array(ctx, (void *)&s->object_tab,
+                        sizeof(s->object_tab[0]),
+                        &s->object_size, s->object_count + 1))
+        return -1;
+    if (unlikely((s->object_count + 1) >= s->hash_size)) {
+        new_hash_size = max_uint32(s->hash_size, 4);
+        while (new_hash_size <= s->object_count)
+            new_hash_size *= 2;
+        if (js_object_list_resize_hash(ctx, s, new_hash_size))
+            return -1;
+    }
+    e = &s->object_tab[s->object_count++];
+    h = js_object_list_get_hash(obj, s->hash_size); 
+    e->obj = obj;
+    e->hash_next = s->hash_table[h];
+    s->hash_table[h] = s->object_count - 1;
+    return 0;
+}
+
+/* return -1 if not present or the object index */
+static int js_object_list_find(JSContext *ctx, JSObjectList *s, JSObject *obj)
+{
+    JSObjectListEntry *e;
+    uint32_t h, p;
+
+    /* must test empty size because there is no hash table */
+    if (s->object_count == 0)
+        return -1;
+    h = js_object_list_get_hash(obj, s->hash_size); 
+    p = s->hash_table[h];
+    while (p != -1) {
+        e = &s->object_tab[p];
+        if (e->obj == obj)
+            return p;
+        p = e->hash_next;
+    }
+    return -1;
+}
+
+static void js_object_list_end(JSContext *ctx, JSObjectList *s)
+{
+    js_free(ctx, s->object_tab);
+    js_free(ctx, s->hash_table);
+}
+
 /*******************************************************************/
 /* binary object writer & reader */
 
@@ -32788,6 +33283,12 @@ typedef enum BCTagEnum {
     BC_TAG_TEMPLATE_OBJECT,
     BC_TAG_FUNCTION_BYTECODE,
     BC_TAG_MODULE,
+    BC_TAG_TYPED_ARRAY,
+    BC_TAG_ARRAY_BUFFER,
+    BC_TAG_SHARED_ARRAY_BUFFER,
+    BC_TAG_DATE,
+    BC_TAG_OBJECT_VALUE,
+    BC_TAG_OBJECT_REFERENCE,
 } BCTagEnum;
 
 #ifdef CONFIG_BIGNUM
@@ -32805,14 +33306,21 @@ typedef enum BCTagEnum {
 typedef struct BCWriterState {
     JSContext *ctx;
     DynBuf dbuf;
-    BOOL byte_swap;
-    BOOL allow_bytecode;
+    BOOL byte_swap : 8;
+    BOOL allow_bytecode : 8;
+    BOOL allow_sab : 8;
+    BOOL allow_reference : 8;
     uint32_t first_atom;
     uint32_t *atom_to_idx;
     int atom_to_idx_size;
     JSAtom *idx_to_atom;
     int idx_to_atom_count;
     int idx_to_atom_size;
+    uint8_t **sab_tab;
+    int sab_tab_len;
+    int sab_tab_size;
+    /* list of referenced objects (used if allow_reference = TRUE) */
+    JSObjectList object_list;
 } BCWriterState;
 
 #ifdef DUMP_READ_OBJECT
@@ -32833,6 +33341,12 @@ static const char * const bc_tag_str[] = {
     "template",
     "function",
     "module",
+    "TypedArray",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "Date",
+    "ObjectValue",
+    "ObjectReference",
 };
 #endif
 
@@ -32892,36 +33406,20 @@ static int bc_atom_to_idx(BCWriterState *s, uint32_t *pres, JSAtom atom)
         return 0;
     }
     if (atom >= s->atom_to_idx_size) {
-        size_t new_size, i, slack;
-        uint32_t *new_tab;
-        /* XXX: potential arithmetic overflow */
-        new_size = s->atom_to_idx_size * 3 / 2;
-        if ((atom + 1) > new_size)
-            new_size = atom + 1;
-        new_tab = js_realloc2(s->ctx, s->atom_to_idx,
-                              new_size * sizeof(s->atom_to_idx[0]), &slack);
-        if (!new_tab)
-            goto fail;
-        new_size += slack / sizeof(*new_tab);
-        for(i = s->atom_to_idx_size; i < new_size; i++)
-            new_tab[i] = 0;
-        s->atom_to_idx = new_tab;
-        s->atom_to_idx_size = new_size;
-    }
-    if ((s->idx_to_atom_count + 1) > s->idx_to_atom_size) {
-        size_t new_size, slack;
-        JSAtom *new_tab;
-        new_size = s->idx_to_atom_size * 3 / 2;
-        if ((s->idx_to_atom_count + 1) > new_size)
-            new_size = s->idx_to_atom_count + 1;
-        new_tab = js_realloc2(s->ctx, s->idx_to_atom,
-                              new_size * sizeof(s->idx_to_atom[0]), &slack);
-        if (!new_tab)
-            goto fail;
-        new_size += slack / sizeof(*new_tab);
-        s->idx_to_atom = new_tab;
-        s->idx_to_atom_size = new_size;
+        int old_size, i;
+        old_size = s->atom_to_idx_size;
+        if (js_resize_array(s->ctx, (void **)&s->atom_to_idx,
+                            sizeof(s->atom_to_idx[0]), &s->atom_to_idx_size,
+                            atom + 1))
+            return -1;
+        /* XXX: could add a specific js_resize_array() function to do it */
+        for(i = old_size; i < s->atom_to_idx_size; i++)
+            s->atom_to_idx[i] = 0;
     }
+    if (js_resize_array(s->ctx, (void **)&s->idx_to_atom,
+                        sizeof(s->idx_to_atom[0]),
+                        &s->idx_to_atom_size, s->idx_to_atom_count + 1))
+        goto fail;
 
     v = s->idx_to_atom_count++;
     s->idx_to_atom[v] = atom + s->first_atom;
@@ -33204,10 +33702,276 @@ static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
 }
 #endif /* CONFIG_BIGNUM */
 
+static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj);
+
+static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
+{
+    JSFunctionBytecode *b = JS_VALUE_GET_PTR(obj);
+    uint32_t flags;
+    int idx, i;
+    
+    bc_put_u8(s, BC_TAG_FUNCTION_BYTECODE);
+    flags = idx = 0;
+    bc_set_flags(&flags, &idx, b->has_prototype, 1);
+    bc_set_flags(&flags, &idx, b->has_simple_parameter_list, 1);
+    bc_set_flags(&flags, &idx, b->is_derived_class_constructor, 1);
+    bc_set_flags(&flags, &idx, b->need_home_object, 1);
+    bc_set_flags(&flags, &idx, b->func_kind, 2);
+    bc_set_flags(&flags, &idx, b->new_target_allowed, 1);
+    bc_set_flags(&flags, &idx, b->super_call_allowed, 1);
+    bc_set_flags(&flags, &idx, b->super_allowed, 1);
+    bc_set_flags(&flags, &idx, b->arguments_allowed, 1);
+    bc_set_flags(&flags, &idx, b->has_debug, 1);
+    bc_set_flags(&flags, &idx, b->backtrace_barrier, 1);
+    assert(idx <= 16);
+    bc_put_u16(s, flags);
+    bc_put_u8(s, b->js_mode);
+    bc_put_atom(s, b->func_name);
+    
+    bc_put_leb128(s, b->arg_count);
+    bc_put_leb128(s, b->var_count);
+    bc_put_leb128(s, b->defined_arg_count);
+    bc_put_leb128(s, b->stack_size);
+    bc_put_leb128(s, b->closure_var_count);
+    bc_put_leb128(s, b->cpool_count);
+    bc_put_leb128(s, b->byte_code_len);
+    if (b->vardefs) {
+        bc_put_leb128(s, b->arg_count + b->var_count);
+        for(i = 0; i < b->arg_count + b->var_count; i++) {
+            JSVarDef *vd = &b->vardefs[i];
+            bc_put_atom(s, vd->var_name);
+            bc_put_leb128(s, vd->scope_level);
+            bc_put_leb128(s, vd->scope_next + 1);
+            flags = idx = 0;
+            bc_set_flags(&flags, &idx, vd->var_kind, 4);
+            bc_set_flags(&flags, &idx, vd->is_func_var, 1);
+            bc_set_flags(&flags, &idx, vd->is_const, 1);
+            bc_set_flags(&flags, &idx, vd->is_lexical, 1);
+            bc_set_flags(&flags, &idx, vd->is_captured, 1);
+            assert(idx <= 8);
+            bc_put_u8(s, flags);
+        }
+    } else {
+        bc_put_leb128(s, 0);
+    }
+    
+    for(i = 0; i < b->closure_var_count; i++) {
+        JSClosureVar *cv = &b->closure_var[i];
+        bc_put_atom(s, cv->var_name);
+        bc_put_leb128(s, cv->var_idx);
+        flags = idx = 0;
+        bc_set_flags(&flags, &idx, cv->is_local, 1);
+        bc_set_flags(&flags, &idx, cv->is_arg, 1);
+        bc_set_flags(&flags, &idx, cv->is_const, 1);
+        bc_set_flags(&flags, &idx, cv->is_lexical, 1);
+        bc_set_flags(&flags, &idx, cv->var_kind, 4);
+        assert(idx <= 8);
+        bc_put_u8(s, flags);
+    }
+    
+    if (JS_WriteFunctionBytecode(s, b->byte_code_buf, b->byte_code_len))
+        goto fail;
+    
+    if (b->has_debug) {
+        bc_put_atom(s, b->debug.filename);
+        bc_put_leb128(s, b->debug.line_num);
+        bc_put_leb128(s, b->debug.pc2line_len);
+        dbuf_put(&s->dbuf, b->debug.pc2line_buf, b->debug.pc2line_len);
+    }
+    
+    for(i = 0; i < b->cpool_count; i++) {
+        if (JS_WriteObjectRec(s, b->cpool[i]))
+            goto fail;
+    }
+    return 0;
+ fail:
+    return -1;
+}
+
+static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
+{
+    JSModuleDef *m = JS_VALUE_GET_PTR(obj);
+    int i;
+    
+    bc_put_u8(s, BC_TAG_MODULE);
+    bc_put_atom(s, m->module_name);
+    
+    bc_put_leb128(s, m->req_module_entries_count);
+    for(i = 0; i < m->req_module_entries_count; i++) {
+        JSReqModuleEntry *rme = &m->req_module_entries[i];
+        bc_put_atom(s, rme->module_name);
+    }
+    
+    bc_put_leb128(s, m->export_entries_count);
+    for(i = 0; i < m->export_entries_count; i++) {
+        JSExportEntry *me = &m->export_entries[i];
+        bc_put_u8(s, me->export_type);
+        if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
+            bc_put_leb128(s, me->u.local.var_idx);
+        } else {
+            bc_put_leb128(s, me->u.req_module_idx);
+            bc_put_atom(s, me->local_name);
+        }
+        bc_put_atom(s, me->export_name);
+    }
+    
+    bc_put_leb128(s, m->star_export_entries_count);
+    for(i = 0; i < m->star_export_entries_count; i++) {
+        JSStarExportEntry *se = &m->star_export_entries[i];
+        bc_put_leb128(s, se->req_module_idx);
+    }
+    
+    bc_put_leb128(s, m->import_entries_count);
+    for(i = 0; i < m->import_entries_count; i++) {
+        JSImportEntry *mi = &m->import_entries[i];
+        bc_put_leb128(s, mi->var_idx);
+        bc_put_atom(s, mi->import_name);
+        bc_put_leb128(s, mi->req_module_idx);
+    }
+    
+    if (JS_WriteObjectRec(s, m->func_obj))
+        goto fail;
+    return 0;
+ fail:
+    return -1;
+}
+
+static int JS_WriteArray(BCWriterState *s, JSValueConst obj)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(obj);
+    uint32_t i, len;
+    JSValue val;
+    int ret;
+    BOOL is_template;
+    
+    if (s->allow_bytecode && !p->extensible) {
+        /* not extensible array: we consider it is a
+           template when we are saving bytecode */
+        bc_put_u8(s, BC_TAG_TEMPLATE_OBJECT);
+        is_template = TRUE;
+    } else {
+        bc_put_u8(s, BC_TAG_ARRAY);
+        is_template = FALSE;
+    }
+    if (js_get_length32(s->ctx, &len, obj))
+        goto fail1;
+    bc_put_leb128(s, len);
+    for(i = 0; i < len; i++) {
+        val = JS_GetPropertyUint32(s->ctx, obj, i);
+        if (JS_IsException(val))
+            goto fail1;
+        ret = JS_WriteObjectRec(s, val);
+        JS_FreeValue(s->ctx, val);
+        if (ret)
+            goto fail1;
+    }
+    if (is_template) {
+        val = JS_GetProperty(s->ctx, obj, JS_ATOM_raw);
+        if (JS_IsException(val))
+            goto fail1;
+        ret = JS_WriteObjectRec(s, val);
+        JS_FreeValue(s->ctx, val);
+        if (ret)
+            goto fail1;
+    }
+    return 0;
+ fail1:
+    return -1;
+}
+
+static int JS_WriteObjectTag(BCWriterState *s, JSValueConst obj)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(obj);
+    uint32_t i, prop_count;
+    JSShape *sh;
+    JSShapeProperty *pr;
+    int pass;
+    JSAtom atom;
+
+    bc_put_u8(s, BC_TAG_OBJECT);
+    prop_count = 0;
+    sh = p->shape;
+    for(pass = 0; pass < 2; pass++) {
+        if (pass == 1)
+            bc_put_leb128(s, prop_count);
+        for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count; i++, pr++) {
+            atom = pr->atom;
+            if (atom != JS_ATOM_NULL &&
+                JS_AtomIsString(s->ctx, atom) &&
+                (pr->flags & JS_PROP_ENUMERABLE)) {
+                if (pr->flags & JS_PROP_TMASK) {
+                    JS_ThrowTypeError(s->ctx, "only value properties are supported");
+                    goto fail;
+                }
+                if (pass == 0) {
+                    prop_count++;
+                } else {
+                    bc_put_atom(s, atom);
+                    if (JS_WriteObjectRec(s, p->prop[i].u.value))
+                        goto fail;
+                }
+            }
+        }
+    }
+    return 0;
+ fail:
+    return -1;
+}
+
+static int JS_WriteTypedArray(BCWriterState *s, JSValueConst obj)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(obj);
+    JSTypedArray *ta = p->u.typed_array;
+
+    bc_put_u8(s, BC_TAG_TYPED_ARRAY);
+    bc_put_u8(s, p->class_id - JS_CLASS_UINT8C_ARRAY);
+    bc_put_leb128(s, p->u.array.count);
+    bc_put_leb128(s, ta->offset);
+    if (JS_WriteObjectRec(s, JS_MKPTR(JS_TAG_OBJECT, ta->buffer)))
+        return -1;
+    return 0;
+}
+
+static int JS_WriteArrayBuffer(BCWriterState *s, JSValueConst obj)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(obj);
+    JSArrayBuffer *abuf = p->u.array_buffer;
+    if (abuf->detached) {
+        JS_ThrowTypeErrorDetachedArrayBuffer(s->ctx);
+        return -1;
+    }
+    bc_put_u8(s, BC_TAG_ARRAY_BUFFER);
+    bc_put_leb128(s, abuf->byte_length);
+    dbuf_put(&s->dbuf, abuf->data, abuf->byte_length);
+    return 0;
+}
+
+static int JS_WriteSharedArrayBuffer(BCWriterState *s, JSValueConst obj)
+{
+    JSObject *p = JS_VALUE_GET_OBJ(obj);
+    JSArrayBuffer *abuf = p->u.array_buffer;
+    assert(!abuf->detached); /* SharedArrayBuffer are never detached */
+    bc_put_u8(s, BC_TAG_SHARED_ARRAY_BUFFER);
+    bc_put_leb128(s, abuf->byte_length);
+    bc_put_u64(s, (uintptr_t)abuf->data);
+    if (js_resize_array(s->ctx, (void **)&s->sab_tab, sizeof(s->sab_tab[0]),
+                        &s->sab_tab_size, s->sab_tab_len + 1))
+        return -1;
+    /* keep the SAB pointer so that the user can clone it or free it */
+    s->sab_tab[s->sab_tab_len++] = abuf->data;
+    return 0;
+}
+
 static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
 {
-    uint32_t tag = JS_VALUE_GET_NORM_TAG(obj);
+    uint32_t tag;
+
+    if (js_check_stack_overflow(s->ctx->rt, 0)) {
+        JS_ThrowStackOverflow(s->ctx);
+        return -1;
+    }
 
+    tag = JS_VALUE_GET_NORM_TAG(obj);
     switch(tag) {
     case JS_TAG_NULL:
         bc_put_u8(s, BC_TAG_NULL);
@@ -33238,218 +34002,82 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
         }
         break;
     case JS_TAG_FUNCTION_BYTECODE:
-        {
-            JSFunctionBytecode *b = JS_VALUE_GET_PTR(obj);
-            uint32_t flags;
-            int idx, i;
-
-            if (!s->allow_bytecode)
-                goto invalid_tag;
-            bc_put_u8(s, BC_TAG_FUNCTION_BYTECODE);
-            flags = idx = 0;
-            bc_set_flags(&flags, &idx, b->has_prototype, 1);
-            bc_set_flags(&flags, &idx, b->has_simple_parameter_list, 1);
-            bc_set_flags(&flags, &idx, b->is_derived_class_constructor, 1);
-            bc_set_flags(&flags, &idx, b->need_home_object, 1);
-            bc_set_flags(&flags, &idx, b->func_kind, 2);
-            bc_set_flags(&flags, &idx, b->new_target_allowed, 1);
-            bc_set_flags(&flags, &idx, b->super_call_allowed, 1);
-            bc_set_flags(&flags, &idx, b->super_allowed, 1);
-            bc_set_flags(&flags, &idx, b->arguments_allowed, 1);
-            bc_set_flags(&flags, &idx, b->has_debug, 1);
-            bc_set_flags(&flags, &idx, b->backtrace_barrier, 1);
-            assert(idx <= 16);
-            bc_put_u16(s, flags);
-            bc_put_u8(s, b->js_mode);
-            bc_put_atom(s, b->func_name);
-
-            bc_put_leb128(s, b->arg_count);
-            bc_put_leb128(s, b->var_count);
-            bc_put_leb128(s, b->defined_arg_count);
-            bc_put_leb128(s, b->stack_size);
-            bc_put_leb128(s, b->closure_var_count);
-            bc_put_leb128(s, b->cpool_count);
-            bc_put_leb128(s, b->byte_code_len);
-            if (b->vardefs) {
-                bc_put_leb128(s, b->arg_count + b->var_count);
-                for(i = 0; i < b->arg_count + b->var_count; i++) {
-                    JSVarDef *vd = &b->vardefs[i];
-                    bc_put_atom(s, vd->var_name);
-                    bc_put_leb128(s, vd->scope_level);
-                    bc_put_leb128(s, vd->scope_next + 1);
-                    flags = idx = 0;
-                    bc_set_flags(&flags, &idx, vd->var_kind, 4);
-                    bc_set_flags(&flags, &idx, vd->is_func_var, 1);
-                    bc_set_flags(&flags, &idx, vd->is_const, 1);
-                    bc_set_flags(&flags, &idx, vd->is_lexical, 1);
-                    bc_set_flags(&flags, &idx, vd->is_captured, 1);
-                    assert(idx <= 8);
-                    bc_put_u8(s, flags);
-                }
-            } else {
-                bc_put_leb128(s, 0);
-            }
-
-            for(i = 0; i < b->closure_var_count; i++) {
-                JSClosureVar *cv = &b->closure_var[i];
-                bc_put_atom(s, cv->var_name);
-                bc_put_leb128(s, cv->var_idx);
-                flags = idx = 0;
-                bc_set_flags(&flags, &idx, cv->is_local, 1);
-                bc_set_flags(&flags, &idx, cv->is_arg, 1);
-                bc_set_flags(&flags, &idx, cv->is_const, 1);
-                bc_set_flags(&flags, &idx, cv->is_lexical, 1);
-                bc_set_flags(&flags, &idx, cv->var_kind, 4);
-                assert(idx <= 8);
-                bc_put_u8(s, flags);
-            }
-
-            if (JS_WriteFunctionBytecode(s, b->byte_code_buf, b->byte_code_len))
-                goto fail;
-
-            if (b->has_debug) {
-                bc_put_atom(s, b->debug.filename);
-                bc_put_leb128(s, b->debug.line_num);
-                bc_put_leb128(s, b->debug.pc2line_len);
-                dbuf_put(&s->dbuf, b->debug.pc2line_buf, b->debug.pc2line_len);
-            }
-
-            for(i = 0; i < b->cpool_count; i++) {
-                if (JS_WriteObjectRec(s, b->cpool[i]))
-                    goto fail;
-            }
-        }
+        if (!s->allow_bytecode)
+            goto invalid_tag;
+        if (JS_WriteFunctionTag(s, obj))
+            goto fail;
         break;
     case JS_TAG_MODULE:
-        {
-            JSModuleDef *m = JS_VALUE_GET_PTR(obj);
-            int i;
-
-            if (!s->allow_bytecode)
-                goto invalid_tag;
-            bc_put_u8(s, BC_TAG_MODULE);
-            bc_put_atom(s, m->module_name);
-
-            bc_put_leb128(s, m->req_module_entries_count);
-            for(i = 0; i < m->req_module_entries_count; i++) {
-                JSReqModuleEntry *rme = &m->req_module_entries[i];
-                bc_put_atom(s, rme->module_name);
-            }
-
-            bc_put_leb128(s, m->export_entries_count);
-            for(i = 0; i < m->export_entries_count; i++) {
-                JSExportEntry *me = &m->export_entries[i];
-                bc_put_u8(s, me->export_type);
-                if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
-                    bc_put_leb128(s, me->u.local.var_idx);
-                } else {
-                    bc_put_leb128(s, me->u.req_module_idx);
-                    bc_put_atom(s, me->local_name);
-                }
-                bc_put_atom(s, me->export_name);
-            }
-
-            bc_put_leb128(s, m->star_export_entries_count);
-            for(i = 0; i < m->star_export_entries_count; i++) {
-                JSStarExportEntry *se = &m->star_export_entries[i];
-                bc_put_leb128(s, se->req_module_idx);
-            }
-
-            bc_put_leb128(s, m->import_entries_count);
-            for(i = 0; i < m->import_entries_count; i++) {
-                JSImportEntry *mi = &m->import_entries[i];
-                bc_put_leb128(s, mi->var_idx);
-                bc_put_atom(s, mi->import_name);
-                bc_put_leb128(s, mi->req_module_idx);
-            }
-
-            if (JS_WriteObjectRec(s, m->func_obj))
-                goto fail;
-        }
+        if (!s->allow_bytecode)
+            goto invalid_tag;
+        if (JS_WriteModule(s, obj))
+            goto fail;
         break;
     case JS_TAG_OBJECT:
         {
             JSObject *p = JS_VALUE_GET_OBJ(obj);
-            uint32_t i, prop_count, len;
-            JSShape *sh;
-            JSShapeProperty *pr;
-            JSValue val;
-            int ret, pass;
-            BOOL is_template;
-            JSAtom atom;
-
-            if (p->class_id != JS_CLASS_ARRAY &&
-                p->class_id != JS_CLASS_OBJECT) {
-                JS_ThrowTypeError(s->ctx, "unsupported object class");
-                goto fail;
-            }
-            if (p->tmp_mark) {
-                JS_ThrowTypeError(s->ctx, "circular reference");
-                goto fail;
-            }
-            p->tmp_mark = 1;
-            if (p->class_id == JS_CLASS_ARRAY) {
-                if (s->allow_bytecode && !p->extensible) {
-                    /* not extensible array: we consider it is a
-                       template when we are saving bytecode */
-                    bc_put_u8(s, BC_TAG_TEMPLATE_OBJECT);
-                    is_template = TRUE;
+            int ret, idx;
+            
+            if (s->allow_reference) {
+                idx = js_object_list_find(s->ctx, &s->object_list, p);
+                if (idx >= 0) {
+                    bc_put_u8(s, BC_TAG_OBJECT_REFERENCE);
+                    bc_put_leb128(s, idx);
+                    break;
                 } else {
-                    bc_put_u8(s, BC_TAG_ARRAY);
-                    is_template = FALSE;
-                }
-                if (js_get_length32(s->ctx, &len, obj))
-                    goto fail1;
-                bc_put_leb128(s, len);
-                for(i = 0; i < len; i++) {
-                    val = JS_GetPropertyUint32(s->ctx, obj, i);
-                    if (JS_IsException(val))
-                        goto fail1;
-                    ret = JS_WriteObjectRec(s, val);
-                    JS_FreeValue(s->ctx, val);
-                    if (ret)
-                        goto fail1;
-                }
-                if (is_template) {
-                    val = JS_GetProperty(s->ctx, obj, JS_ATOM_raw);
-                    if (JS_IsException(val))
-                        goto fail1;
-                    ret = JS_WriteObjectRec(s, val);
-                    JS_FreeValue(s->ctx, val);
-                    if (ret)
-                        goto fail1;
+                    if (js_object_list_add(s->ctx, &s->object_list, p))
+                        goto fail;
                 }
             } else {
-                bc_put_u8(s, BC_TAG_OBJECT);
-                prop_count = 0;
-                sh = p->shape;
-                for(pass = 0; pass < 2; pass++) {
-                    if (pass == 1)
-                        bc_put_leb128(s, prop_count);
-                    for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count; i++, pr++) {
-                        atom = pr->atom;
-                        if (atom != JS_ATOM_NULL &&
-                            JS_AtomIsString(s->ctx, atom) &&
-                            (pr->flags & JS_PROP_ENUMERABLE)) {
-                            if (pr->flags & JS_PROP_TMASK) {
-                                JS_ThrowTypeError(s->ctx, "only value properties are supported");
-                                goto fail;
-                            }
-                            if (pass == 0) {
-                                prop_count++;
-                            } else {
-                                bc_put_atom(s, atom);
-                                if (JS_WriteObjectRec(s, p->prop[i].u.value)) {
-                                fail1:
-                                    p->tmp_mark = 0;
-                                    goto fail;
-                                }
-                            }
-                        }
-                    }
+                if (p->tmp_mark) {
+                    JS_ThrowTypeError(s->ctx, "circular reference");
+                    goto fail;
+                }
+                p->tmp_mark = 1;
+            }
+            switch(p->class_id) {
+            case JS_CLASS_ARRAY:
+                ret = JS_WriteArray(s, obj);
+                break;
+            case JS_CLASS_OBJECT:
+                ret = JS_WriteObjectTag(s, obj);
+                break;
+            case JS_CLASS_ARRAY_BUFFER:
+                ret = JS_WriteArrayBuffer(s, obj);
+                break;
+            case JS_CLASS_SHARED_ARRAY_BUFFER:
+                if (!s->allow_sab)
+                    goto invalid_tag;
+                ret = JS_WriteSharedArrayBuffer(s, obj);
+                break;
+            case JS_CLASS_DATE:
+                bc_put_u8(s, BC_TAG_DATE);
+                ret = JS_WriteObjectRec(s, p->u.object_data);
+                break;
+            case JS_CLASS_NUMBER:
+            case JS_CLASS_STRING:
+            case JS_CLASS_BOOLEAN:
+#ifdef CONFIG_BIGNUM
+            case JS_CLASS_BIG_INT:
+            case JS_CLASS_BIG_FLOAT:
+            case JS_CLASS_BIG_DECIMAL:
+#endif
+                bc_put_u8(s, BC_TAG_OBJECT_VALUE);
+                ret = JS_WriteObjectRec(s, p->u.object_data);
+                break;
+            default:
+                if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
+                    p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
+                    ret = JS_WriteTypedArray(s, obj);
+                } else {
+                    JS_ThrowTypeError(s->ctx, "unsupported object class");
+                    ret = -1;
                 }
+                break;
             }
             p->tmp_mark = 0;
+            if (ret)
+                goto fail;
         }
         break;
 #ifdef CONFIG_BIGNUM
@@ -33511,8 +34139,8 @@ static int JS_WriteObjectAtoms(BCWriterState *s)
     return -1;
 }
 
-uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
-                        int flags)
+uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
+                         int flags, uint8_t ***psab_tab, size_t *psab_tab_len)
 {
     BCWriterState ss, *s = &ss;
 
@@ -33521,29 +34149,48 @@ uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
     /* XXX: byte swapped output is untested */
     s->byte_swap = ((flags & JS_WRITE_OBJ_BSWAP) != 0);
     s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
+    s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
+    s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
     /* XXX: could use a different version when bytecode is included */
     if (s->allow_bytecode)
         s->first_atom = JS_ATOM_END;
     else
         s->first_atom = 1;
     js_dbuf_init(ctx, &s->dbuf);
-
+    js_object_list_init(&s->object_list);
+    
     if (JS_WriteObjectRec(s, obj))
         goto fail;
     if (JS_WriteObjectAtoms(s))
         goto fail;
+    js_object_list_end(ctx, &s->object_list);
     js_free(ctx, s->atom_to_idx);
     js_free(ctx, s->idx_to_atom);
     *psize = s->dbuf.size;
+    if (psab_tab)
+        *psab_tab = s->sab_tab;
+    if (psab_tab_len)
+        *psab_tab_len = s->sab_tab_len;
     return s->dbuf.buf;
  fail:
+    js_object_list_end(ctx, &s->object_list);
     js_free(ctx, s->atom_to_idx);
     js_free(ctx, s->idx_to_atom);
     dbuf_free(&s->dbuf);
     *psize = 0;
+    if (psab_tab)
+        *psab_tab = NULL;
+    if (psab_tab_len)
+        *psab_tab_len = 0;
     return NULL;
 }
 
+uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
+                        int flags)
+{
+    return JS_WriteObject2(ctx, psize, obj, flags, NULL, NULL);
+}
+
 typedef struct BCReaderState {
     JSContext *ctx;
     const uint8_t *buf_start, *ptr, *buf_end;
@@ -33551,8 +34198,15 @@ typedef struct BCReaderState {
     uint32_t idx_to_atom_count;
     JSAtom *idx_to_atom;
     int error_state;
-    BOOL allow_bytecode;
-    BOOL is_rom_data;
+    BOOL allow_sab : 8;
+    BOOL allow_bytecode : 8;
+    BOOL is_rom_data : 8;
+    BOOL allow_reference : 8;
+    /* object references */
+    JSObject **objects;
+    int objects_count;
+    int objects_size;
+    
 #ifdef DUMP_READ_OBJECT
     const uint8_t *ptr_last;
     int level;
@@ -33756,7 +34410,7 @@ static JSString *JS_ReadString(BCReaderState *s)
         p->u.str8[size] = '\0'; /* add the trailing zero for 8 bit strings */
     }
 #ifdef DUMP_READ_OBJECT
-    bc_read_trace(s, "string: "); JS_DumpString(s->ctx->rt, p); printf("\n");
+    JS_DumpString(s->ctx->rt, p); printf("\n");
 #endif
     return p;
 }
@@ -33838,8 +34492,6 @@ static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
     bf_t *a;
     int bpos, d;
     
-    bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-    
     p = js_new_bf(s->ctx);
     if (!p)
         goto fail;
@@ -33961,28 +34613,560 @@ static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
 }
 #endif /* CONFIG_BIGNUM */
 
+static JSValue JS_ReadObjectRec(BCReaderState *s);
+
+static int BC_add_object_ref1(BCReaderState *s, JSObject *p)
+{
+    if (s->allow_reference) {
+        if (js_resize_array(s->ctx, (void *)&s->objects,
+                            sizeof(s->objects[0]),
+                            &s->objects_size, s->objects_count + 1))
+            return -1;
+        s->objects[s->objects_count++] = p;
+    }
+    return 0;
+}
+
+static int BC_add_object_ref(BCReaderState *s, JSValueConst obj)
+{
+    return BC_add_object_ref1(s, JS_VALUE_GET_OBJ(obj));
+}
+
+static JSValue JS_ReadFunctionTag(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSFunctionBytecode bc, *b;
+    JSValue obj = JS_UNDEFINED;
+    uint16_t v16;
+    uint8_t v8;
+    int idx, i, local_count;
+    int function_size, cpool_offset, byte_code_offset;
+    int closure_var_offset, vardefs_offset;
+
+    memset(&bc, 0, sizeof(bc));
+    bc.header.ref_count = 1;
+    //bc.gc_header.mark = 0;
+
+    if (bc_get_u16(s, &v16))
+        goto fail;
+    idx = 0;
+    bc.has_prototype = bc_get_flags(v16, &idx, 1);
+    bc.has_simple_parameter_list = bc_get_flags(v16, &idx, 1);
+    bc.is_derived_class_constructor = bc_get_flags(v16, &idx, 1);
+    bc.need_home_object = bc_get_flags(v16, &idx, 1);
+    bc.func_kind = bc_get_flags(v16, &idx, 2);
+    bc.new_target_allowed = bc_get_flags(v16, &idx, 1);
+    bc.super_call_allowed = bc_get_flags(v16, &idx, 1);
+    bc.super_allowed = bc_get_flags(v16, &idx, 1);
+    bc.arguments_allowed = bc_get_flags(v16, &idx, 1);
+    bc.has_debug = bc_get_flags(v16, &idx, 1);
+    bc.backtrace_barrier = bc_get_flags(v16, &idx, 1);
+    bc.read_only_bytecode = s->is_rom_data;
+    if (bc_get_u8(s, &v8))
+        goto fail;
+    bc.js_mode = v8;
+    if (bc_get_atom(s, &bc.func_name))  //@ atom leak if failure
+        goto fail;
+    if (bc_get_leb128_u16(s, &bc.arg_count))
+        goto fail;
+    if (bc_get_leb128_u16(s, &bc.var_count))
+        goto fail;
+    if (bc_get_leb128_u16(s, &bc.defined_arg_count))
+        goto fail;
+    if (bc_get_leb128_u16(s, &bc.stack_size))
+        goto fail;
+    if (bc_get_leb128_int(s, &bc.closure_var_count))
+        goto fail;
+    if (bc_get_leb128_int(s, &bc.cpool_count))
+        goto fail;
+    if (bc_get_leb128_int(s, &bc.byte_code_len))
+        goto fail;
+    if (bc_get_leb128_int(s, &local_count))
+        goto fail;
+
+    if (bc.has_debug) {
+        function_size = sizeof(*b);
+    } else {
+        function_size = offsetof(JSFunctionBytecode, debug);
+    }
+    cpool_offset = function_size;
+    function_size += bc.cpool_count * sizeof(*bc.cpool);
+    vardefs_offset = function_size;
+    function_size += local_count * sizeof(*bc.vardefs);
+    closure_var_offset = function_size;
+    function_size += bc.closure_var_count * sizeof(*bc.closure_var);
+    byte_code_offset = function_size;
+    if (!bc.read_only_bytecode) {
+        function_size += bc.byte_code_len;
+    }
+
+    b = js_mallocz(ctx, function_size);
+    if (!b)
+        return JS_EXCEPTION;
+            
+    memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
+    b->header.ref_count = 1;
+    add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
+            
+    obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
+
+#ifdef DUMP_READ_OBJECT
+    bc_read_trace(s, "name: "); print_atom(s->ctx, b->func_name); printf("\n");
+#endif
+    bc_read_trace(s, "args=%d vars=%d defargs=%d closures=%d cpool=%d\n",
+                  b->arg_count, b->var_count, b->defined_arg_count,
+                  b->closure_var_count, b->cpool_count);
+    bc_read_trace(s, "stack=%d bclen=%d locals=%d\n",
+                  b->stack_size, b->byte_code_len, local_count);
+
+    if (local_count != 0) {
+        bc_read_trace(s, "vars {\n");
+        b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
+        for(i = 0; i < local_count; i++) {
+            JSVarDef *vd = &b->vardefs[i];
+            if (bc_get_atom(s, &vd->var_name))
+                goto fail;
+            if (bc_get_leb128_int(s, &vd->scope_level))
+                goto fail;
+            if (bc_get_leb128_int(s, &vd->scope_next))
+                goto fail;
+            vd->scope_next--;
+            if (bc_get_u8(s, &v8))
+                goto fail;
+            idx = 0;
+            vd->var_kind = bc_get_flags(v8, &idx, 4);
+            vd->is_func_var = bc_get_flags(v8, &idx, 1);
+            vd->is_const = bc_get_flags(v8, &idx, 1);
+            vd->is_lexical = bc_get_flags(v8, &idx, 1);
+            vd->is_captured = bc_get_flags(v8, &idx, 1);
+#ifdef DUMP_READ_OBJECT
+            bc_read_trace(s, "name: "); print_atom(s->ctx, vd->var_name); printf("\n");
+#endif
+        }
+        bc_read_trace(s, "}\n");
+    }
+    if (b->closure_var_count != 0) {
+        bc_read_trace(s, "closure vars {\n");
+        b->closure_var = (void *)((uint8_t*)b + closure_var_offset);
+        for(i = 0; i < b->closure_var_count; i++) {
+            JSClosureVar *cv = &b->closure_var[i];
+            int var_idx;
+            if (bc_get_atom(s, &cv->var_name))
+                goto fail;
+            if (bc_get_leb128_int(s, &var_idx))
+                goto fail;
+            cv->var_idx = var_idx;
+            if (bc_get_u8(s, &v8))
+                goto fail;
+            idx = 0;
+            cv->is_local = bc_get_flags(v8, &idx, 1);
+            cv->is_arg = bc_get_flags(v8, &idx, 1);
+            cv->is_const = bc_get_flags(v8, &idx, 1);
+            cv->is_lexical = bc_get_flags(v8, &idx, 1);
+            cv->var_kind = bc_get_flags(v8, &idx, 4);
+#ifdef DUMP_READ_OBJECT
+            bc_read_trace(s, "name: "); print_atom(s->ctx, cv->var_name); printf("\n");
+#endif
+        }
+        bc_read_trace(s, "}\n");
+    }
+    {
+        bc_read_trace(s, "bytecode {\n");
+        if (JS_ReadFunctionBytecode(s, b, byte_code_offset, b->byte_code_len))
+            goto fail;
+        bc_read_trace(s, "}\n");
+    }
+    if (b->has_debug) {
+        /* read optional debug information */
+        bc_read_trace(s, "debug {\n");
+        if (bc_get_atom(s, &b->debug.filename))
+            goto fail;
+        if (bc_get_leb128_int(s, &b->debug.line_num))
+            goto fail;
+        if (bc_get_leb128_int(s, &b->debug.pc2line_len))
+            goto fail;
+        if (b->debug.pc2line_len) {
+            b->debug.pc2line_buf = js_mallocz(ctx, b->debug.pc2line_len);
+            if (!b->debug.pc2line_buf)
+                goto fail;
+            if (bc_get_buf(s, b->debug.pc2line_buf, b->debug.pc2line_len))
+                goto fail;
+        }
+#ifdef DUMP_READ_OBJECT
+        bc_read_trace(s, "filename: "); print_atom(s->ctx, b->debug.filename); printf("\n");
+#endif
+        bc_read_trace(s, "}\n");
+    }
+    if (b->cpool_count != 0) {
+        bc_read_trace(s, "cpool {\n");
+        b->cpool = (void *)((uint8_t*)b + cpool_offset);
+        for(i = 0; i < b->cpool_count; i++) {
+            JSValue val;
+            val = JS_ReadObjectRec(s);
+            if (JS_IsException(val))
+                goto fail;
+            b->cpool[i] = val;
+        }
+        bc_read_trace(s, "}\n");
+    }
+    b->realm = JS_DupContext(ctx);
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadModule(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSValue obj;
+    JSModuleDef *m = NULL;
+    JSAtom module_name;
+    int i;
+    uint8_t v8;
+    
+    if (bc_get_atom(s, &module_name))
+        goto fail;
+#ifdef DUMP_READ_OBJECT
+    bc_read_trace(s, "name: "); print_atom(s->ctx, module_name); printf("\n");
+#endif
+    m = js_new_module_def(ctx, module_name);
+    if (!m)
+        goto fail;
+    obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+    if (bc_get_leb128_int(s, &m->req_module_entries_count))
+        goto fail;
+    if (m->req_module_entries_count != 0) {
+        m->req_module_entries_size = m->req_module_entries_count;
+        m->req_module_entries = js_mallocz(ctx, sizeof(m->req_module_entries[0]) * m->req_module_entries_size);
+        if (!m->req_module_entries)
+            goto fail;
+        for(i = 0; i < m->req_module_entries_count; i++) {
+            JSReqModuleEntry *rme = &m->req_module_entries[i];
+            if (bc_get_atom(s, &rme->module_name))
+                goto fail;
+        }
+    }
+
+    if (bc_get_leb128_int(s, &m->export_entries_count))
+        goto fail;
+    if (m->export_entries_count != 0) {
+        m->export_entries_size = m->export_entries_count;
+        m->export_entries = js_mallocz(ctx, sizeof(m->export_entries[0]) * m->export_entries_size);
+        if (!m->export_entries)
+            goto fail;
+        for(i = 0; i < m->export_entries_count; i++) {
+            JSExportEntry *me = &m->export_entries[i];
+            if (bc_get_u8(s, &v8))
+                goto fail;
+            me->export_type = v8;
+            if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
+                if (bc_get_leb128_int(s, &me->u.local.var_idx))
+                    goto fail;
+            } else {
+                if (bc_get_leb128_int(s, &me->u.req_module_idx))
+                    goto fail;
+                if (bc_get_atom(s, &me->local_name))
+                    goto fail;
+            }
+            if (bc_get_atom(s, &me->export_name))
+                goto fail;
+        }
+    }
+
+    if (bc_get_leb128_int(s, &m->star_export_entries_count))
+        goto fail;
+    if (m->star_export_entries_count != 0) {
+        m->star_export_entries_size = m->star_export_entries_count;
+        m->star_export_entries = js_mallocz(ctx, sizeof(m->star_export_entries[0]) * m->star_export_entries_size);
+        if (!m->star_export_entries)
+            goto fail;
+        for(i = 0; i < m->star_export_entries_count; i++) {
+            JSStarExportEntry *se = &m->star_export_entries[i];
+            if (bc_get_leb128_int(s, &se->req_module_idx))
+                goto fail;
+        }
+    }
+
+    if (bc_get_leb128_int(s, &m->import_entries_count))
+        goto fail;
+    if (m->import_entries_count != 0) {
+        m->import_entries_size = m->import_entries_count;
+        m->import_entries = js_mallocz(ctx, sizeof(m->import_entries[0]) * m->import_entries_size);
+        if (!m->import_entries)
+            goto fail;
+        for(i = 0; i < m->import_entries_count; i++) {
+            JSImportEntry *mi = &m->import_entries[i];
+            if (bc_get_leb128_int(s, &mi->var_idx))
+                goto fail;
+            if (bc_get_atom(s, &mi->import_name))
+                goto fail;
+            if (bc_get_leb128_int(s, &mi->req_module_idx))
+                goto fail;
+        }
+    }
+
+    m->func_obj = JS_ReadObjectRec(s);
+    if (JS_IsException(m->func_obj))
+        goto fail;
+    return obj;
+ fail:
+    if (m) {
+        js_free_module_def(ctx, m);
+    }
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadObjectTag(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSValue obj;
+    uint32_t prop_count, i;
+    JSAtom atom;
+    JSValue val;
+    int ret;
+    
+    obj = JS_NewObject(ctx);
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    if (bc_get_leb128(s, &prop_count))
+        goto fail;
+    for(i = 0; i < prop_count; i++) {
+        if (bc_get_atom(s, &atom))
+            goto fail;
+#ifdef DUMP_READ_OBJECT
+        bc_read_trace(s, "propname: "); print_atom(s->ctx, atom); printf("\n");
+#endif
+        val = JS_ReadObjectRec(s);
+        if (JS_IsException(val)) {
+            JS_FreeAtom(ctx, atom);
+            goto fail;
+        }
+        ret = JS_DefinePropertyValue(ctx, obj, atom, val, JS_PROP_C_W_E);
+        JS_FreeAtom(ctx, atom);
+        if (ret < 0)
+            goto fail;
+    }
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadArray(BCReaderState *s, int tag)
+{
+    JSContext *ctx = s->ctx;
+    JSValue obj;
+    uint32_t len, i;
+    JSValue val;
+    int ret, prop_flags;
+    BOOL is_template;
+
+    obj = JS_NewArray(ctx);
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    is_template = (tag == BC_TAG_TEMPLATE_OBJECT);
+    if (bc_get_leb128(s, &len))
+        goto fail;
+    for(i = 0; i < len; i++) {
+        val = JS_ReadObjectRec(s);
+        if (JS_IsException(val))
+            goto fail;
+        if (is_template)
+            prop_flags = JS_PROP_ENUMERABLE;
+        else
+            prop_flags = JS_PROP_C_W_E;
+        ret = JS_DefinePropertyValueUint32(ctx, obj, i, val,
+                                           prop_flags);
+        if (ret < 0)
+            goto fail;
+    }
+    if (is_template) {
+        val = JS_ReadObjectRec(s);
+        if (JS_IsException(val))
+            goto fail;
+        if (!JS_IsUndefined(val)) {
+            ret = JS_DefinePropertyValue(ctx, obj, JS_ATOM_raw, val, 0);
+            if (ret < 0)
+                goto fail;
+        }
+        JS_PreventExtensions(ctx, obj);
+    }
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadTypedArray(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSValue obj = JS_UNDEFINED, array_buffer = JS_UNDEFINED;
+    uint8_t array_tag;
+    JSValueConst args[3];
+    uint32_t offset, len, idx;
+    
+    if (bc_get_u8(s, &array_tag))
+        return JS_EXCEPTION;
+    if (array_tag >= JS_TYPED_ARRAY_COUNT)
+        return JS_ThrowTypeError(ctx, "invalid typed array");
+    if (bc_get_leb128(s, &len))
+        return JS_EXCEPTION;
+    if (bc_get_leb128(s, &offset))
+        return JS_EXCEPTION;
+    /* XXX: this hack could be avoided if the typed array could be
+       created before the array buffer */
+    idx = s->objects_count;
+    if (BC_add_object_ref1(s, NULL))
+        goto fail;
+    array_buffer = JS_ReadObjectRec(s);
+    if (JS_IsException(array_buffer))
+        return JS_EXCEPTION;
+    if (!js_get_array_buffer(ctx, array_buffer)) {
+        JS_FreeValue(ctx, array_buffer);
+        return JS_EXCEPTION;
+    }
+    args[0] = array_buffer;
+    args[1] = JS_NewInt64(ctx, offset);
+    args[2] = JS_NewInt64(ctx, len);
+    obj = js_typed_array_constructor(ctx, JS_UNDEFINED,
+                                     3, args,
+                                     JS_CLASS_UINT8C_ARRAY + array_tag);
+    if (JS_IsException(obj))
+        goto fail;
+    if (s->allow_reference) {
+        s->objects[idx] = JS_VALUE_GET_OBJ(obj);
+    }
+    JS_FreeValue(ctx, array_buffer);
+    return obj;
+ fail:
+    JS_FreeValue(ctx, array_buffer);
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadArrayBuffer(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    uint32_t byte_length;
+    JSValue obj;
+    
+    if (bc_get_leb128(s, &byte_length))
+        return JS_EXCEPTION;
+    if (unlikely(s->buf_end - s->ptr < byte_length)) {
+        bc_read_error_end(s);
+        return JS_EXCEPTION;
+    }
+    obj = JS_NewArrayBufferCopy(ctx, s->ptr, byte_length);
+    if (JS_IsException(obj))
+        goto fail;
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    s->ptr += byte_length;
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadSharedArrayBuffer(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    uint32_t byte_length;
+    uint8_t *data_ptr;
+    JSValue obj;
+    uint64_t u64;
+    
+    if (bc_get_leb128(s, &byte_length))
+        return JS_EXCEPTION;
+    if (bc_get_u64(s, &u64))
+        return JS_EXCEPTION;
+    data_ptr = (uint8_t *)(uintptr_t)u64;
+    /* the SharedArrayBuffer is cloned */
+    obj = js_array_buffer_constructor3(ctx, JS_UNDEFINED, byte_length,
+                                       JS_CLASS_SHARED_ARRAY_BUFFER,
+                                       data_ptr,
+                                       NULL, NULL, FALSE);
+    if (JS_IsException(obj))
+        goto fail;
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadDate(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSValue val, obj = JS_UNDEFINED;
+
+    val = JS_ReadObjectRec(s);
+    if (JS_IsException(val))
+        goto fail;
+    if (!JS_IsNumber(val)) {
+        JS_ThrowTypeError(ctx, "Number tag expected for date");
+        goto fail;
+    }
+    obj = JS_NewObjectProtoClass(ctx, ctx->class_proto[JS_CLASS_DATE],
+                                 JS_CLASS_DATE);
+    if (JS_IsException(obj))
+        goto fail;
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    JS_SetObjectData(ctx, obj, val);
+    return obj;
+ fail:
+    JS_FreeValue(ctx, val);
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue JS_ReadObjectValue(BCReaderState *s)
+{
+    JSContext *ctx = s->ctx;
+    JSValue val, obj = JS_UNDEFINED;
+
+    val = JS_ReadObjectRec(s);
+    if (JS_IsException(val))
+        goto fail;
+    obj = JS_ToObject(ctx, val);
+    if (JS_IsException(obj))
+        goto fail;
+    if (BC_add_object_ref(s, obj))
+        goto fail;
+    JS_FreeValue(ctx, val);
+    return obj;
+ fail:
+    JS_FreeValue(ctx, val);
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
 static JSValue JS_ReadObjectRec(BCReaderState *s)
 {
     JSContext *ctx = s->ctx;
     uint8_t tag;
     JSValue obj = JS_UNDEFINED;
-    JSModuleDef *m = NULL;
+
+    if (js_check_stack_overflow(ctx->rt, 0))
+        return JS_ThrowStackOverflow(ctx);
 
     if (bc_get_u8(s, &tag))
         return JS_EXCEPTION;
 
+    bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
+
     switch(tag) {
     case BC_TAG_NULL:
-        bc_read_trace(s, "null\n");
         obj = JS_NULL;
         break;
     case BC_TAG_UNDEFINED:
-        bc_read_trace(s, "undefined\n");
         obj = JS_UNDEFINED;
         break;
     case BC_TAG_BOOL_FALSE:
     case BC_TAG_BOOL_TRUE:
-        bc_read_trace(s, "%s\n", bc_tag_str[tag]);
         obj = JS_NewBool(ctx, tag - BC_TAG_BOOL_FALSE);
         break;
     case BC_TAG_INT32:
@@ -33990,7 +35174,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
             int32_t val;
             if (bc_get_sleb128(s, &val))
                 return JS_EXCEPTION;
-            bc_read_trace(s, "int32 %d\n", val);
+            bc_read_trace(s, "%d\n", val);
             obj = JS_NewInt32(ctx, val);
         }
         break;
@@ -33999,7 +35183,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
             JSFloat64Union u;
             if (bc_get_u64(s, &u.u64))
                 return JS_EXCEPTION;
-            bc_read_trace(s, "float64 %g\n", u.d);
+            bc_read_trace(s, "%g\n", u.d);
             obj = __JS_NewFloat64(ctx, u.d);
         }
         break;
@@ -34013,378 +35197,68 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
         }
         break;
     case BC_TAG_FUNCTION_BYTECODE:
-        {
-            JSFunctionBytecode bc, *b;
-            uint16_t v16;
-            uint8_t v8;
-            int idx, i, local_count;
-            int function_size, cpool_offset, byte_code_offset;
-            int closure_var_offset, vardefs_offset;
-
-            if (!s->allow_bytecode)
-                goto invalid_tag;
-            bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-
-            memset(&bc, 0, sizeof(bc));
-            bc.header.ref_count = 1;
-            //bc.gc_header.mark = 0;
-
-            if (bc_get_u16(s, &v16))
-                goto fail;
-            idx = 0;
-            bc.has_prototype = bc_get_flags(v16, &idx, 1);
-            bc.has_simple_parameter_list = bc_get_flags(v16, &idx, 1);
-            bc.is_derived_class_constructor = bc_get_flags(v16, &idx, 1);
-            bc.need_home_object = bc_get_flags(v16, &idx, 1);
-            bc.func_kind = bc_get_flags(v16, &idx, 2);
-            bc.new_target_allowed = bc_get_flags(v16, &idx, 1);
-            bc.super_call_allowed = bc_get_flags(v16, &idx, 1);
-            bc.super_allowed = bc_get_flags(v16, &idx, 1);
-            bc.arguments_allowed = bc_get_flags(v16, &idx, 1);
-            bc.has_debug = bc_get_flags(v16, &idx, 1);
-            bc.backtrace_barrier = bc_get_flags(v16, &idx, 1);
-            bc.read_only_bytecode = s->is_rom_data;
-            if (bc_get_u8(s, &v8))
-                goto fail;
-            bc.js_mode = v8;
-            if (bc_get_atom(s, &bc.func_name))  //@ atom leak if failure
-                goto fail;
-            if (bc_get_leb128_u16(s, &bc.arg_count))
-                goto fail;
-            if (bc_get_leb128_u16(s, &bc.var_count))
-                goto fail;
-            if (bc_get_leb128_u16(s, &bc.defined_arg_count))
-                goto fail;
-            if (bc_get_leb128_u16(s, &bc.stack_size))
-                goto fail;
-            if (bc_get_leb128_int(s, &bc.closure_var_count))
-                goto fail;
-            if (bc_get_leb128_int(s, &bc.cpool_count))
-                goto fail;
-            if (bc_get_leb128_int(s, &bc.byte_code_len))
-                goto fail;
-            if (bc_get_leb128_int(s, &local_count))
-                goto fail;
-
-            if (bc.has_debug) {
-                function_size = sizeof(*b);
-            } else {
-                function_size = offsetof(JSFunctionBytecode, debug);
-            }
-            cpool_offset = function_size;
-            function_size += bc.cpool_count * sizeof(*bc.cpool);
-            vardefs_offset = function_size;
-            function_size += local_count * sizeof(*bc.vardefs);
-            closure_var_offset = function_size;
-            function_size += bc.closure_var_count * sizeof(*bc.closure_var);
-            byte_code_offset = function_size;
-            if (!bc.read_only_bytecode) {
-                function_size += bc.byte_code_len;
-            }
-
-            b = js_mallocz(ctx, function_size);
-            if (!b)
-                return JS_EXCEPTION;
-            
-            memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
-            b->header.ref_count = 1;
-            add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-            
-            obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
-
-#ifdef DUMP_READ_OBJECT
-            bc_read_trace(s, "name: "); print_atom(s->ctx, b->func_name); printf("\n");
-#endif
-            bc_read_trace(s, "args=%d vars=%d defargs=%d closures=%d cpool=%d\n",
-                          b->arg_count, b->var_count, b->defined_arg_count,
-                          b->closure_var_count, b->cpool_count);
-            bc_read_trace(s, "stack=%d bclen=%d locals=%d\n",
-                          b->stack_size, b->byte_code_len, local_count);
-
-            if (local_count != 0) {
-                bc_read_trace(s, "vars {\n");
-                b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
-                for(i = 0; i < local_count; i++) {
-                    JSVarDef *vd = &b->vardefs[i];
-                    if (bc_get_atom(s, &vd->var_name))
-                        goto fail;
-                    if (bc_get_leb128_int(s, &vd->scope_level))
-                        goto fail;
-                    if (bc_get_leb128_int(s, &vd->scope_next))
-                        goto fail;
-                    vd->scope_next--;
-                    if (bc_get_u8(s, &v8))
-                        goto fail;
-                    idx = 0;
-                    vd->var_kind = bc_get_flags(v8, &idx, 4);
-                    vd->is_func_var = bc_get_flags(v8, &idx, 1);
-                    vd->is_const = bc_get_flags(v8, &idx, 1);
-                    vd->is_lexical = bc_get_flags(v8, &idx, 1);
-                    vd->is_captured = bc_get_flags(v8, &idx, 1);
-#ifdef DUMP_READ_OBJECT
-                    bc_read_trace(s, "name: "); print_atom(s->ctx, vd->var_name); printf("\n");
-#endif
-                }
-                bc_read_trace(s, "}\n");
-            }
-            if (b->closure_var_count != 0) {
-                bc_read_trace(s, "closure vars {\n");
-                b->closure_var = (void *)((uint8_t*)b + closure_var_offset);
-                for(i = 0; i < b->closure_var_count; i++) {
-                    JSClosureVar *cv = &b->closure_var[i];
-                    int var_idx;
-                    if (bc_get_atom(s, &cv->var_name))
-                        goto fail;
-                    if (bc_get_leb128_int(s, &var_idx))
-                        goto fail;
-                    cv->var_idx = var_idx;
-                    if (bc_get_u8(s, &v8))
-                        goto fail;
-                    idx = 0;
-                    cv->is_local = bc_get_flags(v8, &idx, 1);
-                    cv->is_arg = bc_get_flags(v8, &idx, 1);
-                    cv->is_const = bc_get_flags(v8, &idx, 1);
-                    cv->is_lexical = bc_get_flags(v8, &idx, 1);
-                    cv->var_kind = bc_get_flags(v8, &idx, 4);
-#ifdef DUMP_READ_OBJECT
-                    bc_read_trace(s, "name: "); print_atom(s->ctx, cv->var_name); printf("\n");
-#endif
-                }
-                bc_read_trace(s, "}\n");
-            }
-            {
-                bc_read_trace(s, "bytecode {\n");
-                if (JS_ReadFunctionBytecode(s, b, byte_code_offset, b->byte_code_len))
-                    goto fail;
-                bc_read_trace(s, "}\n");
-            }
-            if (b->has_debug) {
-                /* read optional debug information */
-                bc_read_trace(s, "debug {\n");
-                if (bc_get_atom(s, &b->debug.filename))
-                    goto fail;
-                if (bc_get_leb128_int(s, &b->debug.line_num))
-                    goto fail;
-                if (bc_get_leb128_int(s, &b->debug.pc2line_len))
-                    goto fail;
-                if (b->debug.pc2line_len) {
-                    b->debug.pc2line_buf = js_mallocz(ctx, b->debug.pc2line_len);
-                    if (!b->debug.pc2line_buf)
-                        goto fail;
-                    if (bc_get_buf(s, b->debug.pc2line_buf, b->debug.pc2line_len))
-                        goto fail;
-                }
-#ifdef DUMP_READ_OBJECT
-                bc_read_trace(s, "filename: "); print_atom(s->ctx, b->debug.filename); printf("\n");
-#endif
-                bc_read_trace(s, "}\n");
-            }
-            if (b->cpool_count != 0) {
-                bc_read_trace(s, "cpool {\n");
-                b->cpool = (void *)((uint8_t*)b + cpool_offset);
-                for(i = 0; i < b->cpool_count; i++) {
-                    JSValue val;
-                    val = JS_ReadObjectRec(s);
-                    if (JS_IsException(val))
-                        goto fail;
-                    b->cpool[i] = val;
-                }
-                bc_read_trace(s, "}\n");
-            }
-            bc_read_trace(s, "}\n");
-            b->realm = JS_DupContext(ctx);
-        }
+        if (!s->allow_bytecode)
+            goto invalid_tag;
+        obj = JS_ReadFunctionTag(s);
         break;
     case BC_TAG_MODULE:
-        {
-            JSAtom module_name;
-            int i;
-            uint8_t v8;
-
-            if (!s->allow_bytecode)
-                goto invalid_tag;
-            bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-            if (bc_get_atom(s, &module_name))
-                goto fail;
-#ifdef DUMP_READ_OBJECT
-            bc_read_trace(s, "name: "); print_atom(s->ctx, module_name); printf("\n");
-#endif
-            m = js_new_module_def(ctx, module_name);
-            if (!m)
-                goto fail;
-            obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
-            if (bc_get_leb128_int(s, &m->req_module_entries_count))
-                goto fail;
-            if (m->req_module_entries_count != 0) {
-                m->req_module_entries_size = m->req_module_entries_count;
-                m->req_module_entries = js_mallocz(ctx, sizeof(m->req_module_entries[0]) * m->req_module_entries_size);
-                if (!m->req_module_entries)
-                    goto fail;
-                for(i = 0; i < m->req_module_entries_count; i++) {
-                    JSReqModuleEntry *rme = &m->req_module_entries[i];
-                    if (bc_get_atom(s, &rme->module_name))
-                        goto fail;
-                }
-            }
-
-            if (bc_get_leb128_int(s, &m->export_entries_count))
-                goto fail;
-            if (m->export_entries_count != 0) {
-                m->export_entries_size = m->export_entries_count;
-                m->export_entries = js_mallocz(ctx, sizeof(m->export_entries[0]) * m->export_entries_size);
-                if (!m->export_entries)
-                    goto fail;
-                for(i = 0; i < m->export_entries_count; i++) {
-                    JSExportEntry *me = &m->export_entries[i];
-                    if (bc_get_u8(s, &v8))
-                        goto fail;
-                    me->export_type = v8;
-                    if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
-                        if (bc_get_leb128_int(s, &me->u.local.var_idx))
-                            goto fail;
-                    } else {
-                        if (bc_get_leb128_int(s, &me->u.req_module_idx))
-                            goto fail;
-                        if (bc_get_atom(s, &me->local_name))
-                            goto fail;
-                    }
-                    if (bc_get_atom(s, &me->export_name))
-                        goto fail;
-                }
-            }
-
-            if (bc_get_leb128_int(s, &m->star_export_entries_count))
-                goto fail;
-            if (m->star_export_entries_count != 0) {
-                m->star_export_entries_size = m->star_export_entries_count;
-                m->star_export_entries = js_mallocz(ctx, sizeof(m->star_export_entries[0]) * m->star_export_entries_size);
-                if (!m->star_export_entries)
-                    goto fail;
-                for(i = 0; i < m->star_export_entries_count; i++) {
-                    JSStarExportEntry *se = &m->star_export_entries[i];
-                    if (bc_get_leb128_int(s, &se->req_module_idx))
-                        goto fail;
-                }
-            }
-
-            if (bc_get_leb128_int(s, &m->import_entries_count))
-                goto fail;
-            if (m->import_entries_count != 0) {
-                m->import_entries_size = m->import_entries_count;
-                m->import_entries = js_mallocz(ctx, sizeof(m->import_entries[0]) * m->import_entries_size);
-                if (!m->import_entries)
-                    goto fail;
-                for(i = 0; i < m->import_entries_count; i++) {
-                    JSImportEntry *mi = &m->import_entries[i];
-                    if (bc_get_leb128_int(s, &mi->var_idx))
-                        goto fail;
-                    if (bc_get_atom(s, &mi->import_name))
-                        goto fail;
-                    if (bc_get_leb128_int(s, &mi->req_module_idx))
-                        goto fail;
-                }
-            }
-
-            m->func_obj = JS_ReadObjectRec(s);
-            if (JS_IsException(m->func_obj))
-                goto fail;
-            bc_read_trace(s, "}\n");
-        }
+        if (!s->allow_bytecode)
+            goto invalid_tag;
+        obj = JS_ReadModule(s);
         break;
     case BC_TAG_OBJECT:
-        {
-            uint32_t prop_count, i;
-            JSAtom atom;
-            JSValue val;
-            int ret;
-
-            bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-
-            obj = JS_NewObject(ctx);
-            if (bc_get_leb128(s, &prop_count))
-                goto fail;
-            for(i = 0; i < prop_count; i++) {
-                if (bc_get_atom(s, &atom))
-                    goto fail;
-#ifdef DUMP_READ_OBJECT
-                bc_read_trace(s, "propname: "); print_atom(s->ctx, atom); printf("\n");
-#endif
-                val = JS_ReadObjectRec(s);
-                if (JS_IsException(val)) {
-                    JS_FreeAtom(ctx, atom);
-                    goto fail;
-                }
-                ret = JS_DefinePropertyValue(ctx, obj, atom, val, JS_PROP_C_W_E);
-                JS_FreeAtom(ctx, atom);
-                if (ret < 0)
-                    goto fail;
-            }
-            bc_read_trace(s, "}\n");
-        }
+        obj = JS_ReadObjectTag(s);
         break;
     case BC_TAG_ARRAY:
     case BC_TAG_TEMPLATE_OBJECT:
-        {
-            uint32_t len, i;
-            JSValue val;
-            int ret, prop_flags;
-            BOOL is_template;
-
-            bc_read_trace(s, "%s {\n", bc_tag_str[tag]);
-
-            obj = JS_NewArray(ctx);
-            is_template = (tag == BC_TAG_TEMPLATE_OBJECT);
-            if (bc_get_leb128(s, &len))
-                goto fail;
-            for(i = 0; i < len; i++) {
-                val = JS_ReadObjectRec(s);
-                if (JS_IsException(val))
-                    goto fail;
-                if (is_template)
-                    prop_flags = JS_PROP_ENUMERABLE;
-                else
-                    prop_flags = JS_PROP_C_W_E;
-                ret = JS_DefinePropertyValueUint32(ctx, obj, i, val,
-                                                   prop_flags);
-                if (ret < 0)
-                    goto fail;
-            }
-            if (is_template) {
-                val = JS_ReadObjectRec(s);
-                if (JS_IsException(val))
-                    goto fail;
-                if (!JS_IsUndefined(val)) {
-                    ret = JS_DefinePropertyValue(ctx, obj, JS_ATOM_raw, val, 0);
-                    if (ret < 0)
-                        goto fail;
-                }
-                JS_PreventExtensions(ctx, obj);
-            }
-            bc_read_trace(s, "}\n");
-        }
+        obj = JS_ReadArray(s, tag);
+        break;
+    case BC_TAG_TYPED_ARRAY:
+        obj = JS_ReadTypedArray(s);
+        break;
+    case BC_TAG_ARRAY_BUFFER:
+        obj = JS_ReadArrayBuffer(s);
+        break;
+    case BC_TAG_SHARED_ARRAY_BUFFER:
+        if (!s->allow_sab || !ctx->rt->sab_funcs.sab_dup)
+            goto invalid_tag;
+        obj = JS_ReadSharedArrayBuffer(s);
+        break;
+    case BC_TAG_DATE:
+        obj = JS_ReadDate(s);
+        break;
+    case BC_TAG_OBJECT_VALUE:
+        obj = JS_ReadObjectValue(s);
         break;
 #ifdef CONFIG_BIGNUM
     case BC_TAG_BIG_INT:
     case BC_TAG_BIG_FLOAT:
     case BC_TAG_BIG_DECIMAL:
         obj = JS_ReadBigNum(s, tag);
-        if (JS_IsException(obj))
-            goto fail;
         break;
 #endif
+    case BC_TAG_OBJECT_REFERENCE:
+        {
+            uint32_t val;
+            if (!s->allow_reference)
+                return JS_ThrowSyntaxError(ctx, "object references are not allowed");
+            if (bc_get_leb128(s, &val))
+                return JS_EXCEPTION;
+            bc_read_trace(s, "%u\n", val);
+            if (val >= s->objects_count) {
+                return JS_ThrowSyntaxError(ctx, "invalid object reference (%u >= %u)",
+                                           val, s->objects_count);
+            }
+            obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, s->objects[val]));
+        }
+        break;
     default:
     invalid_tag:
         return JS_ThrowSyntaxError(ctx, "invalid tag (tag=%d pos=%u)",
                                    tag, (unsigned int)(s->ptr - s->buf_start));
     }
+    bc_read_trace(s, "}\n");
     return obj;
- fail:
-    if (m) {
-        js_free_module_def(ctx, m);
-    } else {
-        JS_FreeValue(ctx, obj);
-    }
-    return JS_EXCEPTION;
 }
 
 static int JS_ReadObjectAtoms(BCReaderState *s)
@@ -34437,10 +35311,11 @@ static void bc_reader_free(BCReaderState *s)
         }
         js_free(s->ctx, s->idx_to_atom);
     }
+    js_free(s->ctx, s->objects);
 }
 
 JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
-                      int flags)
+                       int flags)
 {
     BCReaderState ss, *s = &ss;
     JSValue obj;
@@ -34455,6 +35330,8 @@ JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
     s->ptr = buf;
     s->allow_bytecode = ((flags & JS_READ_OBJ_BYTECODE) != 0);
     s->is_rom_data = ((flags & JS_READ_OBJ_ROM_DATA) != 0);
+    s->allow_sab = ((flags & JS_READ_OBJ_SAB) != 0);
+    s->allow_reference = ((flags & JS_READ_OBJ_REFERENCE) != 0);
     if (s->allow_bytecode)
         s->first_atom = JS_ATOM_END;
     else
@@ -34944,7 +35821,7 @@ static __exception int JS_ObjectDefineProperties(JSContext *ctx,
     if (JS_IsException(props))
         return -1;
     p = JS_VALUE_GET_OBJ(props);
-    if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK) < 0)
+    if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK) < 0)
         goto exception;
     for(i = 0; i < len; i++) {
         JS_FreeValue(ctx, desc);
@@ -35021,7 +35898,7 @@ static JSValue js_object_getPrototypeOf(JSContext *ctx, JSValueConst this_val,
             JS_VALUE_GET_TAG(val) == JS_TAG_UNDEFINED)
             return JS_ThrowTypeErrorNotAnObject(ctx);
     }
-    return JS_DupValue(ctx, JS_GetPrototype(ctx, val));
+    return JS_GetPrototype(ctx, val);
 }
 
 static JSValue js_object_setPrototypeOf(JSContext *ctx, JSValueConst this_val,
@@ -35815,7 +36692,7 @@ static JSValue js_object_get___proto__(JSContext *ctx, JSValueConst this_val)
     val = JS_ToObject(ctx, this_val);
     if (JS_IsException(val))
         return val;
-    ret = JS_DupValue(ctx, JS_GetPrototype(ctx, val));
+    ret = JS_GetPrototype(ctx, val);
     JS_FreeValue(ctx, val);
     return ret;
 }
@@ -35836,9 +36713,9 @@ static JSValue js_object_set___proto__(JSContext *ctx, JSValueConst this_val,
 static JSValue js_object_isPrototypeOf(JSContext *ctx, JSValueConst this_val,
                                        int argc, JSValueConst *argv)
 {
-    JSValue obj;
+    JSValue obj, v1;
     JSValueConst v;
-    int max_depth = 1000, res = -1;
+    int res;
 
     v = argv[0];
     if (!JS_IsObject(v))
@@ -35846,27 +36723,29 @@ static JSValue js_object_isPrototypeOf(JSContext *ctx, JSValueConst this_val,
     obj = JS_ToObject(ctx, this_val);
     if (JS_IsException(obj))
         return JS_EXCEPTION;
-    while (--max_depth > 0) {
-        v = JS_GetPrototype(ctx, v);
-        if (JS_IsException(v))
+    v1 = JS_DupValue(ctx, v);
+    for(;;) {
+        v1 = JS_GetPrototypeFree(ctx, v1);
+        if (JS_IsException(v1))
             goto exception;
-        if (JS_IsNull(v)) {
+        if (JS_IsNull(v1)) {
             res = FALSE;
             break;
         }
-        if (js_strict_eq2(ctx, JS_DupValue(ctx, obj), JS_DupValue(ctx, v),
-                          JS_EQ_STRICT)) {
+        if (JS_VALUE_GET_OBJ(obj) == JS_VALUE_GET_OBJ(v1)) {
             res = TRUE;
             break;
         }
+        /* avoid infinite loop (possible with proxies) */
+        if (js_poll_interrupts(ctx))
+            goto exception;
     }
+    JS_FreeValue(ctx, v1);
     JS_FreeValue(ctx, obj);
-    if (res < 0)
-        return JS_ThrowInternalError(ctx, "prototype chain cycle");
-    else
-        return JS_NewBool(ctx, res);
+    return JS_NewBool(ctx, res);
 
 exception:
+    JS_FreeValue(ctx, v1);
     JS_FreeValue(ctx, obj);
     return JS_EXCEPTION;
 }
@@ -35906,7 +36785,6 @@ static JSValue js_object___lookupGetter__(JSContext *ctx, JSValueConst this_val,
                                           int argc, JSValueConst *argv, int setter)
 {
     JSValue obj, res = JS_EXCEPTION;
-    JSValueConst v;
     JSAtom prop = JS_ATOM_NULL;
     JSPropertyDescriptor desc;
     int has_prop;
@@ -35918,8 +36796,8 @@ static JSValue js_object___lookupGetter__(JSContext *ctx, JSValueConst this_val,
     if (unlikely(prop == JS_ATOM_NULL))
         goto exception;
 
-    for (v = obj;;) {
-        has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(v), prop);
+    for (;;) {
+        has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
         if (has_prop < 0)
             goto exception;
         if (has_prop) {
@@ -35930,13 +36808,16 @@ static JSValue js_object___lookupGetter__(JSContext *ctx, JSValueConst this_val,
             js_free_desc(ctx, &desc);
             break;
         }
-        v = JS_GetPrototype(ctx, v);
-        if (JS_IsException(v))
+        obj = JS_GetPrototypeFree(ctx, obj);
+        if (JS_IsException(obj))
             goto exception;
-        if (JS_IsNull(v)) {
+        if (JS_IsNull(obj)) {
             res = JS_UNDEFINED;
             break;
         }
+        /* avoid infinite loop (possible with proxies) */
+        if (js_poll_interrupts(ctx))
+            goto exception;
     }
 
 exception:
@@ -36002,59 +36883,12 @@ static JSValue js_function_proto(JSContext *ctx, JSValueConst this_val,
     return JS_UNDEFINED;
 }
 
-/* insert a '\n' at unicode character position 'pos' in the source of
-   'func_obj' */
-static int patch_function_constructor_source(JSContext *ctx,
-                                             JSValueConst func_obj,
-                                             size_t pos)
-{
-    JSObject *p;
-    JSFunctionBytecode *b;
-    char *r, *r_end, *new_source;
-    int c;
-    size_t idx, len;
-    
-    if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
-        return 0;
-    p = JS_VALUE_GET_OBJ(func_obj);
-    if (!js_class_has_bytecode(p->class_id))
-        return 0;
-    b = p->u.func.function_bytecode;
-    if (!b->has_debug)
-        return 0;
-    r = b->debug.source;
-    r_end = b->debug.source + b->debug.source_len;
-    idx = 0;
-    while (r < r_end) {
-        if (idx == pos) {
-            /* add the '\n' */
-            new_source = js_realloc(ctx, b->debug.source,
-                                    b->debug.source_len + 2);
-            if (!new_source)
-                return -1;
-            len = r - b->debug.source;
-            memmove(new_source + len + 1, new_source + len,
-                    b->debug.source_len + 1 - len);
-            new_source[len] = '\n';
-            b->debug.source = new_source;
-            b->debug.source_len++;
-            break;
-        }
-        c = unicode_from_utf8((const uint8_t *)r, UTF8_CHAR_LEN_MAX,
-                              (const uint8_t **)&r);
-        if (c < 0)
-            break;
-        idx++;
-    }
-    return 0;
-}
-                                             
 /* XXX: add a specific eval mode so that Function("}), ({") is rejected */
 static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
                                        int argc, JSValueConst *argv, int magic)
 {
     JSFunctionKindEnum func_kind = magic;
-    int i, n, ret, func_start_pos;
+    int i, n, ret;
     JSValue s, proto, obj = JS_UNDEFINED;
     StringBuffer b_s, *b = &b_s;
 
@@ -36079,13 +36913,7 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
         if (string_buffer_concat_value(b, argv[i]))
             goto fail;
     }
-    string_buffer_puts8(b, "\n) {");
-    /* Annex B HTML comments: We don't add a '\n' after "{" so that
-       "-->" is not considered as an HTML comment. It is necessary
-       because in the spec the function body is parsed separately. */
-    /* XXX: find a simpler way or be deliberately incompatible to
-       simplify the code ? */
-    func_start_pos = b->len - 1; /* the leading '(' is not in the source */
+    string_buffer_puts8(b, "\n) {\n");
     if (n >= 0) {
         if (string_buffer_concat_value(b, argv[n]))
             goto fail;
@@ -36099,8 +36927,6 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
     JS_FreeValue(ctx, s);
     if (JS_IsException(obj))
         goto fail1;
-    if (patch_function_constructor_source(ctx, obj, func_start_pos) < 0)
-        goto fail1;
     if (!JS_IsUndefined(new_target)) {
         /* set the prototype */
         proto = JS_GetProperty(ctx, new_target, JS_ATOM_prototype);
@@ -36315,27 +37141,22 @@ static JSValue js_function_toString(JSContext *ctx, JSValueConst this_val,
         JSValue name;
         const char *pref, *suff;
 
-        if (p->is_class) {
-            pref = "class ";
-            suff = " {\n    [native code]\n}";
-        } else {
-            switch(func_kind) {
-            default:
-            case JS_FUNC_NORMAL:
-                pref = "function ";
-                break;
-            case JS_FUNC_GENERATOR:
-                pref = "function *";
-                break;
-            case JS_FUNC_ASYNC:
-                pref = "async function ";
-                break;
-            case JS_FUNC_ASYNC_GENERATOR:
-                pref = "async function *";
-                break;
-            }
-            suff = "() {\n    [native code]\n}";
+        switch(func_kind) {
+        default:
+        case JS_FUNC_NORMAL:
+            pref = "function ";
+            break;
+        case JS_FUNC_GENERATOR:
+            pref = "function *";
+            break;
+        case JS_FUNC_ASYNC:
+            pref = "async function ";
+            break;
+        case JS_FUNC_ASYNC_GENERATOR:
+            pref = "async function *";
+            break;
         }
+        suff = "() {\n    [native code]\n}";
         name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
         if (JS_IsUndefined(name))
             name = JS_AtomToString(ctx, JS_ATOM_empty_string);
@@ -36435,12 +37256,6 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
     if (JS_IsException(obj))
         return obj;
     if (magic == JS_AGGREGATE_ERROR) {
-        JSObject *p;
-        JSValue error_list = iterator_to_array(ctx, argv[0]);
-        if (JS_IsException(error_list))
-            goto exception;
-        p = JS_VALUE_GET_OBJ(obj);
-        p->u.object_data = error_list;
         message = argv[1];
     } else {
         message = argv[0];
@@ -36448,17 +37263,26 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
 
     if (!JS_IsUndefined(message)) {
         msg = JS_ToString(ctx, message);
-        if (unlikely(JS_IsException(msg))) {
-        exception:
-            JS_FreeValue(ctx, obj);
-            return JS_EXCEPTION;
-        }
+        if (unlikely(JS_IsException(msg)))
+            goto exception;
         JS_DefinePropertyValue(ctx, obj, JS_ATOM_message, msg,
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     }
+
+    if (magic == JS_AGGREGATE_ERROR) {
+        JSValue error_list = iterator_to_array(ctx, argv[0]);
+        if (JS_IsException(error_list))
+            goto exception;
+        JS_DefinePropertyValue(ctx, obj, JS_ATOM_errors, error_list,
+                               JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    }
+
     /* skip the Error() function in the backtrace */
     build_backtrace(ctx, obj, NULL, 0, JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL);
     return obj;
+ exception:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
 }
 
 static JSValue js_error_toString(JSContext *ctx, JSValueConst this_val,
@@ -36498,56 +37322,22 @@ static const JSCFunctionListEntry js_error_proto_funcs[] = {
 
 /* AggregateError */
 
-/* used by C code. 'errors' must be a fast array. */
+/* used by C code. */
 static JSValue js_aggregate_error_constructor(JSContext *ctx,
                                               JSValueConst errors)
 {
     JSValue obj;
-    JSObject *p;
     
     obj = JS_NewObjectProtoClass(ctx,
                                  ctx->native_error_proto[JS_AGGREGATE_ERROR],
                                  JS_CLASS_ERROR);
     if (JS_IsException(obj))
         return obj;
-    p = JS_VALUE_GET_OBJ(obj);
-    p->u.object_data = JS_DupValue(ctx, errors);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_errors, JS_DupValue(ctx, errors),
+                           JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     return obj;
 }
 
-static JSValue js_aggregate_error_errors(JSContext *ctx, JSValueConst this_val)
-{
-    JSObject *p;
-    JSValue r, *arr;
-    uint32_t len, i;
-    
-    if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
-        goto invalid_type;
-    p = JS_VALUE_GET_OBJ(this_val);
-    if (p->class_id != JS_CLASS_ERROR)
-        goto invalid_type;
-    if (!js_get_fast_array(ctx, p->u.object_data, &arr, &len)) {
-    invalid_type:
-        return JS_ThrowTypeError(ctx, "not an AggregateError");
-    }
-    r = JS_NewArray(ctx);
-    if (JS_IsException(r))
-        goto exception;
-    for(i = 0; i < len; i++) {
-        if (JS_DefinePropertyValueInt64(ctx, r, i, JS_DupValue(ctx, arr[i]),
-                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0)
-            goto exception;
-    }
-    return r;
- exception:
-    JS_FreeValue(ctx, r);
-    return JS_EXCEPTION;
-}
-
-static const JSCFunctionListEntry js_aggregate_error_proto_funcs[] = {
-    JS_CGETSET_DEF("errors", js_aggregate_error_errors, NULL),
-};
-
 /* Array */
 
 static int JS_CopySubArray(JSContext *ctx,
@@ -39130,22 +39920,25 @@ static JSValue js_string_includes(JSContext *ctx, JSValueConst this_val,
     p1 = JS_VALUE_GET_STRING(v);
     len = p->len;
     v_len = p1->len;
-    pos = (magic & 2) ? len : 0;
+    pos = (magic == 2) ? len : 0;
     if (argc > 1 && !JS_IsUndefined(argv[1])) {
         if (JS_ToInt32Clamp(ctx, &pos, argv[1], 0, len, 0))
             goto fail;
     }
     len -= v_len;
-    start = pos;
-    stop = len;
-    if (magic & 1) {
-        stop = pos;
-    }
-    if (magic & 2) {
-        pos -= v_len;
+    ret = 0;
+    if (magic == 0) {
+        start = pos;
+        stop = len;
+    } else {
+        if (magic == 1) {
+            if (pos > len)
+                goto done;
+        } else {
+            pos -= v_len;
+        }
         start = stop = pos;
     }
-    ret = 0;
     if (start >= 0 && start <= stop) {
         for (i = start;; i++) {
             if (!string_cmp(p, p1, i, 0, v_len)) {
@@ -39156,6 +39949,7 @@ static JSValue js_string_includes(JSContext *ctx, JSValueConst this_val,
                 break;
         }
     }
+ done:
     JS_FreeValue(ctx, str);
     JS_FreeValue(ctx, v);
     return JS_NewBool(ctx, ret);
@@ -40372,46 +41166,23 @@ static double js_math_round(double a)
 static JSValue js_math_hypot(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
-    double r, a, b;
+    double r, a;
     int i;
 
-    if (argc == 2) {
-        /* use the more precise built-in function when possible */
-        if (JS_ToFloat64(ctx, &a, argv[0]))
-            return JS_EXCEPTION;
-        if (JS_ToFloat64(ctx, &b, argv[1]))
-            return JS_EXCEPTION;
-        r = hypot(a, b);
-    } else if (argc == 0) {
-        r = 0;
-    } else {
-        double *tab, a_max;
-        tab = js_malloc(ctx, sizeof(tab[0]) * argc);
-        if (!tab)
+    r = 0;
+    if (argc > 0) {
+        if (JS_ToFloat64(ctx, &r, argv[0]))
             return JS_EXCEPTION;
-        /* avoid overflow by taking the maximum */
-        a_max = 0;
-        for(i = 0; i < argc; i++) {
-            if (JS_ToFloat64(ctx, &a, argv[i])) {
-                js_free(ctx, tab);
-                return JS_EXCEPTION;
-            }
-            a = fabs(a);
-            tab[i] = a;
-            if (a > a_max)
-                a_max = a;
-        }
-        if (a_max == 0 || !isfinite(a_max)) {
-            r = a_max;
+        if (argc == 1) {
+            r = fabs(r);
         } else {
-            r = 0;
-            for(i = 0; i < argc; i++) {
-                a = tab[i] / a_max;
-                r += a * a;
+            /* use the built-in function to minimize precision loss */
+            for (i = 1; i < argc; i++) {
+                if (JS_ToFloat64(ctx, &a, argv[i]))
+                    return JS_EXCEPTION;
+                r = hypot(r, a);
             }
-            r = a_max * sqrt(r);
         }
-        js_free(ctx, tab);
     }
     return JS_NewFloat64(ctx, r);
 }
@@ -42093,58 +42864,69 @@ void JS_AddIntrinsicRegExp(JSContext *ctx)
 
 /* JSON */
 
-/* XXX: this parser is less strict than the JSON standard because we
-   reuse the Javascript tokenizer. It could be improved by adding a
-   specific JSON parse flag. */
+static int json_parse_expect(JSParseState *s, int tok)
+{
+    if (s->token.val != tok) {
+        /* XXX: dump token correctly in all cases */
+        return js_parse_error(s, "expecting '%c'", tok);
+    }
+    return json_next_token(s);
+}
+
 static JSValue json_parse_value(JSParseState *s)
 {
     JSContext *ctx = s->ctx;
     JSValue val = JS_NULL;
-    BOOL is_neg;
     int ret;
 
     switch(s->token.val) {
     case '{':
         {
-            JSValue prop_val, prop_str;
-
-            if (next_token(s))
+            JSValue prop_val;
+            JSAtom prop_name;
+            
+            if (json_next_token(s))
                 goto fail;
             val = JS_NewObject(ctx);
             if (JS_IsException(val))
                 goto fail;
             if (s->token.val != '}') {
                 for(;;) {
-                    if (s->token.val != TOK_STRING) {
+                    if (s->token.val == TOK_STRING) {
+                        prop_name = JS_ValueToAtom(ctx, s->token.u.str.str);
+                        if (prop_name == JS_ATOM_NULL)
+                            goto fail;
+                    } else if (s->ext_json && s->token.val == TOK_IDENT) {
+                        prop_name = JS_DupAtom(ctx, s->token.u.ident.atom);
+                    } else {
                         js_parse_error(s, "expecting property name");
                         goto fail;
                     }
-                    prop_str = JS_DupValue(ctx, s->token.u.str.str);
-                    if (next_token(s)) {
-                        JS_FreeValue(ctx, prop_str);
-                        goto fail;
-                    }
-                    if (js_parse_expect(s, ':')) {
-                        JS_FreeValue(ctx, prop_str);
-                        goto fail;
-                    }
+                    if (json_next_token(s))
+                        goto fail1;
+                    if (json_parse_expect(s, ':'))
+                        goto fail1;
                     prop_val = json_parse_value(s);
                     if (JS_IsException(prop_val)) {
-                        JS_FreeValue(ctx, prop_str);
+                    fail1:
+                        JS_FreeAtom(ctx, prop_name);
                         goto fail;
                     }
-                    ret = JS_DefinePropertyValueValue(ctx, val, prop_str,
-                                                      prop_val, JS_PROP_C_W_E);
+                    ret = JS_DefinePropertyValue(ctx, val, prop_name,
+                                                 prop_val, JS_PROP_C_W_E);
+                    JS_FreeAtom(ctx, prop_name);
                     if (ret < 0)
                         goto fail;
 
                     if (s->token.val != ',')
                         break;
-                    if (next_token(s))
+                    if (json_next_token(s))
                         goto fail;
+                    if (s->ext_json && s->token.val == '}')
+                        break;
                 }
             }
-            if (js_parse_expect(s, '}'))
+            if (json_parse_expect(s, '}'))
                 goto fail;
         }
         break;
@@ -42153,7 +42935,7 @@ static JSValue json_parse_value(JSParseState *s)
             JSValue el;
             uint32_t idx;
 
-            if (next_token(s))
+            if (json_next_token(s))
                 goto fail;
             val = JS_NewArray(ctx);
             if (JS_IsException(val))
@@ -42169,52 +42951,41 @@ static JSValue json_parse_value(JSParseState *s)
                         goto fail;
                     if (s->token.val != ',')
                         break;
-                    if (next_token(s))
+                    if (json_next_token(s))
                         goto fail;
                     idx++;
+                    if (s->ext_json && s->token.val == ']')
+                        break;
                 }
             }
-            if (js_parse_expect(s, ']'))
+            if (json_parse_expect(s, ']'))
                 goto fail;
         }
         break;
     case TOK_STRING:
         val = JS_DupValue(ctx, s->token.u.str.str);
-        if (next_token(s))
+        if (json_next_token(s))
             goto fail;
         break;
     case TOK_NUMBER:
-        is_neg = 0;
-        goto number;
-    case '-':
-        if (next_token(s))
-            goto fail;
-        if (s->token.val != TOK_NUMBER) {
-            js_parse_error(s, "number expected");
-            goto fail;
-        }
-        is_neg = 1;
-    number:
         val = s->token.u.num.val;
-        if (is_neg) {
-            double d;
-            JS_ToFloat64(ctx, &d, val);  /* no exception possible */
-            val = JS_NewFloat64(ctx, -d);
-        }
-        if (next_token(s))
+        if (json_next_token(s))
             goto fail;
         break;
-    case TOK_FALSE:
-    case TOK_TRUE:
-        val = JS_NewBool(ctx, s->token.val - TOK_FALSE);
-        if (next_token(s))
-            goto fail;
-        break;
-    case TOK_NULL:
-        if (next_token(s))
+    case TOK_IDENT:
+        if (s->token.u.ident.atom == JS_ATOM_false ||
+            s->token.u.ident.atom == JS_ATOM_true) {
+            val = JS_NewBool(ctx, (s->token.u.ident.atom == JS_ATOM_true));
+        } else if (s->token.u.ident.atom == JS_ATOM_null) {
+            val = JS_NULL;
+        } else {
+            goto def_token;
+        }
+        if (json_next_token(s))
             goto fail;
         break;
     default:
+    def_token:
         if (s->token.val == TOK_EOF) {
             js_parse_error(s, "unexpected end of input");
         } else {
@@ -42229,15 +43000,15 @@ static JSValue json_parse_value(JSParseState *s)
     return JS_EXCEPTION;
 }
 
-JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
-                     const char *filename)
+JSValue JS_ParseJSON2(JSContext *ctx, const char *buf, size_t buf_len,
+                      const char *filename, int flags)
 {
     JSParseState s1, *s = &s1;
-    JSValue val;
+    JSValue val = JS_UNDEFINED;
 
     js_parse_init(ctx, s, buf, buf_len, filename);
-
-    if (next_token(s))
+    s->ext_json = ((flags & JS_PARSE_JSON_EXT) != 0);
+    if (json_next_token(s))
         goto fail;
     val = json_parse_value(s);
     if (JS_IsException(val))
@@ -42248,10 +43019,17 @@ JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
     }
     return val;
  fail:
+    JS_FreeValue(ctx, val);
     free_token(s, &s->token);
     return JS_EXCEPTION;
 }
 
+JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
+                     const char *filename)
+{
+    return JS_ParseJSON2(ctx, buf, buf_len, filename, 0); 
+}
+
 static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
                                          JSAtom name, JSValueConst reviver)
 {
@@ -42960,7 +43738,6 @@ static void js_proxy_finalizer(JSRuntime *rt, JSValue val)
     if (s) {
         JS_FreeValueRT(rt, s->target);
         JS_FreeValueRT(rt, s->handler);
-        JS_FreeValueRT(rt, s->proto);
         js_free_rt(rt, s);
     }
 }
@@ -42972,7 +43749,6 @@ static void js_proxy_mark(JSRuntime *rt, JSValueConst val,
     if (s) {
         JS_MarkValue(rt, s->target, mark_func);
         JS_MarkValue(rt, s->handler, mark_func);
-        JS_MarkValue(rt, s->proto, mark_func);
     }
 }
 
@@ -43007,17 +43783,12 @@ static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
     return s;
 }
 
-static JSValueConst js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
+static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
 {
     JSProxyData *s;
-    JSValue method, ret;
-    JSValueConst proto1;
+    JSValue method, ret, proto1;
     int res;
 
-    /* must check for timeout to avoid infinite loop in instanceof */
-    if (js_poll_interrupts(ctx))
-        return JS_EXCEPTION;
-
     s = get_proxy_method(ctx, &method, obj, JS_ATOM_getPrototypeOf);
     if (!s)
         return JS_EXCEPTION;
@@ -43043,22 +43814,22 @@ static JSValueConst js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
             return JS_EXCEPTION;
         }
         if (JS_VALUE_GET_OBJ(proto1) != JS_VALUE_GET_OBJ(ret)) {
+            JS_FreeValue(ctx, proto1);
         fail:
             JS_FreeValue(ctx, ret);
             return JS_ThrowTypeError(ctx, "proxy: inconsistent prototype");
         }
+        JS_FreeValue(ctx, proto1);
     }
-    /* store the prototype in the proxy so that its refcount is at least 1 */
-    set_value(ctx, &s->proto, ret);
-    return (JSValueConst)ret;
+    return ret;
 }
 
 static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
                                    JSValueConst proto_val, BOOL throw_flag)
 {
     JSProxyData *s;
-    JSValue method, ret;
-    JSValueConst args[2], proto1;
+    JSValue method, ret, proto1;
+    JSValueConst args[2];
     BOOL res;
     int res2;
 
@@ -43089,9 +43860,11 @@ static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
         if (JS_IsException(proto1))
             return -1;
         if (JS_VALUE_GET_OBJ(proto_val) != JS_VALUE_GET_OBJ(proto1)) {
+            JS_FreeValue(ctx, proto1);
             JS_ThrowTypeError(ctx, "proxy: inconsistent prototype");
             return -1;
         }
+        JS_FreeValue(ctx, proto1);
     }
     return TRUE;
 }
@@ -43829,7 +44602,6 @@ static JSValue js_proxy_constructor(JSContext *ctx, JSValueConst this_val,
     }
     s->target = JS_DupValue(ctx, target);
     s->handler = JS_DupValue(ctx, handler);
-    s->proto = JS_NULL;
     s->is_func = JS_IsFunction(ctx, target);
     s->is_revoked = FALSE;
     JS_SetOpaque(obj, s);
@@ -45414,10 +46186,10 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
 static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
 {
-    JSValue result_promise, resolving_funcs[2], iter, item, next_promise, ret;
+    JSValue result_promise, resolving_funcs[2], item, next_promise, ret;
     JSValue next_method = JS_UNDEFINED, values = JS_UNDEFINED;
     JSValue resolve_element_env = JS_UNDEFINED, resolve_element, reject_element;
-    JSValue promise_resolve = JS_UNDEFINED;
+    JSValue promise_resolve = JS_UNDEFINED, iter = JS_UNDEFINED;
     JSValueConst then_args[2], resolve_element_data[5];
     BOOL done;
     int index, is_zero, is_promise_any = (magic == PROMISE_MAGIC_any);
@@ -45427,6 +46199,10 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
     result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
     if (JS_IsException(result_promise))
         return result_promise;
+    promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+    if (JS_IsException(promise_resolve) ||
+        check_function(ctx, promise_resolve))
+        goto fail_reject;
     iter = JS_GetIterator(ctx, argv[0], FALSE);
     if (JS_IsException(iter)) {
         JSValue error;
@@ -45454,11 +46230,6 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                                          JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
             goto fail_reject;
         
-        promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
-        if (JS_IsException(promise_resolve) ||
-            check_function(ctx, promise_resolve))
-            goto fail_reject1;
-        
         index = 0;
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
@@ -45560,8 +46331,8 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
 static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
 {
-    JSValue result_promise, resolving_funcs[2], iter, item, next_promise, ret;
-    JSValue next_method = JS_UNDEFINED;
+    JSValue result_promise, resolving_funcs[2], item, next_promise, ret;
+    JSValue next_method = JS_UNDEFINED, iter = JS_UNDEFINED;
     JSValue promise_resolve = JS_UNDEFINED;
     BOOL done;
 
@@ -45570,6 +46341,10 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
     result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
     if (JS_IsException(result_promise))
         return result_promise;
+    promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+    if (JS_IsException(promise_resolve) ||
+        check_function(ctx, promise_resolve))
+        goto fail_reject;
     iter = JS_GetIterator(ctx, argv[0], FALSE);
     if (JS_IsException(iter)) {
         JSValue error;
@@ -45586,11 +46361,6 @@ static JSValue js_promise_race(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(next_method))
             goto fail_reject;
 
-        promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
-        if (JS_IsException(promise_resolve) ||
-            check_function(ctx, promise_resolve))
-            goto fail_reject1;
-
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
                access, but not on 'value' access */
@@ -49385,9 +50155,6 @@ static void JS_AddIntrinsicBasicObjects(JSContext *ctx)
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
         ctx->native_error_proto[i] = proto;
     }
-    JS_SetPropertyFunctionList(ctx, ctx->native_error_proto[JS_AGGREGATE_ERROR],
-                               js_aggregate_error_proto_funcs,
-                               countof(js_aggregate_error_proto_funcs));
 
     /* the array prototype is an array */
     ctx->class_proto[JS_CLASS_ARRAY] =
@@ -49621,6 +50388,7 @@ static JSValue js_array_buffer_constructor3(JSContext *ctx,
                                             JSFreeArrayBufferDataFunc *free_func,
                                             void *opaque, BOOL alloc_flag)
 {
+    JSRuntime *rt = ctx->rt;
     JSValue obj;
     JSArrayBuffer *abuf = NULL;
 
@@ -49637,11 +50405,24 @@ static JSValue js_array_buffer_constructor3(JSContext *ctx,
         goto fail;
     abuf->byte_length = len;
     if (alloc_flag) {
-        /* the allocation must be done after the object creation */
-        abuf->data = js_mallocz(ctx, max_int(len, 1));
-        if (!abuf->data)
-            goto fail;
+        if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
+            rt->sab_funcs.sab_alloc) {
+            abuf->data = rt->sab_funcs.sab_alloc(rt->sab_funcs.sab_opaque,
+                                                 max_int(len, 1));
+            if (!abuf->data)
+                goto fail;
+            memset(abuf->data, 0, len);
+        } else {
+            /* the allocation must be done after the object creation */
+            abuf->data = js_mallocz(ctx, max_int(len, 1));
+            if (!abuf->data)
+                goto fail;
+        }
     } else {
+        if (class_id == JS_CLASS_SHARED_ARRAY_BUFFER &&
+            rt->sab_funcs.sab_dup) {
+            rt->sab_funcs.sab_dup(rt->sab_funcs.sab_opaque, buf);
+        }
         abuf->data = buf;
     }
     init_list_head(&abuf->array_list);
@@ -49731,8 +50512,12 @@ static void js_array_buffer_finalizer(JSRuntime *rt, JSValue val)
            array finalizers using it, so abuf->array_list is not
            necessarily empty. */
         // assert(list_empty(&abuf->array_list));
-        if (abuf->free_func)
-            abuf->free_func(rt, abuf->opaque, abuf->data);
+        if (abuf->shared && rt->sab_funcs.sab_free) {
+            rt->sab_funcs.sab_free(rt->sab_funcs.sab_opaque, abuf->data);
+        } else {
+            if (abuf->free_func)
+                abuf->free_func(rt, abuf->opaque, abuf->data);
+        }
         js_free_rt(rt, abuf);
     }
 }
@@ -50208,11 +50993,6 @@ static JSValue js_typed_array___getLength(JSContext *ctx,
 }
 #endif
 
-static JSValue js_typed_array_constructor(JSContext *ctx,
-                                          JSValueConst this_val,
-                                          int argc, JSValueConst *argv,
-                                          int classid);
-
 static JSValue js_typed_array_create(JSContext *ctx, JSValueConst ctor,
                                      int argc, JSValueConst *argv)
 {
@@ -51967,9 +52747,10 @@ typedef enum AtomicsOpEnum {
 } AtomicsOpEnum;
 
 static void *js_atomics_get_ptr(JSContext *ctx,
+                                JSArrayBuffer **pabuf,
                                 int *psize_log2, JSClassID *pclass_id,
                                 JSValueConst obj, JSValueConst idx_val,
-                                BOOL is_waitable)
+                                int is_waitable)
 {
     JSObject *p;
     JSTypedArray *ta;
@@ -52004,18 +52785,27 @@ static void *js_atomics_get_ptr(JSContext *ctx,
     ta = p->u.typed_array;
     abuf = ta->buffer->u.array_buffer;
     if (!abuf->shared) {
-        JS_ThrowTypeError(ctx, "not a SharedArrayBuffer TypedArray");
-        return NULL;
+        if (is_waitable == 2) {
+            JS_ThrowTypeError(ctx, "not a SharedArrayBuffer TypedArray");
+            return NULL;
+        }
+        if (abuf->detached) {
+            JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+            return NULL;
+        }
     }
     if (JS_ToIndex(ctx, &idx, idx_val)) {
         return NULL;
     }
+    /* if the array buffer is detached, p->u.array.count = 0 */
     if (idx >= p->u.array.count) {
         JS_ThrowRangeError(ctx, "out-of-bound access");
         return NULL;
     }
     size_log2 = typed_array_size_log2(p->class_id);
     ptr = p->u.array.u.uint8_ptr + ((uintptr_t)idx << size_log2);
+    if (pabuf)
+        *pabuf = abuf;
     if (psize_log2)
         *psize_log2 = size_log2;
     if (pclass_id)
@@ -52036,17 +52826,18 @@ static JSValue js_atomics_op(JSContext *ctx,
     void *ptr;
     JSValue ret;
     JSClassID class_id;
+    JSArrayBuffer *abuf;
 
-    ptr = js_atomics_get_ptr(ctx, &size_log2, &class_id,
-                             argv[0], argv[1], FALSE);
+    ptr = js_atomics_get_ptr(ctx, &abuf, &size_log2, &class_id,
+                             argv[0], argv[1], 0);
     if (!ptr)
         return JS_EXCEPTION;
     rep_val = 0;
     if (op == ATOMICS_OP_LOAD) {
         v = 0;
-    } else
+    } else {
 #ifdef CONFIG_BIGNUM
-   if (size_log2 == 3) {
+        if (size_log2 == 3) {
             int64_t v64;
             if (JS_ToBigInt64(ctx, &v64, argv[2]))
                 return JS_EXCEPTION;
@@ -52056,19 +52847,23 @@ static JSValue js_atomics_op(JSContext *ctx,
                     return JS_EXCEPTION;
                 rep_val = v64;
             }
-   } else
+        } else
 #endif
-   {
-       uint32_t v32;
-       if (JS_ToUint32(ctx, &v32, argv[2]))
-           return JS_EXCEPTION;
-       v = v32;
-       if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
-           if (JS_ToUint32(ctx, &v32, argv[3]))
-               return JS_EXCEPTION;
-           rep_val = v32;
-       }
+        {
+                uint32_t v32;
+                if (JS_ToUint32(ctx, &v32, argv[2]))
+                    return JS_EXCEPTION;
+                v = v32;
+                if (op == ATOMICS_OP_COMPARE_EXCHANGE) {
+                    if (JS_ToUint32(ctx, &v32, argv[3]))
+                        return JS_EXCEPTION;
+                    rep_val = v32;
+                }
+        }
+        if (abuf->detached)
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
    }
+
    switch(op | (size_log2 << 3)) {
             
 #ifdef CONFIG_BIGNUM
@@ -52195,8 +52990,10 @@ static JSValue js_atomics_store(JSContext *ctx,
     int size_log2;
     void *ptr;
     JSValue ret;
+    JSArrayBuffer *abuf;
 
-    ptr = js_atomics_get_ptr(ctx, &size_log2, NULL, argv[0], argv[1], FALSE);
+    ptr = js_atomics_get_ptr(ctx, &abuf, &size_log2, NULL,
+                             argv[0], argv[1], 0);
     if (!ptr)
         return JS_EXCEPTION;
 #ifdef CONFIG_BIGNUM
@@ -52209,6 +53006,8 @@ static JSValue js_atomics_store(JSContext *ctx,
             JS_FreeValue(ctx, ret);
             return JS_EXCEPTION;
         }
+        if (abuf->detached)
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
         atomic_store((_Atomic(uint64_t) *)ptr, v64);
     } else
 #endif
@@ -52222,6 +53021,8 @@ static JSValue js_atomics_store(JSContext *ctx,
             JS_FreeValue(ctx, ret);
             return JS_EXCEPTION;
         }
+        if (abuf->detached)
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
         switch(size_log2) {
         case 0:
             atomic_store((_Atomic(uint8_t) *)ptr, v);
@@ -52278,7 +53079,8 @@ static JSValue js_atomics_wait(JSContext *ctx,
     int ret, size_log2, res;
     double d;
 
-    ptr = js_atomics_get_ptr(ctx, &size_log2, NULL, argv[0], argv[1], TRUE);
+    ptr = js_atomics_get_ptr(ctx, NULL, &size_log2, NULL,
+                             argv[0], argv[1], 2);
     if (!ptr)
         return JS_EXCEPTION;
 #ifdef CONFIG_BIGNUM
@@ -52357,8 +53159,9 @@ static JSValue js_atomics_notify(JSContext *ctx,
     int32_t count, n;
     void *ptr;
     JSAtomicsWaiter *waiter;
+    JSArrayBuffer *abuf;
 
-    ptr = js_atomics_get_ptr(ctx, NULL, NULL, argv[0], argv[1], TRUE);
+    ptr = js_atomics_get_ptr(ctx, &abuf, NULL, NULL, argv[0], argv[1], 1);
     if (!ptr)
         return JS_EXCEPTION;
 
@@ -52368,9 +53171,11 @@ static JSValue js_atomics_notify(JSContext *ctx,
         if (JS_ToInt32Clamp(ctx, &count, argv[2], 0, INT32_MAX, 0))
             return JS_EXCEPTION;
     }
+    if (abuf->detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
 
     n = 0;
-    if (count > 0) {
+    if (abuf->shared && count > 0) {
         pthread_mutex_lock(&js_atomics_mutex);
         init_list_head(&waiter_list);
         list_for_each_safe(el, el1, &js_atomics_waiter_list) {
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index f6bfdb022e..db293728ec 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -498,7 +498,7 @@ int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
 
 static js_force_inline JSValue JS_NewBool(JSContext *ctx, JS_BOOL val)
 {
-    return JS_MKVAL(JS_TAG_BOOL, val);
+    return JS_MKVAL(JS_TAG_BOOL, (val != 0));
 }
 
 static js_force_inline JSValue JS_NewInt32(JSContext *ctx, int32_t val)
@@ -746,7 +746,7 @@ int JS_IsExtensible(JSContext *ctx, JSValueConst obj);
 int JS_PreventExtensions(JSContext *ctx, JSValueConst obj);
 int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags);
 int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val);
-JSValueConst JS_GetPrototype(JSContext *ctx, JSValueConst val);
+JSValue JS_GetPrototype(JSContext *ctx, JSValueConst val);
 
 #define JS_GPN_STRING_MASK  (1 << 0)
 #define JS_GPN_SYMBOL_MASK  (1 << 1)
@@ -796,6 +796,9 @@ void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id);
 /* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
                      const char *filename);
+#define JS_PARSE_JSON_EXT (1 << 0) /* allow extended JSON */
+JSValue JS_ParseJSON2(JSContext *ctx, const char *buf, size_t buf_len,
+                      const char *filename, int flags);
 JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
                          JSValueConst replacer, JSValueConst space0);
 
@@ -810,6 +813,14 @@ JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
                                size_t *pbyte_offset,
                                size_t *pbyte_length,
                                size_t *pbytes_per_element);
+typedef struct {
+    void *(*sab_alloc)(void *opaque, size_t size);
+    void (*sab_free)(void *opaque, void *ptr);
+    void (*sab_dup)(void *opaque, void *ptr);
+    void *sab_opaque;
+} JSSharedArrayBufferFunctions;
+void JS_SetSharedArrayBufferFunctions(JSRuntime *rt,
+                                      const JSSharedArrayBufferFunctions *sf);
 
 JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
 
@@ -853,14 +864,24 @@ JS_BOOL JS_IsJobPending(JSRuntime *rt);
 int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx);
 
 /* Object Writer/Reader (currently only used to handle precompiled code) */
-#define JS_WRITE_OBJ_BYTECODE (1 << 0) /* allow function/module */
-#define JS_WRITE_OBJ_BSWAP    (1 << 1) /* byte swapped output */
+#define JS_WRITE_OBJ_BYTECODE  (1 << 0) /* allow function/module */
+#define JS_WRITE_OBJ_BSWAP     (1 << 1) /* byte swapped output */
+#define JS_WRITE_OBJ_SAB       (1 << 2) /* allow SharedArrayBuffer */
+#define JS_WRITE_OBJ_REFERENCE (1 << 3) /* allow object references to
+                                           encode arbitrary object
+                                           graph */
 uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
                         int flags);
+uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
+                         int flags, uint8_t ***psab_tab, size_t *psab_tab_len);
+
 #define JS_READ_OBJ_BYTECODE  (1 << 0) /* allow function/module */
 #define JS_READ_OBJ_ROM_DATA  (1 << 1) /* avoid duplicating 'buf' data */
+#define JS_READ_OBJ_SAB       (1 << 2) /* allow SharedArrayBuffer */
+#define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */
 JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                       int flags);
+
 /* load the dependencies of the module 'obj'. Useful when JS_ReadObject()
    returns a module. */
 int JS_ResolveModule(JSContext *ctx, JSValueConst obj);

From 3be9da47cdf69da28c238aff267410d150ff6a8f Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 5 Jul 2020 14:36:03 +0300
Subject: [PATCH 063/185] Link against threads library

---
 quickjs/CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index e794a03ef5..4862129b27 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -14,6 +14,7 @@ add_library(quickjs-dumpleaks ${quickjs_src})
 target_compile_definitions(quickjs-dumpleaks PRIVATE ${quickjs_def} DUMP_LEAKS=1)
 
 if(UNIX)
-  target_link_libraries(quickjs ${CMAKE_DL_LIBS} m )
-  target_link_libraries(quickjs-dumpleaks ${CMAKE_DL_LIBS} m )
+  find_package(Threads)
+  target_link_libraries(quickjs ${CMAKE_DL_LIBS} m Threads::Threads)
+  target_link_libraries(quickjs-dumpleaks ${CMAKE_DL_LIBS} m Threads::Threads)
 endif()

From 21c19e85817877480635186d102a9501f6869c12 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 5 Jul 2020 14:36:48 +0300
Subject: [PATCH 064/185] Add js_std_init_handlers

---
 qjs.cpp        | 2 +-
 test/class.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/qjs.cpp b/qjs.cpp
index a9718a8091..9fec3e2c08 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -15,7 +15,7 @@ int main(int argc, char ** argv)
     Context context(runtime);
     ctx = context.ctx;
 
-
+    js_std_init_handlers(rt);
     /* loader for ES6 modules */
     JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
     js_std_add_helpers(ctx, argc - 1, argv + 1);
diff --git a/test/class.cpp b/test/class.cpp
index 97fe942f72..7f460ae670 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -93,7 +93,7 @@ int main()
     {
         qjs_glue(context.addModule("test"));
 
-
+        js_std_init_handlers(rt);
         /* loader for ES6 modules */
         JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
         js_std_add_helpers(ctx, 0, nullptr);

From 00532d9358a707c6e2cd7806d849b3d05ef639f2 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 5 Jul 2020 14:40:03 +0300
Subject: [PATCH 065/185] Remove extern C

---
 quickjspp.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 3e1cca755a..959c8219dc 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1,9 +1,7 @@
 #pragma once
 
-extern "C" {
 #include "quickjs/quickjs.h"
 #include "quickjs/quickjs-libc.h"
-}
 
 #include <vector>
 #include <string_view>

From ade8a2f918714c115ab777f75d354b1ca01b319d Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 17 Jul 2020 12:55:44 +0300
Subject: [PATCH 066/185] fix building without RTTI

---
 quickjspp.hpp | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 959c8219dc..0f1233ea1d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -459,9 +459,13 @@ struct js_traits<ctor_wrapper<T, Args...>>
 
             if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
             {
+#if defined(__cpp_rtti)
+                // automatically register class on first use (no prototype)
                 js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
-                //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
-                //return JS_EXCEPTION;
+#else
+                JS_ThrowTypeError(ctx, "quickjspp ctor_wrapper<T>::wrap: Class is not registered");
+                return JS_EXCEPTION;
+#endif
             }
 
             auto proto = JS_GetPropertyStr(ctx, this_value, "prototype");
@@ -543,9 +547,13 @@ struct js_traits<std::shared_ptr<T>>
     {
         if(QJSClassId == 0) // not registered
         {
+#if defined(__cpp_rtti)
+            // automatically register class on first use (no prototype)
             register_class(ctx, typeid(T).name());
-            //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
-            //return JS_EXCEPTION;
+#else
+            JS_ThrowTypeError(ctx, "quickjspp std::shared_ptr<T>::wrap: Class is not registered");
+            return JS_EXCEPTION;
+#endif
         }
         auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
         if(JS_IsException(jsobj))
@@ -580,9 +588,12 @@ struct js_traits<T *>
     {
         if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
         {
+#if defined(__cpp_rtti)
             js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
-            //JS_ThrowTypeError(ctx, "quickjspp: Class %s is not registered", typeid(T).name());
-            //return JS_EXCEPTION;
+#else
+            JS_ThrowTypeError(ctx, "quickjspp js_traits<T *>::wrap: Class is not registered");
+            return JS_EXCEPTION;
+#endif
         }
         auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
         if(JS_IsException(jsobj))

From db6d0b7db57a89625841dff614cad2df7166beea Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 17 Jul 2020 13:43:40 +0300
Subject: [PATCH 067/185] remove allocator, simplify code

---
 quickjspp.hpp | 81 +++++++--------------------------------------------
 1 file changed, 11 insertions(+), 70 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 0f1233ea1d..c52140fdc4 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -16,43 +16,7 @@
 
 namespace qjs {
 
-/** A custom allocator that uses js_malloc_rt and js_free_rt
- */
-template <typename T>
-struct allocator
-{
-    JSRuntime * rt;
-    using value_type = T;
-    using propagate_on_container_move_assignment = std::true_type;
-    using propagate_on_container_copy_assignment = std::true_type;
-
-    constexpr allocator(JSRuntime * rt) noexcept : rt{rt}
-    {}
-
-    allocator(JSContext * ctx) noexcept : rt{JS_GetRuntime(ctx)}
-    {}
-
-    template <class U>
-    constexpr allocator(const allocator<U>& other) noexcept : rt{other.rt}
-    {}
-
-    [[nodiscard]] T * allocate(std::size_t n)
-    {
-        if(auto p = static_cast<T *>(js_malloc_rt(rt, n * sizeof(T)))) return p;
-        throw std::bad_alloc();
-    }
-
-    void deallocate(T * p, std::size_t) noexcept
-    { js_free_rt(rt, p); }
-
-    template <class U>
-    bool operator ==(const allocator<U>& other) const
-    { return rt == other.rt; }
 
-    template <class U>
-    bool operator !=(const allocator<U>& other) const
-    { return rt != other.rt; }
-};
 /** Exception type.
  * Indicates that exception has occured in JS context.
  */
@@ -455,8 +419,6 @@ struct js_traits<ctor_wrapper<T, Args...>>
         return JS_NewCFunction2(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                         JSValueConst * argv) noexcept -> JSValue {
 
-            std::shared_ptr<T> ptr =  std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
-
             if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
             {
 #if defined(__cpp_rtti)
@@ -476,13 +438,8 @@ struct js_traits<ctor_wrapper<T, Args...>>
             if (JS_IsException(jsobj))
                 return jsobj;
 
-            //auto pptr = new std::shared_ptr<T>(std::move(ptr));
-            auto alloc = allocator<std::shared_ptr<T>>{ctx};
-            using atraits = std::allocator_traits<decltype(alloc)>;
-            auto pptr = atraits::allocate(alloc, 1);
-            atraits::construct(alloc, pptr, std::move(ptr));
-
-            JS_SetOpaque(jsobj, pptr);
+            std::shared_ptr<T> ptr =  std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
+            JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
             return jsobj;
 
             // return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
@@ -522,12 +479,7 @@ struct js_traits<std::shared_ptr<T>>
                     // destructor
                     [](JSRuntime * rt, JSValue obj) noexcept {
                         auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
-                        assert(pptr);
-                        //delete pptr;
-                        auto alloc = allocator<std::shared_ptr<T>>{rt};
-                        using atraits = std::allocator_traits<decltype(alloc)>;
-                        atraits::destroy(alloc, pptr);
-                        atraits::deallocate(alloc, pptr, 1);
+                        delete pptr;
                     }
             };
             int e = JS_NewClass(rt, QJSClassId, &def);
@@ -557,15 +509,9 @@ struct js_traits<std::shared_ptr<T>>
         }
         auto jsobj = JS_NewObjectClass(ctx, QJSClassId);
         if(JS_IsException(jsobj))
-        {
             return jsobj;
-        }
-        //auto pptr = new std::shared_ptr<T>(std::move(ptr));
-        auto alloc = allocator<std::shared_ptr<T>>{ctx};
-        using atraits = std::allocator_traits<decltype(alloc)>;
-        auto pptr = atraits::allocate(alloc, 1);
-        atraits::construct(alloc, pptr, std::move(ptr));
 
+        auto pptr = new std::shared_ptr<T>(std::move(ptr));
         JS_SetOpaque(jsobj, pptr);
         return jsobj;
     }
@@ -597,15 +543,10 @@ struct js_traits<T *>
         }
         auto jsobj = JS_NewObjectClass(ctx, js_traits<std::shared_ptr<T>>::QJSClassId);
         if(JS_IsException(jsobj))
-        {
             return jsobj;
-        }
-        //auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
-        auto alloc = allocator<std::shared_ptr<T>>{ctx};
-        using atraits = std::allocator_traits<decltype(alloc)>;
-        auto pptr = atraits::allocate(alloc, 1);
-        atraits::construct(alloc, pptr, ptr, [](T *) {}); // shared_ptr with empty deleter
 
+        // shared_ptr with empty deleter since we don't own T*
+        auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
         JS_SetOpaque(jsobj, pptr);
         return jsobj;
     }
@@ -994,9 +935,9 @@ class Context
         const char * name;
 
         using nvp = std::pair<const char *, Value>;
-        std::vector<nvp, allocator<nvp>> exports;
+        std::vector<nvp> exports;
     public:
-        Module(JSContext * ctx, const char * name) : ctx(ctx), name(name), exports(JS_GetRuntime(ctx))
+        Module(JSContext * ctx, const char * name) : ctx(ctx), name(name)
         {
             m = JS_NewCModule(ctx, name, [](JSContext * ctx, JSModuleDef * m) noexcept {
                 auto& context = Context::get(ctx);
@@ -1157,7 +1098,7 @@ class Context
 
     };
 
-    std::vector<Module, allocator<Module>> modules;
+    std::vector<Module> modules;
 private:
     void init()
     {
@@ -1169,7 +1110,7 @@ class Context
     Context(Runtime& rt) : Context(rt.rt)
     {}
 
-    Context(JSRuntime * rt) : modules{rt}
+    Context(JSRuntime * rt)
     {
         ctx = JS_NewContext(rt);
         if(!ctx)
@@ -1177,7 +1118,7 @@ class Context
         init();
     }
 
-    Context(JSContext * ctx) : ctx{ctx}, modules{ctx}
+    Context(JSContext * ctx) : ctx{ctx}
     {
         init();
     }

From 5b8cd65e7b0cf5b8566b5616e110aa57a8a05334 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 28 Jul 2020 15:23:57 +0300
Subject: [PATCH 068/185] function-unwrap now returns a lambda (#14)

---
 quickjspp.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index c52140fdc4..fae6a62014 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1214,14 +1214,14 @@ struct js_traits<Value>
     }
 };
 
-/** Convert to/from std::function
+/** Convert to/from std::function. Actually accepts/returns callable object that is compatible with function<R (Args...)>.
  * @tparam R return type
  * @tparam Args argument types
  */
 template <typename R, typename... Args>
 struct js_traits<std::function<R(Args...)>>
 {
-    static std::function<R(Args...)> unwrap(JSContext * ctx, JSValueConst fun_obj)
+    static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
     {
         return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
             const int argc = sizeof...(Args);

From fdf12ba8a0bea5d98eb0b823dff0c066b97761ea Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 28 Jul 2020 15:24:16 +0300
Subject: [PATCH 069/185] subtle change in as<T>() return type

---
 quickjspp.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index fae6a62014..cf0a6a5bc3 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -805,11 +805,14 @@ class Value
 
     bool isError() const { return JS_IsError(ctx, v); }
 
-    /** Conversion helper function. Both value.as<T>() and static_cast<T>(value) are supported */
+    /** Conversion helper function: value.as<T>()
+     * @tparam T type to convert to
+     * @return type returned by js_traits<std::decay_t<T>>::unwrap that should be implicitly convertible to T
+     * */
     template <typename T>
-    T as() const { return js_traits<std::decay_t<T>>::unwrap(ctx, v); }
+    auto as() const { return js_traits<std::decay_t<T>>::unwrap(ctx, v); }
 
-    /** Explicit conversion to any type */
+    /** Explicit conversion: static_cast<T>(value) or (T)value */
     template <typename T>
     explicit operator T() const { return as<T>(); }
 

From 45ac3e1fa0a5d5e73c5a55ff42889c03bb6f85ef Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 28 Jul 2020 15:26:47 +0300
Subject: [PATCH 070/185] fix exception handling in vector-wrap

---
 quickjspp.hpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index cf0a6a5bc3..d95e0fa963 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1264,20 +1264,17 @@ struct js_traits<std::vector<T>>
 {
     static JSValue wrap(JSContext * ctx, const std::vector<T>& arr) noexcept
     {
-        auto jsarray = Value{ctx, JS_NewArray(ctx)};
-        if(JS_IsException(jsarray.v))
-            return jsarray.v;
-
         try
         {
+            auto jsarray = Value{ctx, JS_NewArray(ctx)};
             for(uint32_t i = 0; i < (uint32_t) arr.size(); i++)
                 jsarray[i] = arr[i];
+            return jsarray.release();
         }
         catch(exception)
         {
             return JS_EXCEPTION;
         }
-        return std::move(jsarray);
     }
 
     static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)

From ad71664bd3dca00435f60e51524b01773f9e78ff Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 28 Jul 2020 15:36:42 +0300
Subject: [PATCH 071/185] compile-time error if trying to convert to non-class
 pointer

---
 quickjspp.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d95e0fa963..e5cfa35f05 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -526,9 +526,11 @@ struct js_traits<std::shared_ptr<T>>
     }
 };
 
-// T * - non-owning pointer
+/** Conversions for non-owning pointers to class T.
+ * @tparam T class type
+ */
 template <class T>
-struct js_traits<T *>
+struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
 {
     static JSValue wrap(JSContext * ctx, T * ptr)
     {

From 23fd05705be9e885c3934c835f742dd42b729dfb Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 27 Sep 2020 15:10:17 +0300
Subject: [PATCH 072/185] add property() for getters/setters (#16)

---
 quickjspp.hpp  | 84 ++++++++++++++++++++++++++++++++++----------------
 test/class.cpp | 11 +++++++
 2 files changed, 68 insertions(+), 27 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index e5cfa35f05..392db85d0e 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -370,11 +370,11 @@ struct js_traits<fwrapper<F, PassThis>>
     }
 };
 
-/** Conversion to JSValue for class member function in fwrapper. */
-template <typename R, class T, typename... Args, R (T::*F)(Args...)>
-struct js_traits<fwrapper<F>>
+/** Conversion to JSValue for class member function in fwrapper. PassThis is ignored and treated as true */
+template <typename R, class T, typename... Args, R (T::*F)(Args...), bool PassThis/*=ignored*/>
+struct js_traits<fwrapper<F, PassThis>>
 {
-    static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
+    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
@@ -384,11 +384,11 @@ struct js_traits<fwrapper<F>>
     }
 };
 
-/** Conversion to JSValue for const class member function in fwrapper. */
-template <typename R, class T, typename... Args, R (T::*F)(Args...) const>
-struct js_traits<fwrapper<F>>
+/** Conversion to JSValue for const class member function in fwrapper. PassThis is ignored and treated as true */
+template <typename R, class T, typename... Args, R (T::*F)(Args...) const, bool PassThis/*=ignored*/>
+struct js_traits<fwrapper<F, PassThis>>
 {
-    static JSValue wrap(JSContext * ctx, fwrapper<F> fw) noexcept
+    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
@@ -855,36 +855,56 @@ class Value
         return *this;
     }
 
-    // add<&T::member>("member");
-    template <auto M>
-    std::enable_if_t<std::is_member_object_pointer_v<decltype(M)>, Value&>
-    add(const char * name)
+    // add_getter_setter<&T::get_member, &T::set_member>("member");
+    template <auto FGet, auto FSet>
+    Value& add_getter_setter(const char * name)
     {
         auto prop = JS_NewAtom(ctx, name);
-        using fgetter = fwrapper<detail::get_set<M>::get, true>;
-        int ret;
-        if constexpr (detail::get_set<M>::is_const::value)
-        {
-            ret = JS_DefinePropertyGetSet(ctx, v, prop,
+        using fgetter = fwrapper<FGet, true>;
+        using fsetter = fwrapper<FSet, true>;
+        int ret = JS_DefinePropertyGetSet(ctx, v, prop,
+                                      js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                      js_traits<fsetter>::wrap(ctx, fsetter{name}),
+                                      JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE
+        );
+        JS_FreeAtom(ctx, prop);
+        if(ret < 0)
+            throw exception{};
+        return *this;
+    }
+
+    // add_getter<&T::get_member>("member");
+    template <auto FGet>
+    Value& add_getter(const char * name)
+    {
+        auto prop = JS_NewAtom(ctx, name);
+        using fgetter = fwrapper<FGet, true>;
+        int ret = JS_DefinePropertyGetSet(ctx, v, prop,
                                           js_traits<fgetter>::wrap(ctx, fgetter{name}),
                                           JS_UNDEFINED,
                                           JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE
-            );
-        } else
-        {
-            using fsetter = fwrapper<detail::get_set<M>::set, true>;
-            ret = JS_DefinePropertyGetSet(ctx, v, prop,
-                                          js_traits<fgetter>::wrap(ctx, fgetter{name}),
-                                          js_traits<fsetter>::wrap(ctx, fsetter{name}),
-                                          JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE
-            );
-        }
+        );
         JS_FreeAtom(ctx, prop);
         if(ret < 0)
             throw exception{};
         return *this;
     }
 
+    // add<&T::member>("member");
+    template <auto M>
+    std::enable_if_t<std::is_member_object_pointer_v<decltype(M)>, Value&>
+    add(const char * name)
+    {
+        if constexpr (detail::get_set<M>::is_const::value)
+        {
+            return add_getter<detail::get_set<M>::get>(name);
+        }
+        else
+        {
+            return add_getter_setter<detail::get_set<M>::get, detail::get_set<M>::set>(name);
+        }
+    }
+
     std::string toJSON(const Value& replacer = Value{nullptr, JS_UNDEFINED}, const Value& space = Value{nullptr, JS_UNDEFINED})
     {
         assert(ctx);
@@ -1056,6 +1076,16 @@ class Context
                 return *this;
             }
 
+            template <auto FGet, auto FSet = nullptr>
+            class_registrar& property(const char * name)
+            {
+                if constexpr (FSet == nullptr)
+                    prototype.add_getter<FGet>(name);
+                else
+                    prototype.add_getter_setter<FGet, FSet>(name);
+                return *this;
+            }
+
             /** Add class constructor
              * @tparam Args contructor arguments
              * @param name constructor name (if not specified class name will be used)
diff --git a/test/class.cpp b/test/class.cpp
index 7f460ae670..d81adf3d86 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -43,6 +43,10 @@ class test : public base_test
     const std::string& fs(TYPES) { i++; return s; }
     void f(TYPES) { i++; }
 
+    double get_d()  { i++; return d; }
+    double set_d(double new_d) { i++; d = new_d; return d; }
+
+
     static void fstatic(TYPES) {}
 };
 
@@ -74,6 +78,8 @@ void qjs_glue(qjs::Context::Module& m) {
             .fun<&::test::d>("d") // double
             .fun<&::test::spt>("spt") // ::std::shared_ptr<test>
             .fun<&::test::s>("s") // ::std::string
+            .property<&test::get_d, &test::set_d>("property_rw")
+            .property<&test::get_d>("property_ro")
             ;
 } // qjs_glue
 
@@ -144,6 +150,11 @@ int main()
                     context.eval("t").as<std::shared_ptr<test>>(), "test string", std::string{"test"});
         assert(zzz == 19);
 
+        zzz = (int)context.eval("q.property_rw = q.property_ro - q.property_rw + 1;"
+                               "assert(q.property_ro === 1);"
+                               "q.i"
+                               );
+        assert(zzz == 23);
     }
     catch(exception)
     {

From a45b716ba4144ab7cf464cdf7ad0f138cac760c4 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 27 Sep 2020 15:11:48 +0300
Subject: [PATCH 073/185] update quickjs to 2020-09-06

---
 quickjs/VERSION          |   2 +-
 quickjs/cutils.c         |  21 +-
 quickjs/libregexp.c      |  20 +-
 quickjs/libregexp.h      |   1 +
 quickjs/libunicode.c     |  26 +-
 quickjs/quickjs-libc.c   | 100 +++--
 quickjs/quickjs-libc.h   |   3 +-
 quickjs/quickjs-opcode.h |   3 +-
 quickjs/quickjs.c        | 884 +++++++++++++++++++++++++--------------
 quickjs/quickjs.h        |  10 +
 10 files changed, 702 insertions(+), 368 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index e970cf624e..c67790a714 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-07-05
+2020-09-06
diff --git a/quickjs/cutils.c b/quickjs/cutils.c
index 64a32d362f..a02fb76886 100644
--- a/quickjs/cutils.c
+++ b/quickjs/cutils.c
@@ -258,19 +258,30 @@ int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
         return c;
     }
     switch(c) {
-    case 0xc0 ... 0xdf:
+    case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+    case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+    case 0xc8: case 0xc9: case 0xca: case 0xcb:
+    case 0xcc: case 0xcd: case 0xce: case 0xcf:
+    case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+    case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+    case 0xd8: case 0xd9: case 0xda: case 0xdb:
+    case 0xdc: case 0xdd: case 0xde: case 0xdf:
         l = 1;
         break;
-    case 0xe0 ... 0xef:
+    case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+    case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+    case 0xe8: case 0xe9: case 0xea: case 0xeb:
+    case 0xec: case 0xed: case 0xee: case 0xef:
         l = 2;
         break;
-    case 0xf0 ... 0xf7:
+    case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+    case 0xf4: case 0xf5: case 0xf6: case 0xf7:
         l = 3;
         break;
-    case 0xf8 ... 0xfb:
+    case 0xf8: case 0xf9: case 0xfa: case 0xfb:
         l = 4;
         break;
-    case 0xfc ... 0xfd:
+    case 0xfc: case 0xfd:
         l = 5;
         break;
     default:
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index b455bf246f..bbb5e9d701 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -569,7 +569,8 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
             }
         }
         break;
-    case '0' ... '7':
+    case '0': case '1': case '2': case '3':
+    case '4': case '5': case '6': case '7':
         c -= '0';
         if (allow_utf16 == 2) {
             /* only accept \0 not followed by digit */
@@ -1410,7 +1411,9 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 }
             }
             goto normal_char;
-        case '1' ... '9':
+        case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8':
+        case '9': 
             {
                 const uint8_t *q = ++p;
                 
@@ -1434,7 +1437,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                         }
                         goto normal_char;
                     }
-                    return re_parse_error(s, "back reference out of range in reguar expression");
+                    return re_parse_error(s, "back reference out of range in regular expression");
                 }
             emit_back_reference:
                 last_atom_start = s->byte_code.size;
@@ -2533,6 +2536,17 @@ int lre_get_flags(const uint8_t *bc_buf)
     return bc_buf[RE_HEADER_FLAGS];
 }
 
+/* Return NULL if no group names. Otherwise, return a pointer to
+   'capture_count - 1' zero terminated UTF-8 strings. */
+const char *lre_get_groupnames(const uint8_t *bc_buf)
+{
+    uint32_t re_bytecode_len;
+    if ((lre_get_flags(bc_buf) & LRE_FLAG_NAMED_GROUPS) == 0)
+        return NULL;
+    re_bytecode_len = get_u32(bc_buf + 3);
+    return (const char *)(bc_buf + 7 + re_bytecode_len);
+}
+
 #ifdef TEST
 
 BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size)
diff --git a/quickjs/libregexp.h b/quickjs/libregexp.h
index cd0b24f2d7..9aedb7e937 100644
--- a/quickjs/libregexp.h
+++ b/quickjs/libregexp.h
@@ -44,6 +44,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
                      void *opaque);
 int lre_get_capture_count(const uint8_t *bc_buf);
 int lre_get_flags(const uint8_t *bc_buf);
+const char *lre_get_groupnames(const uint8_t *bc_buf);
 int lre_exec(uint8_t **capture,
              const uint8_t *bc_buf, const uint8_t *cbuf, int cindex, int clen,
              int cbuf_type, void *opaque);
diff --git a/quickjs/libunicode.c b/quickjs/libunicode.c
index 96ff002072..63c12a0771 100644
--- a/quickjs/libunicode.c
+++ b/quickjs/libunicode.c
@@ -527,7 +527,13 @@ static int unicode_decomp_entry(uint32_t *res, uint32_t c,
     } else {
         d = unicode_decomp_data + unicode_decomp_table2[idx];
         switch(type) {
-        case DECOMP_TYPE_L1 ... DECOMP_TYPE_L7:
+        case DECOMP_TYPE_L1:
+        case DECOMP_TYPE_L2:
+        case DECOMP_TYPE_L3:
+        case DECOMP_TYPE_L4:
+        case DECOMP_TYPE_L5:
+        case DECOMP_TYPE_L6:
+        case DECOMP_TYPE_L7:
             l = type - DECOMP_TYPE_L1 + 1;
             d += (c - code) * l * 2;
             for(i = 0; i < l; i++) {
@@ -535,7 +541,8 @@ static int unicode_decomp_entry(uint32_t *res, uint32_t c,
                     return 0;
             }
             return l;
-        case DECOMP_TYPE_LL1 ... DECOMP_TYPE_LL2:
+        case DECOMP_TYPE_LL1:
+        case DECOMP_TYPE_LL2:
             {
                 uint32_t k, p;
                 l = type - DECOMP_TYPE_LL1 + 1;
@@ -551,7 +558,11 @@ static int unicode_decomp_entry(uint32_t *res, uint32_t c,
                 }
             }
             return l;
-        case DECOMP_TYPE_S1 ... DECOMP_TYPE_S5:
+        case DECOMP_TYPE_S1:
+        case DECOMP_TYPE_S2:
+        case DECOMP_TYPE_S3:
+        case DECOMP_TYPE_S4:
+        case DECOMP_TYPE_S5:
             l = type - DECOMP_TYPE_S1 + 1;
             d += (c - code) * l;
             for(i = 0; i < l; i++) {
@@ -582,7 +593,14 @@ static int unicode_decomp_entry(uint32_t *res, uint32_t c,
         case DECOMP_TYPE_B18:
             l = 18;
             goto decomp_type_b;
-        case DECOMP_TYPE_B1 ... DECOMP_TYPE_B8:
+        case DECOMP_TYPE_B1:
+        case DECOMP_TYPE_B2:
+        case DECOMP_TYPE_B3:
+        case DECOMP_TYPE_B4:
+        case DECOMP_TYPE_B5:
+        case DECOMP_TYPE_B6:
+        case DECOMP_TYPE_B7:
+        case DECOMP_TYPE_B8:
             l = type - DECOMP_TYPE_B1 + 1;
         decomp_type_b:
             {
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index eda23c7899..00a7536d77 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -2993,9 +2993,8 @@ typedef struct {
 } JSWorkerData;
 
 typedef struct {
-    /* source code of the worker */
-    char *eval_buf;
-    size_t eval_buf_len;
+    char *filename; /* module filename */
+    char *basename; /* module base name */
     JSWorkerMessagePipe *recv_pipe, *send_pipe;
 } WorkerFuncArgs;
 
@@ -3005,6 +3004,7 @@ typedef struct {
 } JSSABHeader;
 
 static JSClassID js_worker_class_id;
+static JSContext *(*js_worker_new_context_func)(JSRuntime *rt);
 
 static int atomic_add_int(int *ptr, int v)
 {
@@ -3136,7 +3136,6 @@ static void *worker_func(void *opaque)
     JSRuntime *rt;
     JSThreadState *ts;
     JSContext *ctx;
-    JSValue retval;
     
     rt = JS_NewRuntime();
     if (rt == NULL) {
@@ -3145,12 +3144,16 @@ static void *worker_func(void *opaque)
     }        
     js_std_init_handlers(rt);
 
+    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
+
     /* set the pipe to communicate with the parent */
     ts = JS_GetRuntimeOpaque(rt);
     ts->recv_pipe = args->recv_pipe;
     ts->send_pipe = args->send_pipe;
     
-    ctx = JS_NewContext(rt);
+    /* function pointer to avoid linking the whole JS_NewContext() if
+       not needed */
+    ctx = js_worker_new_context_func(rt);
     if (ctx == NULL) {
         fprintf(stderr, "JS_NewContext failure");
     }
@@ -3159,18 +3162,11 @@ static void *worker_func(void *opaque)
 
     js_std_add_helpers(ctx, -1, NULL);
 
-    /* system modules */
-    js_init_module_std(ctx, "std");
-    js_init_module_os(ctx, "os");
-
-    retval = JS_Eval(ctx, args->eval_buf, args->eval_buf_len,
-                      "<worker>", JS_EVAL_TYPE_MODULE);
-    free(args->eval_buf);
-    free(args);
-
-    if (JS_IsException(retval))
+    if (!JS_RunModule(ctx, args->basename, args->filename))
         js_std_dump_error(ctx);
-    JS_FreeValue(ctx, retval);
+    free(args->filename);
+    free(args->basename);
+    free(args);
 
     js_std_loop(ctx);
 
@@ -3216,52 +3212,53 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
                               int argc, JSValueConst *argv)
 {
     JSRuntime *rt = JS_GetRuntime(ctx);
-    WorkerFuncArgs *args;
-    const char *str;
-    size_t str_len;
+    WorkerFuncArgs *args = NULL;
     pthread_t tid;
     pthread_attr_t attr;
     JSValue obj = JS_UNDEFINED;
     int ret;
+    const char *filename = NULL, *basename;
+    JSAtom basename_atom;
     
     /* XXX: in order to avoid problems with resource liberation, we
        don't support creating workers inside workers */
     if (!is_main_thread(rt))
         return JS_ThrowTypeError(ctx, "cannot create a worker inside a worker");
+
+    /* base name, assuming the calling function is a normal JS
+       function */
+    basename_atom = JS_GetScriptOrModuleName(ctx, 1);
+    if (basename_atom == JS_ATOM_NULL) {
+        return JS_ThrowTypeError(ctx, "could not determine calling script or module name");
+    }
+    basename = JS_AtomToCString(ctx, basename_atom);
+    JS_FreeAtom(ctx, basename_atom);
+    if (!basename)
+        goto fail;
     
-    /* script source */
-    
-    str = JS_ToCStringLen(ctx, &str_len, argv[0]);
-    if (!str)
-        return JS_EXCEPTION;
+    /* module name */
+    filename = JS_ToCString(ctx, argv[0]);
+    if (!filename)
+        goto fail;
 
     args = malloc(sizeof(*args));
-    if (!args) {
-        JS_ThrowOutOfMemory(ctx);
-        goto fail;
-    }
+    if (!args)
+        goto oom_fail;
     memset(args, 0, sizeof(*args));
-    args->eval_buf = malloc(str_len + 1);
-    if (!args->eval_buf) {
-        JS_ThrowOutOfMemory(ctx);
-        goto fail;
-    }
-    memcpy(args->eval_buf, str, str_len + 1);
-    args->eval_buf_len = str_len;
-    JS_FreeCString(ctx, str);
-    str = NULL;
+    args->filename = strdup(filename);
+    args->basename = strdup(basename);
 
     /* ports */
     args->recv_pipe = js_new_message_pipe();
     if (!args->recv_pipe)
-        goto fail;
+        goto oom_fail;
     args->send_pipe = js_new_message_pipe();
     if (!args->send_pipe)
-        goto fail;
+        goto oom_fail;
 
     obj = js_worker_ctor_internal(ctx, new_target,
                                   args->send_pipe, args->recv_pipe);
-    if (JS_IsUndefined(obj))
+    if (JS_IsException(obj))
         goto fail;
     
     pthread_attr_init(&attr);
@@ -3273,11 +3270,17 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
         JS_ThrowTypeError(ctx, "could not create worker");
         goto fail;
     }
+    JS_FreeCString(ctx, basename);
+    JS_FreeCString(ctx, filename);
     return obj;
+ oom_fail:
+    JS_ThrowOutOfMemory(ctx);
  fail:
-    JS_FreeCString(ctx, str);
+    JS_FreeCString(ctx, basename);
+    JS_FreeCString(ctx, filename);
     if (args) {
-        free(args->eval_buf);
+        free(args->filename);
+        free(args->basename);
         js_free_message_pipe(args->recv_pipe);
         js_free_message_pipe(args->send_pipe);
         free(args);
@@ -3417,6 +3420,13 @@ static const JSCFunctionListEntry js_worker_proto_funcs[] = {
 
 #endif /* USE_WORKER */
 
+void js_std_set_worker_new_context_func(JSContext *(*func)(JSRuntime *rt))
+{
+#ifdef USE_WORKER
+    js_worker_new_context_func = func;
+#endif
+}
+
 #if defined(_WIN32)
 #define OS_PLATFORM "win32"
 #elif defined(__APPLE__)
@@ -3668,6 +3678,12 @@ void js_std_free_handlers(JSRuntime *rt)
             free_timer(rt, th);
     }
 
+#ifdef USE_WORKER
+    /* XXX: free port_list ? */
+    js_free_message_pipe(ts->recv_pipe);
+    js_free_message_pipe(ts->send_pipe);
+#endif
+
     free(ts);
     JS_SetRuntimeOpaque(rt, NULL); /* fail safe */
 }
diff --git a/quickjs/quickjs-libc.h b/quickjs/quickjs-libc.h
index b105028992..fbbe5b0166 100644
--- a/quickjs/quickjs-libc.h
+++ b/quickjs/quickjs-libc.h
@@ -50,7 +50,8 @@ void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
 void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                       JSValueConst reason,
                                       JS_BOOL is_handled, void *opaque);
-
+void js_std_set_worker_new_context_func(JSContext *(*func)(JSRuntime *rt));
+                                        
 #ifdef __cplusplus
 } /* extern "C" { */
 #endif
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 230f6e4771..387363c370 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -359,7 +359,8 @@ DEF(          call3, 1, 1, 1, npopx)
 
 DEF(   is_undefined, 1, 1, 1, none)
 DEF(        is_null, 1, 1, 1, none)
-DEF(    is_function, 1, 1, 1, none)
+DEF(typeof_is_undefined, 1, 1, 1, none)
+DEF( typeof_is_function, 1, 1, 1, none)
 #endif
 
 #undef DEF
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 8fbb7a3938..efc1d54aad 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -825,8 +825,8 @@ typedef struct JSShapeProperty {
 } JSShapeProperty;
 
 struct JSShape {
-    uint32_t prop_hash_end[0]; /* hash table of size hash_mask + 1
-                                  before the start of the structure. */
+    /* hash table of size hash_mask + 1 before the start of the
+       structure (see prop_hash_end()). */
     JSGCObjectHeader header;
     /* true if the shape is inserted in the shape hash table. If not,
        JSShape.hash is not valid */
@@ -859,6 +859,7 @@ struct JSObject {
             uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
             uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
             uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
+            uint8_t is_HTMLDDA : 1; /* specific annex B IsHtmlDDA behavior */
             uint16_t class_id; /* see JS_CLASS_x */
         };
     };
@@ -931,7 +932,7 @@ struct JSObject {
     /* byte sizes: 40/48/72 */
 };
 enum {
-    JS_ATOM_NULL,
+    __JS_ATOM_NULL = JS_ATOM_NULL,
 #define DEF(name, str) JS_ATOM_ ## name,
 #include "quickjs-atom.h"
 #undef DEF
@@ -4198,9 +4199,14 @@ static inline JSShape *get_shape_from_alloc(void *sh_alloc, size_t hash_size)
     return (JSShape *)(void *)((uint32_t *)sh_alloc + hash_size);
 }
 
+static inline uint32_t *prop_hash_end(JSShape *sh)
+{
+    return (uint32_t *)sh;
+}
+
 static inline void *get_alloc_from_shape(JSShape *sh)
 {
-    return sh->prop_hash_end - ((intptr_t)sh->prop_hash_mask + 1);
+    return prop_hash_end(sh) - ((intptr_t)sh->prop_hash_mask + 1);
 }
 
 static inline JSShapeProperty *get_shape_prop(JSShape *sh)
@@ -4311,7 +4317,7 @@ static no_inline JSShape *js_new_shape2(JSContext *ctx, JSObject *proto,
     if (proto)
         JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, proto));
     sh->proto = proto;
-    memset(sh->prop_hash_end - hash_size, 0, sizeof(sh->prop_hash_end[0]) *
+    memset(prop_hash_end(sh) - hash_size, 0, sizeof(prop_hash_end(sh)[0]) *
            hash_size);
     sh->prop_hash_mask = hash_size - 1;
     sh->prop_size = prop_size;
@@ -4440,13 +4446,13 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
         list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
         new_hash_mask = new_hash_size - 1;
         sh->prop_hash_mask = new_hash_mask;
-        memset(sh->prop_hash_end - new_hash_size, 0,
-               sizeof(sh->prop_hash_end[0]) * new_hash_size);
+        memset(prop_hash_end(sh) - new_hash_size, 0,
+               sizeof(prop_hash_end(sh)[0]) * new_hash_size);
         for(i = 0, pr = sh->prop; i < sh->prop_count; i++, pr++) {
             if (pr->atom != JS_ATOM_NULL) {
                 h = ((uintptr_t)pr->atom & new_hash_mask);
-                pr->hash_next = sh->prop_hash_end[-h - 1];
-                sh->prop_hash_end[-h - 1] = i + 1;
+                pr->hash_next = prop_hash_end(sh)[-h - 1];
+                prop_hash_end(sh)[-h - 1] = i + 1;
             }
         }
         js_free(ctx, get_alloc_from_shape(old_sh));
@@ -4500,8 +4506,8 @@ static int compact_properties(JSContext *ctx, JSObject *p)
     memcpy(sh, old_sh, sizeof(JSShape));
     list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
     
-    memset(sh->prop_hash_end - new_hash_size, 0,
-           sizeof(sh->prop_hash_end[0]) * new_hash_size);
+    memset(prop_hash_end(sh) - new_hash_size, 0,
+           sizeof(prop_hash_end(sh)[0]) * new_hash_size);
 
     j = 0;
     old_pr = old_sh->prop;
@@ -4512,8 +4518,8 @@ static int compact_properties(JSContext *ctx, JSObject *p)
             pr->atom = old_pr->atom;
             pr->flags = old_pr->flags;
             h = ((uintptr_t)old_pr->atom & new_hash_mask);
-            pr->hash_next = sh->prop_hash_end[-h - 1];
-            sh->prop_hash_end[-h - 1] = j + 1;
+            pr->hash_next = prop_hash_end(sh)[-h - 1];
+            prop_hash_end(sh)[-h - 1] = j + 1;
             prop[j] = prop[i];
             j++;
             pr++;
@@ -4575,8 +4581,8 @@ static int add_shape_property(JSContext *ctx, JSShape **psh,
     /* add in hash table */
     hash_mask = sh->prop_hash_mask;
     h = atom & hash_mask;
-    pr->hash_next = sh->prop_hash_end[-h - 1];
-    sh->prop_hash_end[-h - 1] = sh->prop_count;
+    pr->hash_next = prop_hash_end(sh)[-h - 1];
+    prop_hash_end(sh)[-h - 1] = sh->prop_count;
     return 0;
 }
 
@@ -4693,6 +4699,7 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     p->is_constructor = 0;
     p->is_uncatchable_error = 0;
     p->tmp_mark = 0;
+    p->is_HTMLDDA = 0;
     p->first_weak_ref = NULL;
     p->u.opaque = NULL;
     p->shape = sh;
@@ -4731,7 +4738,19 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
         p->prop[0].u.value = JS_UNDEFINED;
         break;
     case JS_CLASS_ARGUMENTS:
-    case JS_CLASS_UINT8C_ARRAY ... JS_CLASS_FLOAT64_ARRAY:
+    case JS_CLASS_UINT8C_ARRAY:
+    case JS_CLASS_INT8_ARRAY:
+    case JS_CLASS_UINT8_ARRAY:
+    case JS_CLASS_INT16_ARRAY:
+    case JS_CLASS_UINT16_ARRAY:
+    case JS_CLASS_INT32_ARRAY:
+    case JS_CLASS_UINT32_ARRAY:
+#ifdef CONFIG_BIGNUM
+    case JS_CLASS_BIG_INT64_ARRAY:
+    case JS_CLASS_BIG_UINT64_ARRAY:
+#endif
+    case JS_CLASS_FLOAT32_ARRAY:
+    case JS_CLASS_FLOAT64_ARRAY:
         p->is_exotic = 1;
         p->fast_array = 1;
         p->u.array.u.ptr = NULL;
@@ -5133,7 +5152,7 @@ static force_inline JSShapeProperty *find_own_property1(JSObject *p,
     intptr_t h;
     sh = p->shape;
     h = (uintptr_t)atom & sh->prop_hash_mask;
-    h = sh->prop_hash_end[-h - 1];
+    h = prop_hash_end(sh)[-h - 1];
     prop = get_shape_prop(sh);
     while (h) {
         pr = &prop[h - 1];
@@ -5154,7 +5173,7 @@ static force_inline JSShapeProperty *find_own_property(JSProperty **ppr,
     intptr_t h;
     sh = p->shape;
     h = (uintptr_t)atom & sh->prop_hash_mask;
-    h = sh->prop_hash_end[-h - 1];
+    h = prop_hash_end(sh)[-h - 1];
     prop = get_shape_prop(sh);
     while (h) {
         pr = &prop[h - 1];
@@ -7994,7 +8013,7 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
  redo:
     sh = p->shape;
     h1 = atom & sh->prop_hash_mask;
-    h = sh->prop_hash_end[-h1 - 1];
+    h = prop_hash_end(sh)[-h1 - 1];
     prop = get_shape_prop(sh);
     lpr = NULL;
     lpr_idx = 0;   /* prevent warning */
@@ -8015,7 +8034,7 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
                 lpr = get_shape_prop(sh) + lpr_idx;
                 lpr->hash_next = pr->hash_next;
             } else {
-                sh->prop_hash_end[-h1 - 1] = pr->hash_next;
+                prop_hash_end(sh)[-h1 - 1] = pr->hash_next;
             }
             sh->deleted_prop_count++;
             /* free the entry */
@@ -8095,15 +8114,16 @@ static int call_setter(JSContext *ctx, JSObject *setter,
 }
 
 /* set the array length and remove the array elements if necessary. */
-static int set_array_length(JSContext *ctx, JSObject *p, JSProperty *prop,
-                            JSValue val, int flags)
+static int set_array_length(JSContext *ctx, JSObject *p, JSValue val, int flags)
 {
     uint32_t len, idx, cur_len;
     int i, ret;
 
+    /* Note: this call can reallocate the properties of 'p' */
     ret = JS_ToArrayLengthFree(ctx, &len, val);
     if (ret)
         return -1;
+
     if (likely(p->fast_array)) {
         uint32_t old_len = p->u.array.count;
         if (len < old_len) {
@@ -8112,11 +8132,11 @@ static int set_array_length(JSContext *ctx, JSObject *p, JSProperty *prop,
             }
             p->u.array.count = len;
         }
-        prop->u.value = JS_NewUint32(ctx, len);
+        p->prop[0].u.value = JS_NewUint32(ctx, len);
     } else {
         /* Note: length is always a uint32 because the object is an
            array */
-        JS_ToUint32(ctx, &cur_len, prop->u.value);
+        JS_ToUint32(ctx, &cur_len, p->prop[0].u.value);
         if (len < cur_len) {
             uint32_t d;
             JSShape *sh;
@@ -8366,7 +8386,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                    (JS_PROP_LENGTH | JS_PROP_WRITABLE)) {
             assert(p->class_id == JS_CLASS_ARRAY);
             assert(prop == JS_ATOM_length);
-            return set_array_length(ctx, p, pr, val, flags);
+            return set_array_length(ctx, p, val, flags);
         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
             return call_setter(ctx, pr->u.getset.setter, this_obj, val, flags);
         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
@@ -9047,7 +9067,7 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                 }
                 if (prs->flags & JS_PROP_LENGTH) {
                     if (flags & JS_PROP_HAS_VALUE) {
-                        res = set_array_length(ctx, p, pr, JS_DupValue(ctx, val),
+                        res = set_array_length(ctx, p, JS_DupValue(ctx, val),
                                                flags);
                     } else {
                         res = TRUE;
@@ -9806,6 +9826,24 @@ static JSValue JS_ToPrimitive(JSContext *ctx, JSValueConst val, int hint)
     return JS_ToPrimitiveFree(ctx, JS_DupValue(ctx, val), hint);
 }
 
+void JS_SetIsHTMLDDA(JSContext *ctx, JSValueConst obj)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
+        return;
+    p = JS_VALUE_GET_OBJ(obj);
+    p->is_HTMLDDA = TRUE;
+}
+
+static inline BOOL JS_IsHTMLDDA(JSContext *ctx, JSValueConst obj)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
+        return FALSE;
+    p = JS_VALUE_GET_OBJ(obj);
+    return p->is_HTMLDDA;
+}
+                         
 static int JS_ToBoolFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag = JS_VALUE_GET_TAG(val);
@@ -9843,6 +9881,15 @@ static int JS_ToBoolFree(JSContext *ctx, JSValue val)
             return ret;
         }
 #endif
+    case JS_TAG_OBJECT:
+        {
+            JSObject *p = JS_VALUE_GET_OBJ(val);
+            BOOL ret;
+            ret = !p->is_HTMLDDA;
+            JS_FreeValue(ctx, val);
+            return ret;
+        }
+        break;
     default:
         if (JS_TAG_IS_FLOAT64(tag)) {
             double d = JS_VALUE_GET_FLOAT64(val);
@@ -11602,7 +11649,19 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
             case JS_CLASS_ARGUMENTS:
                 JS_DumpValueShort(rt, p->u.array.u.values[i]);
                 break;
-            case JS_CLASS_UINT8C_ARRAY ... JS_CLASS_FLOAT64_ARRAY:
+            case JS_CLASS_UINT8C_ARRAY:
+            case JS_CLASS_INT8_ARRAY:
+            case JS_CLASS_UINT8_ARRAY:
+            case JS_CLASS_INT16_ARRAY:
+            case JS_CLASS_UINT16_ARRAY:
+            case JS_CLASS_INT32_ARRAY:
+            case JS_CLASS_UINT32_ARRAY:
+#ifdef CONFIG_BIGNUM
+            case JS_CLASS_BIG_INT64_ARRAY:
+            case JS_CLASS_BIG_UINT64_ARRAY:
+#endif
+            case JS_CLASS_FLOAT32_ARRAY:
+            case JS_CLASS_FLOAT64_ARRAY:
                 {
                     int size = 1 << typed_array_size_log2(p->class_id);
                     const uint8_t *b = p->u.array.u.uint8_ptr + i * size;
@@ -13668,33 +13727,8 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
         JS_FreeValue(ctx, op2);
     } else if ((tag1 <= JS_TAG_NULL || tag1 == JS_TAG_FLOAT64) &&
                (tag2 <= JS_TAG_NULL || tag2 == JS_TAG_FLOAT64)) {
-        /* can use floating point comparison */
-        double d1, d2;
-        if (tag1 == JS_TAG_FLOAT64) {
-            d1 = JS_VALUE_GET_FLOAT64(op1);
-        } else {
-            d1 = JS_VALUE_GET_INT(op1);
-        }
-        if (tag2 == JS_TAG_FLOAT64) {
-            d2 = JS_VALUE_GET_FLOAT64(op2);
-        } else {
-            d2 = JS_VALUE_GET_INT(op2);
-        }
-        switch(op) {
-        case OP_lt:
-            res = (d1 < d2); /* if NaN return false */
-            break;
-        case OP_lte:
-            res = (d1 <= d2); /* if NaN return false */
-            break;
-        case OP_gt:
-            res = (d1 > d2); /* if NaN return false */
-            break;
-        default:
-        case OP_gte:
-            res = (d1 >= d2); /* if NaN return false */
-            break;
-        }
+        /* fast path for float64/int */
+        goto float64_compare;
     } else {
         if (((tag1 == JS_TAG_BIG_INT && tag2 == JS_TAG_STRING) ||
              (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_STRING)) &&
@@ -13727,20 +13761,51 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
             }
         }
 
-        if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_DECIMAL ||
-            JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_DECIMAL) {
+        tag1 = JS_VALUE_GET_NORM_TAG(op1);
+        tag2 = JS_VALUE_GET_NORM_TAG(op2);
+
+        if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
             res = ctx->rt->bigdecimal_ops.compare(ctx, op, op1, op2);
             if (res < 0)
                 goto exception;
-        } else if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_FLOAT ||
-                   JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_FLOAT) {
+        } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
             res = ctx->rt->bigfloat_ops.compare(ctx, op, op1, op2);
             if (res < 0)
                 goto exception;
-        } else {
+        } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
             res = ctx->rt->bigint_ops.compare(ctx, op, op1, op2);
             if (res < 0)
                 goto exception;
+        } else {
+            double d1, d2;
+
+        float64_compare:
+            /* can use floating point comparison */
+            if (tag1 == JS_TAG_FLOAT64) {
+                d1 = JS_VALUE_GET_FLOAT64(op1);
+            } else {
+                d1 = JS_VALUE_GET_INT(op1);
+            }
+            if (tag2 == JS_TAG_FLOAT64) {
+                d2 = JS_VALUE_GET_FLOAT64(op2);
+            } else {
+                d2 = JS_VALUE_GET_INT(op2);
+            }
+            switch(op) {
+            case OP_lt:
+                res = (d1 < d2); /* if NaN return false */
+                break;
+            case OP_lte:
+                res = (d1 <= d2); /* if NaN return false */
+                break;
+            case OP_gt:
+                res = (d1 > d2); /* if NaN return false */
+                break;
+            default:
+            case OP_gte:
+                res = (d1 >= d2); /* if NaN return false */
+                break;
+            }
         }
     }
  done:
@@ -13895,9 +13960,17 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
         }
         goto redo;
     } else {
+        /* IsHTMLDDA object is equivalent to undefined for '==' and '!=' */
+        if ((JS_IsHTMLDDA(ctx, op1) &&
+             (tag2 == JS_TAG_NULL || tag2 == JS_TAG_UNDEFINED)) ||
+            (JS_IsHTMLDDA(ctx, op2) &&
+             (tag1 == JS_TAG_NULL || tag1 == JS_TAG_UNDEFINED))) {
+            res = TRUE;
+        } else {
+            res = FALSE;
+        }
         JS_FreeValue(ctx, op1);
         JS_FreeValue(ctx, op2);
-        res = FALSE;
     }
  done:
     sp[-2] = JS_NewBool(ctx, res ^ is_neq);
@@ -14348,9 +14421,17 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
         }
         goto redo;
     } else {
+        /* IsHTMLDDA object is equivalent to undefined for '==' and '!=' */
+        if ((JS_IsHTMLDDA(ctx, op1) &&
+             (tag2 == JS_TAG_NULL || tag2 == JS_TAG_UNDEFINED)) ||
+            (JS_IsHTMLDDA(ctx, op2) &&
+             (tag1 == JS_TAG_NULL || tag1 == JS_TAG_UNDEFINED))) {
+            res = TRUE;
+        } else {
+            res = FALSE;
+        }
         JS_FreeValue(ctx, op1);
         JS_FreeValue(ctx, op2);
-        res = FALSE;
     }
     sp[-2] = JS_NewBool(ctx, res ^ is_neq);
     return 0;
@@ -14631,7 +14712,7 @@ static __exception int js_operator_instanceof(JSContext *ctx, JSValue *sp)
     return 0;
 }
 
-static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
+static __exception int js_operator_typeof(JSContext *ctx, JSValueConst op1)
 {
     JSAtom atom;
     uint32_t tag;
@@ -14663,10 +14744,16 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
         atom = JS_ATOM_string;
         break;
     case JS_TAG_OBJECT:
-        if (JS_IsFunction(ctx, op1))
-            atom = JS_ATOM_function;
-        else
-            goto obj_type;
+        {
+            JSObject *p;
+            p = JS_VALUE_GET_OBJ(op1);
+            if (unlikely(p->is_HTMLDDA)) 
+                atom = JS_ATOM_undefined;
+            else if (JS_IsFunction(ctx, op1))
+                atom = JS_ATOM_function;
+            else
+                goto obj_type;
+        }
         break;
     case JS_TAG_NULL:
     obj_type:
@@ -15231,7 +15318,10 @@ static __exception int js_for_of_start(JSContext *ctx, JSValue *sp,
     return 0;
 }
 
-/* enum_rec -> enum_rec value done */
+/* enum_rec [objs] -> enum_rec [objs] value done. There are 'offset'
+   objs. If 'done' is true or in case of exception, 'enum_rec' is set
+   to undefined. If 'done' is true, 'value' is always set to
+   undefined. */
 static __exception int js_for_of_next(JSContext *ctx, JSValue *sp, int offset)
 {
     JSValue value = JS_UNDEFINED;
@@ -15246,8 +15336,12 @@ static __exception int js_for_of_next(JSContext *ctx, JSValue *sp, int offset)
             /* replace the iteration object with undefined */
             JS_FreeValue(ctx, sp[offset]);
             sp[offset] = JS_UNDEFINED;
-            if (done < 0)
+            if (done < 0) {
                 return -1;
+            } else {
+                JS_FreeValue(ctx, value);
+                value = JS_UNDEFINED;
+            }
         }
     }
     sp[0] = value;
@@ -15363,10 +15457,10 @@ static BOOL js_get_fast_array(JSContext *ctx, JSValueConst obj,
 static __exception int js_append_enumerate(JSContext *ctx, JSValue *sp)
 {
     JSValue iterator, enumobj, method, value;
-    int pos, is_array_iterator;
+    int is_array_iterator;
     JSValue *arrp;
-    uint32_t i, count32;
-
+    uint32_t i, count32, pos;
+    
     if (JS_VALUE_GET_TAG(sp[-2]) != JS_TAG_INT) {
         JS_ThrowInternalError(ctx, "invalid index for append");
         return -1;
@@ -15399,24 +15493,21 @@ static __exception int js_append_enumerate(JSContext *ctx, JSValue *sp)
     if (is_array_iterator
     &&  JS_IsCFunction(ctx, method, (JSCFunction *)js_array_iterator_next, 0)
     &&  js_get_fast_array(ctx, sp[-1], &arrp, &count32)) {
-        int64_t len;
-        /* Handle fast arrays explicitly */
-        if (js_get_length64(ctx, &len, sp[-1]))
+        uint32_t len;
+        if (js_get_length32(ctx, &len, sp[-1]))
             goto exception;
+        /* if len > count32, the elements >= count32 might be read in
+           the prototypes and might have side effects */
+        if (len != count32)
+            goto general_case;
+        /* Handle fast arrays explicitly */
         for (i = 0; i < count32; i++) {
             if (JS_DefinePropertyValueUint32(ctx, sp[-3], pos++,
                                              JS_DupValue(ctx, arrp[i]), JS_PROP_C_W_E) < 0)
                 goto exception;
         }
-        if (len > count32) {
-            /* This is not strictly correct because the trailing elements are
-               empty instead of undefined. Append undefined entries instead.
-             */
-            pos += len - count32;
-            if (JS_SetProperty(ctx, sp[-3], JS_ATOM_length, JS_NewUint32(ctx, pos)) < 0)
-                goto exception;
-        }
     } else {
+    general_case:
         for (;;) {
             BOOL done;
             value = JS_IteratorNext(ctx, enumobj, method, 0, NULL, &done);
@@ -15430,6 +15521,7 @@ static __exception int js_append_enumerate(JSContext *ctx, JSValue *sp)
                 goto exception;
         }
     }
+    /* Note: could raise an error if too many elements */
     sp[-2] = JS_NewInt32(ctx, pos);
     JS_FreeValue(ctx, enumobj);
     JS_FreeValue(ctx, method);
@@ -17742,47 +17834,42 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_add_loc):
             {
-                JSValue ops[2];
+                JSValue *pv;
                 int idx;
                 idx = *pc;
                 pc += 1;
 
-                ops[0] = var_buf[idx];
-                ops[1] = sp[-1];
-                if (likely(JS_VALUE_IS_BOTH_INT(ops[0], ops[1]))) {
+                pv = &var_buf[idx];
+                if (likely(JS_VALUE_IS_BOTH_INT(*pv, sp[-1]))) {
                     int64_t r;
-                    r = (int64_t)JS_VALUE_GET_INT(ops[0]) + JS_VALUE_GET_INT(ops[1]);
+                    r = (int64_t)JS_VALUE_GET_INT(*pv) +
+                        JS_VALUE_GET_INT(sp[-1]);
                     if (unlikely((int)r != r))
                         goto add_loc_slow;
-                    var_buf[idx] = JS_NewInt32(ctx, r);
+                    *pv = JS_NewInt32(ctx, r);
                     sp--;
-                } else if (JS_VALUE_GET_TAG(ops[0]) == JS_TAG_STRING) {
+                } else if (JS_VALUE_GET_TAG(*pv) == JS_TAG_STRING) {
+                    JSValue op1;
+                    op1 = sp[-1];
                     sp--;
-                    ops[1] = JS_ToPrimitiveFree(ctx, ops[1], HINT_NONE);
-                    if (JS_IsException(ops[1])) {
+                    op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
+                    if (JS_IsException(op1))
                         goto exception;
-                    }
-                    /* XXX: should not modify the variable in case of
-                       exception */
-                    ops[0] = JS_ConcatString(ctx, ops[0], ops[1]);
-                    if (JS_IsException(ops[0])) {
-                        var_buf[idx] = JS_UNDEFINED;
+                    op1 = JS_ConcatString(ctx, JS_DupValue(ctx, *pv), op1);
+                    if (JS_IsException(op1))
                         goto exception;
-                    }
-                    var_buf[idx] = ops[0];
+                    set_value(ctx, pv, op1);
                 } else {
+                    JSValue ops[2];
                 add_loc_slow:
-                    /* XXX: should not modify the variable in case of
-                       exception */
-                    sp--;
                     /* In case of exception, js_add_slow frees ops[0]
-                       and ops[1]. */
-                    /* XXX: change API */
-                    if (js_add_slow(ctx, ops + 2)) {
-                        var_buf[idx] = JS_UNDEFINED;
+                       and ops[1], so we must duplicate *pv */
+                    ops[0] = JS_DupValue(ctx, *pv);
+                    ops[1] = sp[-1];
+                    sp--;
+                    if (js_add_slow(ctx, ops + 2))
                         goto exception;
-                    }
-                    var_buf[idx] = ops[0];
+                    set_value(ctx, pv, ops[0]);
                 }
             }
             BREAK;
@@ -18427,7 +18514,15 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             } else {
                 goto free_and_set_false;
             }
-        CASE(OP_is_function):
+            /* XXX: could merge to a single opcode */
+        CASE(OP_typeof_is_undefined):
+            /* different from OP_is_undefined because of isHTMLDDA */
+            if (js_operator_typeof(ctx, sp[-1]) == JS_ATOM_undefined) {
+                goto free_and_set_true;
+            } else {
+                goto free_and_set_false;
+            }
+        CASE(OP_typeof_is_function):
             if (js_operator_typeof(ctx, sp[-1]) == JS_ATOM_function) {
                 goto free_and_set_true;
             } else {
@@ -19656,6 +19751,9 @@ enum {
     TOK_MATH_POW_ASSIGN,
 #endif
     TOK_POW_ASSIGN,
+    TOK_LAND_ASSIGN,
+    TOK_LOR_ASSIGN,
+    TOK_DOUBLE_QUESTION_MARK_ASSIGN,
     TOK_DEC,
     TOK_INC,
     TOK_SHL,
@@ -20015,11 +20113,14 @@ static void free_token(JSParseState *s, JSToken *token)
         JS_FreeValue(s->ctx, token->u.regexp.flags);
         break;
     case TOK_IDENT:
-    case TOK_FIRST_KEYWORD ... TOK_LAST_KEYWORD:
     case TOK_PRIVATE_NAME:
         JS_FreeAtom(s->ctx, token->u.ident.atom);
         break;
     default:
+        if (token->val >= TOK_FIRST_KEYWORD &&
+            token->val <= TOK_LAST_KEYWORD) {
+            JS_FreeAtom(s->ctx, token->u.ident.atom);
+        }
         break;
     }
 }
@@ -20233,6 +20334,8 @@ static __exception int js_parse_string(JSParseState *s, int sep,
         }
         if (c == '\\') {
             c = *p;
+            /* XXX: need a specific JSON case to avoid
+               accepting invalid escapes */
             switch(c) {
             case '\0':
                 if (p >= s->buf_end)
@@ -20256,18 +20359,23 @@ static __exception int js_parse_string(JSParseState *s, int sep,
                     s->line_num++;
                 continue;
             default:
-                if (c >= '0' && c <= '7') {
+                if (c >= '0' && c <= '9') {
                     if (!s->cur_func)
-                        goto invalid_octal; /* JSON case */
+                        goto invalid_escape; /* JSON case */
                     if (!(s->cur_func->js_mode & JS_MODE_STRICT) && sep != '`')
                         goto parse_escape;
                     if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
                         p++;
                         c = '\0';
                     } else {
-                    invalid_octal:
-                        if (do_throw)
-                            js_parse_error(s, "invalid octal syntax in strict mode");
+                        if (c >= '8' || sep == '`') {
+                            /* Note: according to ES2021, \8 and \9 are not
+                               accepted in strict mode or in templates. */
+                            goto invalid_escape;
+                        } else {
+                            if (do_throw)
+                                js_parse_error(s, "octal escape sequences are not allowed in strict mode");
+                        }
                         goto fail;
                     }
                 } else if (c >= 0x80) {
@@ -20284,6 +20392,7 @@ static __exception int js_parse_string(JSParseState *s, int sep,
                 parse_escape:
                     ret = lre_parse_escape(&p, TRUE);
                     if (ret == -1) {
+                    invalid_escape:
                         if (do_throw)
                             js_parse_error(s, "malformed escape sequence in string literal");
                         goto fail;
@@ -20634,8 +20743,20 @@ static __exception int next_token(JSParseState *s)
             }
         }
         goto def_token;
-    case 'a' ... 'z':
-    case 'A' ... 'Z':
+    case 'a': case 'b': case 'c': case 'd':
+    case 'e': case 'f': case 'g': case 'h':
+    case 'i': case 'j': case 'k': case 'l':
+    case 'm': case 'n': case 'o': case 'p':
+    case 'q': case 'r': case 's': case 't':
+    case 'u': case 'v': case 'w': case 'x':
+    case 'y': case 'z': 
+    case 'A': case 'B': case 'C': case 'D':
+    case 'E': case 'F': case 'G': case 'H':
+    case 'I': case 'J': case 'K': case 'L':
+    case 'M': case 'N': case 'O': case 'P':
+    case 'Q': case 'R': case 'S': case 'T':
+    case 'U': case 'V': case 'W': case 'X':
+    case 'Y': case 'Z': 
     case '_':
     case '$':
         /* identifier */
@@ -20717,7 +20838,9 @@ static __exception int next_token(JSParseState *s)
             goto fail;
         }
         goto parse_number;
-    case '1' ... '9':
+    case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8':
+    case '9': 
         /* number */
     parse_number:
         {
@@ -20887,8 +21010,13 @@ static __exception int next_token(JSParseState *s)
             p += 2;
             s->token.val = TOK_AND_ASSIGN;
         } else if (p[1] == '&') {
-            p += 2;
-            s->token.val = TOK_LAND;
+            if (p[2] == '=') {
+                p += 3;
+                s->token.val = TOK_LAND_ASSIGN;
+            } else {
+                p += 2;
+                s->token.val = TOK_LAND;
+            }
         } else {
             goto def_token;
         }
@@ -20934,16 +21062,26 @@ static __exception int next_token(JSParseState *s)
             p += 2;
             s->token.val = TOK_OR_ASSIGN;
         } else if (p[1] == '|') {
-            p += 2;
-            s->token.val = TOK_LOR;
+            if (p[2] == '=') {
+                p += 3;
+                s->token.val = TOK_LOR_ASSIGN;
+            } else {
+                p += 2;
+                s->token.val = TOK_LOR;
+            }
         } else {
             goto def_token;
         }
         break;
     case '?':
         if (p[1] == '?') {
-            p += 2;
-            s->token.val = TOK_DOUBLE_QUESTION_MARK;
+            if (p[2] == '=') {
+                p += 3;
+                s->token.val = TOK_DOUBLE_QUESTION_MARK_ASSIGN;
+            } else {
+                p += 2;
+                s->token.val = TOK_DOUBLE_QUESTION_MARK;
+            }
         } else if (p[1] == '.' && !(p[2] >= '0' && p[2] <= '9')) {
             p += 2;
             s->token.val = TOK_QUESTION_MARK_DOT;
@@ -21135,8 +21273,20 @@ static __exception int json_next_token(JSParseState *s)
             goto def_token;
         }
         break;
-    case 'a' ... 'z':
-    case 'A' ... 'Z':
+    case 'a': case 'b': case 'c': case 'd':
+    case 'e': case 'f': case 'g': case 'h':
+    case 'i': case 'j': case 'k': case 'l':
+    case 'm': case 'n': case 'o': case 'p':
+    case 'q': case 'r': case 's': case 't':
+    case 'u': case 'v': case 'w': case 'x':
+    case 'y': case 'z': 
+    case 'A': case 'B': case 'C': case 'D':
+    case 'E': case 'F': case 'G': case 'H':
+    case 'I': case 'J': case 'K': case 'L':
+    case 'M': case 'N': case 'O': case 'P':
+    case 'Q': case 'R': case 'S': case 'T':
+    case 'U': case 'V': case 'W': case 'X':
+    case 'Y': case 'Z': 
     case '_':
     case '$':
         /* identifier : only pure ascii characters are accepted */
@@ -21161,7 +21311,9 @@ static __exception int json_next_token(JSParseState *s)
         if (!is_digit(p[1]))
             goto def_token;
         goto parse_number;
-    case '1' ... '9':
+    case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8':
+    case '9': 
         /* number */
     parse_number:
         {
@@ -23267,15 +23419,6 @@ static BOOL has_with_scope(JSFunctionDef *s, int scope_level)
     return FALSE;
 }
 
-typedef struct JSLValue {
-    int opcode;
-    int scope;
-    int label;
-    int depth;
-    int tok;
-    JSAtom name;
-} JSLValue;
-
 static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
                                   JSAtom *pname, int *plabel, int *pdepth, BOOL keep,
                                   int tok)
@@ -23400,84 +23543,112 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
     return 0;
 }
 
-/* if special = TRUE: specific post inc/dec case */
-/* name has a live reference */
+typedef enum {
+    PUT_LVALUE_NOKEEP, /* [depth] v -> */
+    PUT_LVALUE_NOKEEP_DEPTH, /* [depth] v -> , keep depth (currently
+                                just disable optimizations) */
+    PUT_LVALUE_KEEP_TOP,  /* [depth] v -> v */
+    PUT_LVALUE_KEEP_SECOND, /* [depth] v0 v -> v0 */
+    PUT_LVALUE_NOKEEP_BOTTOM, /* v [depth] -> */
+} PutLValueEnum;
+
+/* name has a live reference. 'is_let' is only used with opcode =
+   OP_scope_get_var which is never generated by get_lvalue(). */
 static void put_lvalue(JSParseState *s, int opcode, int scope,
-                       JSAtom name, int label, BOOL special)
+                       JSAtom name, int label, PutLValueEnum special,
+                       BOOL is_let)
 {
     switch(opcode) {
     case OP_get_field:
-        if (!special)
-            emit_op(s, OP_insert2); /* obj v -> v obj v */
-        else
-            emit_op(s, OP_perm3); /* obj v0 v -> v0 obj v */
-        emit_op(s, OP_put_field);
-        emit_u32(s, name);  /* name has refcount */
-        break;
     case OP_scope_get_private_field:
-        if (!special)
+        /* depth = 1 */
+        switch(special) {
+        case PUT_LVALUE_NOKEEP:
+        case PUT_LVALUE_NOKEEP_DEPTH:
+            break;
+        case PUT_LVALUE_KEEP_TOP:
             emit_op(s, OP_insert2); /* obj v -> v obj v */
-        else
+            break;
+        case PUT_LVALUE_KEEP_SECOND:
             emit_op(s, OP_perm3); /* obj v0 v -> v0 obj v */
-        emit_op(s, OP_scope_put_private_field);
-        emit_u32(s, name);  /* name has refcount */
-        emit_u16(s, scope);
+            break;
+        case PUT_LVALUE_NOKEEP_BOTTOM:
+            emit_op(s, OP_swap);
+            break;
+        default:
+            abort();
+        }
         break;
     case OP_get_array_el:
-        if (!special)
-            emit_op(s, OP_insert3); /* obj prop v -> v obj prop v */
-        else
-            emit_op(s, OP_perm4); /* obj prop v0 v -> v0 obj prop v */
-        emit_op(s, OP_put_array_el);
-        break;
     case OP_get_ref_value:
-        JS_FreeAtom(s->ctx, name);
-        emit_label(s, label);
-        if (!special)
+        /* depth = 2 */
+        if (opcode == OP_get_ref_value) {
+            JS_FreeAtom(s->ctx, name);
+            emit_label(s, label);
+        }
+        switch(special) {
+        case PUT_LVALUE_NOKEEP:
+            emit_op(s, OP_nop); /* will trigger optimization */
+            break;
+        case PUT_LVALUE_NOKEEP_DEPTH:
+            break;
+        case PUT_LVALUE_KEEP_TOP:
             emit_op(s, OP_insert3); /* obj prop v -> v obj prop v */
-        else
+            break;
+        case PUT_LVALUE_KEEP_SECOND:
             emit_op(s, OP_perm4); /* obj prop v0 v -> v0 obj prop v */
-        emit_op(s, OP_put_ref_value);
+            break;
+        case PUT_LVALUE_NOKEEP_BOTTOM:
+            emit_op(s, OP_rot3l);
+            break;
+        default:
+            abort();
+        }
         break;
     case OP_get_super_value:
-        if (!special)
+        /* depth = 3 */
+        switch(special) {
+        case PUT_LVALUE_NOKEEP:
+        case PUT_LVALUE_NOKEEP_DEPTH:
+            break;
+        case PUT_LVALUE_KEEP_TOP:
             emit_op(s, OP_insert4); /* this obj prop v -> v this obj prop v */
-        else
+            break;
+        case PUT_LVALUE_KEEP_SECOND:
             emit_op(s, OP_perm5); /* this obj prop v0 v -> v0 this obj prop v */
-        emit_op(s, OP_put_super_value);
+            break;
+        case PUT_LVALUE_NOKEEP_BOTTOM:
+            emit_op(s, OP_rot4l);
+            break;
+        default:
+            abort();
+        }
         break;
     default:
-        abort();
+        break;
     }
-}
-
-static void put_lvalue_nokeep(JSParseState *s, int opcode, int scope,
-                              JSAtom name, int label, int var_tok)
-{
+    
     switch(opcode) {
     case OP_scope_get_var:  /* val -- */
-        emit_op(s, (var_tok == TOK_CONST || var_tok == TOK_LET) ?
-                OP_scope_put_var_init : OP_scope_put_var);
+        assert(special == PUT_LVALUE_NOKEEP ||
+               special == PUT_LVALUE_NOKEEP_DEPTH);
+        emit_op(s, is_let ? OP_scope_put_var_init : OP_scope_put_var);
         emit_u32(s, name);  /* has refcount */
         emit_u16(s, scope);
         break;
-    case OP_get_field:      /* obj val -- */
+    case OP_get_field:
         emit_op(s, OP_put_field);
-        emit_u32(s, name);  /* has refcount */
+        emit_u32(s, name);  /* name has refcount */
         break;
     case OP_scope_get_private_field:
         emit_op(s, OP_scope_put_private_field);
-        emit_u32(s, name);  /* has refcount */
+        emit_u32(s, name);  /* name has refcount */
         emit_u16(s, scope);
         break;
-    case OP_get_array_el:   /* obj prop val -- */
+    case OP_get_array_el:
         emit_op(s, OP_put_array_el);
         break;
-    case OP_get_ref_value:   /* obj prop val -- */
-        /* XXX: currently this reference is never optimized */
-        JS_FreeAtom(s->ctx, name);
-        emit_label(s, label);
-        //emit_op(s, OP_nop);   /* emit 2 bytes for optimizer */
+    case OP_get_ref_value:
         emit_op(s, OP_put_ref_value);
         break;
     case OP_get_super_value:
@@ -23869,7 +24040,9 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                 emit_label(s, label_hasval);
             }
             /* store value into lvalue object */
-            put_lvalue_nokeep(s, opcode, scope, var_name, label_lvalue, tok);
+            put_lvalue(s, opcode, scope, var_name, label_lvalue,
+                       PUT_LVALUE_NOKEEP_DEPTH,
+                       (tok == TOK_CONST || tok == TOK_LET));
             if (s->token.val == '}')
                 break;
             /* accept a trailing comma before the '}' */
@@ -23969,8 +24142,9 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     emit_label(s, label_hasval);
                 }
                 /* store value into lvalue object */
-                put_lvalue_nokeep(s, opcode, scope, var_name,
-                                  label_lvalue, tok);
+                put_lvalue(s, opcode, scope, var_name,
+                           label_lvalue, PUT_LVALUE_NOKEEP_DEPTH,
+                           (tok == TOK_CONST || tok == TOK_LET));
             }
             if (s->token.val == ']')
                 break;
@@ -24786,7 +24960,8 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
                 return -1;
             emit_op(s, OP_dec + op - TOK_DEC);
-            put_lvalue(s, opcode, scope, name, label, FALSE);
+            put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP,
+                       FALSE);
         }
         break;
     case TOK_TYPEOF:
@@ -24834,7 +25009,8 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
                 return -1;
             emit_op(s, OP_post_dec + op - TOK_DEC);
-            put_lvalue(s, opcode, scope, name, label, TRUE);
+            put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_SECOND,
+                       FALSE);
             if (next_token(s))
                 return -1;        
         }
@@ -25298,7 +25474,61 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
 #endif
             emit_op(s, op);
         }
-        put_lvalue(s, opcode, scope, name, label, FALSE);
+        put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
+    } else if (op >= TOK_LAND_ASSIGN && op <= TOK_DOUBLE_QUESTION_MARK_ASSIGN) {
+        int label, label1, depth_lvalue, label2;
+        
+        if (next_token(s))
+            return -1;
+        if (get_lvalue(s, &opcode, &scope, &name, &label,
+                       &depth_lvalue, TRUE, op) < 0)
+            return -1;
+
+        emit_op(s, OP_dup);
+        if (op == TOK_DOUBLE_QUESTION_MARK_ASSIGN)
+            emit_op(s, OP_is_undefined_or_null);
+        label1 = emit_goto(s, op == TOK_LOR_ASSIGN ? OP_if_true : OP_if_false,
+                           -1);
+        emit_op(s, OP_drop);
+        
+        if (js_parse_assign_expr(s, in_accepted)) {
+            JS_FreeAtom(s->ctx, name);
+            return -1;
+        }
+
+        if (opcode == OP_get_ref_value && name == name0) {
+            set_object_name(s, name);
+        }
+        
+        switch(depth_lvalue) {
+        case 1:
+            emit_op(s, OP_insert2);
+            break;
+        case 2:
+            emit_op(s, OP_insert3);
+            break;
+        case 3:
+            emit_op(s, OP_insert4);
+            break;
+        default:
+            abort();
+        }
+
+        /* XXX: we disable the OP_put_ref_value optimization by not
+           using put_lvalue() otherwise depth_lvalue is not correct */
+        put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_NOKEEP_DEPTH,
+                   FALSE);
+        label2 = emit_goto(s, OP_goto, -1);
+        
+        emit_label(s, label1);
+
+        /* remove the lvalue stack entries */
+        while (depth_lvalue != 0) {
+            emit_op(s, OP_nip);
+            depth_lvalue--;
+        }
+
+        emit_label(s, label2);
     }
     return 0;
 }
@@ -25563,8 +25793,8 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
                         goto var_error;
                     }
                     set_object_name(s, name);
-                    put_lvalue(s, opcode, scope, name1, label, FALSE);
-                    emit_op(s, OP_drop);
+                    put_lvalue(s, opcode, scope, name1, label,
+                               PUT_LVALUE_NOKEEP, FALSE);
                 } else {
                     if (js_parse_assign_expr(s, in_accepted))
                         goto var_error;
@@ -25751,29 +25981,14 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
             if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
                 return -1;
         } else {
-            int lvalue_label, depth;
+            int lvalue_label;
             if (js_parse_postfix_expr(s, TRUE))
                 return -1;
             if (get_lvalue(s, &opcode, &scope, &var_name, &lvalue_label,
-                           &depth, FALSE, TOK_FOR))
+                           NULL, FALSE, TOK_FOR))
                 return -1;
-            /* swap value and lvalue object and store it into lvalue object */
-            /* enum_rec val [depth] -- enum_rec */
-            switch(depth) {
-            case 1:
-                emit_op(s, OP_swap);
-                break;
-            case 2:
-                emit_op(s, OP_rot3l);
-                break;
-            case 3:
-                emit_op(s, OP_rot4l);
-                break;
-            default:
-                abort();
-            }
-            put_lvalue_nokeep(s, opcode, scope, var_name, lvalue_label,
-                              TOK_FOR /* not used */);
+            put_lvalue(s, opcode, scope, var_name, lvalue_label,
+                       PUT_LVALUE_NOKEEP_BOTTOM, FALSE);
         }
         var_name = JS_ATOM_NULL;
     }
@@ -26933,32 +27148,20 @@ static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name)
 
 /* return NULL in case of exception (e.g. module could not be loaded) */
 static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
-                                                    JSAtom base_module_name,
-                                                    JSAtom module_name1)
+                                                    const char *base_cname,
+                                                    const char *cname1)
 {
     JSRuntime *rt = ctx->rt;
     JSModuleDef *m;
     char *cname;
-    const char *base_cname, *cname1;
     JSAtom module_name;
 
-    base_cname = JS_AtomToCString(ctx, base_module_name);
-    if (!base_cname)
-        return NULL;
-    cname1 = JS_AtomToCString(ctx, module_name1);
-    if (!cname1) {
-        JS_FreeCString(ctx, base_cname);
-        return NULL;
-    }
-
     if (!rt->module_normalize_func) {
         cname = js_default_module_normalize_name(ctx, base_cname, cname1);
     } else {
         cname = rt->module_normalize_func(ctx, base_cname, cname1,
                                           rt->module_loader_opaque);
     }
-    JS_FreeCString(ctx, base_cname);
-    JS_FreeCString(ctx, cname1);
     if (!cname)
         return NULL;
 
@@ -26992,6 +27195,27 @@ static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
     return m;
 }
 
+static JSModuleDef *js_host_resolve_imported_module_atom(JSContext *ctx,
+                                                    JSAtom base_module_name,
+                                                    JSAtom module_name1)
+{
+    const char *base_cname, *cname;
+    JSModuleDef *m;
+    
+    base_cname = JS_AtomToCString(ctx, base_module_name);
+    if (!base_cname)
+        return NULL;
+    cname = JS_AtomToCString(ctx, module_name1);
+    if (!cname) {
+        JS_FreeCString(ctx, base_cname);
+        return NULL;
+    }
+    m = js_host_resolve_imported_module(ctx, base_cname, cname);
+    JS_FreeCString(ctx, base_cname);
+    JS_FreeCString(ctx, cname);
+    return m;
+}
+
 typedef struct JSResolveEntry {
     JSModuleDef *module;
     JSAtom name;
@@ -27435,8 +27659,8 @@ static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
     /* resolve each requested module */
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        m1 = js_host_resolve_imported_module(ctx, m->module_name,
-                                             rme->module_name);
+        m1 = js_host_resolve_imported_module_atom(ctx, m->module_name,
+                                                  rme->module_name);
         if (!m1)
             return -1;
         rme->module = m1;
@@ -27711,8 +27935,9 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     return -1;
 }
 
-/* warning: the returned atom is not allocated */
-static JSAtom js_get_script_or_module_name(JSContext *ctx)
+/* return JS_ATOM_NULL if the name cannot be found. Only works with
+   not striped bytecode functions. */
+JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
 {
     JSStackFrame *sf;
     JSFunctionBytecode *b;
@@ -27721,14 +27946,22 @@ static JSAtom js_get_script_or_module_name(JSContext *ctx)
        function. It does not work for eval(). Need to add a
        ScriptOrModule info in JSFunctionBytecode */
     sf = ctx->rt->current_stack_frame;
-    assert(sf != NULL);
-    assert(JS_VALUE_GET_TAG(sf->cur_func) == JS_TAG_OBJECT);
+    if (!sf)
+        return JS_ATOM_NULL;
+    while (n_stack_levels-- > 0) {
+        sf = sf->prev_frame;
+        if (!sf)
+            return JS_ATOM_NULL;
+    }
+    if (JS_VALUE_GET_TAG(sf->cur_func) != JS_TAG_OBJECT)
+        return JS_ATOM_NULL;
     p = JS_VALUE_GET_OBJ(sf->cur_func);
-    assert(js_class_has_bytecode(p->class_id));
+    if (!js_class_has_bytecode(p->class_id))
+        return JS_ATOM_NULL;
     b = p->u.func.function_bytecode;
     if (!b->has_debug)
         return JS_ATOM_NULL;
-    return b->debug.filename;
+    return JS_DupAtom(ctx, b->debug.filename);
 }
 
 JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m)
@@ -27755,13 +27988,14 @@ static JSValue js_import_meta(JSContext *ctx)
     JSAtom filename;
     JSModuleDef *m;
     
-    filename = js_get_script_or_module_name(ctx);
+    filename = JS_GetScriptOrModuleName(ctx, 0);
     if (filename == JS_ATOM_NULL)
         goto fail;
 
     /* XXX: inefficient, need to add a module or script pointer in
        JSFunctionBytecode */
     m = js_find_loaded_module(ctx, filename);
+    JS_FreeAtom(ctx, filename);
     if (!m) {
     fail:
         JS_ThrowTypeError(ctx, "import.meta not supported in this context");
@@ -27770,6 +28004,31 @@ static JSValue js_import_meta(JSContext *ctx)
     return JS_GetImportMeta(ctx, m);
 }
 
+/* used by os.Worker() and import() */
+JSModuleDef *JS_RunModule(JSContext *ctx, const char *basename,
+                          const char *filename)
+{
+    JSModuleDef *m;
+    JSValue ret, func_obj;
+    
+    m = js_host_resolve_imported_module(ctx, basename, filename);
+    if (!m)
+        return NULL;
+    
+    if (js_resolve_module(ctx, m) < 0) {
+        js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
+        return NULL;
+    }
+
+    /* Evaluate the module code */
+    func_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+    ret = JS_EvalFunction(ctx, func_obj);
+    if (JS_IsException(ret))
+        return NULL;
+    JS_FreeValue(ctx, ret);
+    return m;
+}
+
 static JSValue js_dynamic_import_job(JSContext *ctx,
                                      int argc, JSValueConst *argv)
 {
@@ -27777,53 +28036,36 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
     JSValueConst basename_val = argv[2];
     JSValueConst specifier = argv[3];
     JSModuleDef *m;
-    JSAtom basename = JS_ATOM_NULL, filename;
-    JSValue specifierString, ret, func_obj, err, ns;
+    const char *basename = NULL, *filename;
+    JSValue ret, err, ns;
 
     if (!JS_IsString(basename_val)) {
         JS_ThrowTypeError(ctx, "no function filename for import()");
         goto exception;
     }
-    basename = JS_ValueToAtom(ctx, basename_val);
-    if (basename == JS_ATOM_NULL)
+    basename = JS_ToCString(ctx, basename_val);
+    if (!basename)
         goto exception;
 
-    specifierString = JS_ToString(ctx, specifier);
-    if (JS_IsException(specifierString))
-        goto exception;
-    filename = JS_ValueToAtom(ctx, specifierString);
-    JS_FreeValue(ctx, specifierString);
-    if (filename == JS_ATOM_NULL)
+    filename = JS_ToCString(ctx, specifier);
+    if (!filename)
         goto exception;
                      
-    m = js_host_resolve_imported_module(ctx, basename, filename);
-    JS_FreeAtom(ctx, filename);
-    if (!m) {
-        goto exception;
-    }
-    
-    if (js_resolve_module(ctx, m) < 0) {
-        js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
-        goto exception;
-    }
-
-    /* Evaluate the module code */
-    func_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
-    ret = JS_EvalFunction(ctx, func_obj);
-    if (JS_IsException(ret))
+    m = JS_RunModule(ctx, basename, filename);
+    JS_FreeCString(ctx, filename);
+    if (!m)
         goto exception;
-    JS_FreeValue(ctx, ret);
 
     /* return the module namespace */
     ns = js_get_module_ns(ctx, m);
-    if (JS_IsException(ret))
+    if (JS_IsException(ns))
         goto exception;
 
     ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
                    1, (JSValueConst *)&ns);
     JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
     JS_FreeValue(ctx, ns);
-    JS_FreeAtom(ctx, basename);
+    JS_FreeCString(ctx, basename);
     return JS_UNDEFINED;
  exception:
 
@@ -27832,7 +28074,7 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
                    1, (JSValueConst *)&err);
     JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
     JS_FreeValue(ctx, err);
-    JS_FreeAtom(ctx, basename);
+    JS_FreeCString(ctx, basename);
     return JS_UNDEFINED;
 }
 
@@ -27842,11 +28084,12 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     JSValue promise, resolving_funcs[2], basename_val;
     JSValueConst args[4];
 
-    basename = js_get_script_or_module_name(ctx);
+    basename = JS_GetScriptOrModuleName(ctx, 0);
     if (basename == JS_ATOM_NULL)
         basename_val = JS_NULL;
     else
         basename_val = JS_AtomToValue(ctx, basename);
+    JS_FreeAtom(ctx, basename);
     if (JS_IsException(basename_val))
         return basename_val;
     
@@ -28957,7 +29200,7 @@ static BOOL can_opt_put_ref_value(const uint8_t *bc_buf, int pos)
     return (bc_buf[pos + 1] == OP_put_ref_value &&
             (opcode == OP_insert3 ||
              opcode == OP_perm4 ||
-             //opcode == OP_nop ||
+             opcode == OP_nop ||
              opcode == OP_rot3l));
 }
 
@@ -28967,7 +29210,7 @@ static BOOL can_opt_put_global_ref_value(const uint8_t *bc_buf, int pos)
     return (bc_buf[pos + 1] == OP_put_ref_value &&
             (opcode == OP_insert3 ||
              opcode == OP_perm4 ||
-             //opcode == OP_nop ||
+             opcode == OP_nop ||
              opcode == OP_rot3l));
 }
 
@@ -29049,20 +29292,22 @@ static int optimize_scope_make_global_ref(JSContext *ctx, JSFunctionDef *s,
     end_pos = label_pos + 2;
     op = bc_buf[label_pos];
     if (is_strict) {
-        switch(op) {
-        case OP_insert3:
-            op = OP_insert2;
-            break;
-        case OP_perm4:
-            op = OP_perm3;
-            break;
-        case OP_rot3l:
-            op = OP_swap;
-            break;
-        default:
-            abort();
+        if (op != OP_nop) {
+            switch(op) {
+            case OP_insert3:
+                op = OP_insert2;
+                break;
+            case OP_perm4:
+                op = OP_perm3;
+                break;
+            case OP_rot3l:
+                op = OP_swap;
+                break;
+            default:
+                abort();
+            }
+            bc_buf[pos++] = op;
         }
-        bc_buf[pos++] = op;
     } else {
         if (op == OP_insert3)
             bc_buf[pos++] = OP_dup;
@@ -31567,20 +31812,20 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
             }
             goto no_change;
 
+#if SHORT_OPCODES
         case OP_typeof:
             if (OPTIMIZE) {
                 /* simplify typeof tests */
                 if (code_match(&cc, pos_next, OP_push_atom_value, M4(OP_strict_eq, OP_strict_neq, OP_eq, OP_neq), -1)) {
                     if (cc.line_num >= 0) line_num = cc.line_num;
                     int op1 = (cc.op == OP_strict_eq || cc.op == OP_eq) ? OP_strict_eq : OP_strict_neq;
-#if SHORT_OPCODES
                     int op2 = -1;
                     switch (cc.atom) {
                     case JS_ATOM_undefined:
-                        op2 = OP_is_undefined;
+                        op2 = OP_typeof_is_undefined;
                         break;
                     case JS_ATOM_function:
-                        op2 = OP_is_function;
+                        op2 = OP_typeof_is_function;
                         break;
                     }
                     if (op2 >= 0) {
@@ -31604,19 +31849,10 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                             goto has_label;
                         }
                     }
-#endif
-                    if (cc.atom == JS_ATOM_undefined) {
-                        /* transform typeof(s) == "undefined" into s === void 0 */
-                        add_pc2line_info(s, bc_out.size, line_num);
-                        dbuf_putc(&bc_out, OP_undefined);
-                        dbuf_putc(&bc_out, op1);
-                        JS_FreeAtom(ctx, cc.atom);
-                        pos_next = cc.pos;
-                        break;
-                    }
                 }
             }
             goto no_change;
+#endif
 
         default:
         no_change:
@@ -37067,10 +37303,9 @@ static JSValue js_function_bind(JSContext *ctx, JSValueConst this_val,
                                 int argc, JSValueConst *argv)
 {
     JSBoundFunction *bf;
-    JSValue func_obj, name1;
+    JSValue func_obj, name1, len_val;
     JSObject *p;
-    int arg_count, i;
-    uint32_t len1;
+    int arg_count, i, ret;
 
     if (check_function(ctx, this_val))
         return JS_EXCEPTION;
@@ -37093,6 +37328,44 @@ static JSValue js_function_bind(JSContext *ctx, JSValueConst this_val,
     }
     p->u.bound_function = bf;
 
+    /* XXX: the spec could be simpler by only using GetOwnProperty */
+    ret = JS_GetOwnProperty(ctx, NULL, this_val, JS_ATOM_length);
+    if (ret < 0)
+        goto exception;
+    if (!ret) {
+        len_val = JS_NewInt32(ctx, 0);
+    } else {
+        len_val = JS_GetProperty(ctx, this_val, JS_ATOM_length);
+        if (JS_IsException(len_val))
+            goto exception;
+        if (JS_VALUE_GET_TAG(len_val) == JS_TAG_INT) {
+            /* most common case */
+            int len1 = JS_VALUE_GET_INT(len_val);
+            if (len1 <= arg_count)
+                len1 = 0;
+            else
+                len1 -= arg_count;
+            len_val = JS_NewInt32(ctx, len1);
+        } else if (JS_VALUE_GET_NORM_TAG(len_val) == JS_TAG_FLOAT64) {
+            double d = JS_VALUE_GET_FLOAT64(len_val);
+            if (isnan(d)) {
+                d = 0.0;
+            } else {
+                d = trunc(d);
+                if (d <= (double)arg_count)
+                    d = 0.0;
+                else
+                    d -= (double)arg_count; /* also converts -0 to +0 */
+            }
+            len_val = JS_NewFloat64(ctx, d);
+        } else {
+            JS_FreeValue(ctx, len_val);
+            len_val = JS_NewInt32(ctx, 0);
+        }
+    }
+    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_length,
+                           len_val, JS_PROP_CONFIGURABLE);
+
     name1 = JS_GetProperty(ctx, this_val, JS_ATOM_name);
     if (JS_IsException(name1))
         goto exception;
@@ -37105,15 +37378,6 @@ static JSValue js_function_bind(JSContext *ctx, JSValueConst this_val,
         goto exception;
     JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, name1,
                            JS_PROP_CONFIGURABLE);
-    if (js_get_length32(ctx, &len1, this_val))
-        goto exception;
-    if (len1 <= (uint32_t)arg_count)
-        len1 = 0;
-    else
-        len1 -= arg_count;
-    JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_length,
-                           JS_NewUint32(ctx, len1),
-                           JS_PROP_CONFIGURABLE);
     return func_obj;
  exception:
     JS_FreeValue(ctx, func_obj);
@@ -40455,10 +40719,6 @@ static JSValue js_string_pad(JSContext *ctx, JSValueConst this_val,
     len = p->len;
     if (len >= n)
         return str;
-    if (n > JS_STRING_LEN_MAX) {
-        JS_ThrowInternalError(ctx, "string too long");
-        goto fail2;
-    }
     if (argc > 1 && !JS_IsUndefined(argv[1])) {
         v = JS_ToString(ctx, argv[1]);
         if (JS_IsException(v))
@@ -40473,6 +40733,10 @@ static JSValue js_string_pad(JSContext *ctx, JSValueConst this_val,
             p1 = NULL;
         }
     }
+    if (n > JS_STRING_LEN_MAX) {
+        JS_ThrowInternalError(ctx, "string too long");
+        goto fail2;
+    }
     if (string_buffer_init(ctx, b, n))
         goto fail3;
     n -= len;
@@ -41932,14 +42196,11 @@ static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(obj))
             goto fail;
         prop_flags = JS_PROP_C_W_E | JS_PROP_THROW;
-        group_name_ptr = NULL;
-        if (re_flags & LRE_FLAG_NAMED_GROUPS) {
-            uint32_t re_bytecode_len;
+        group_name_ptr = lre_get_groupnames(re_bytecode);
+        if (group_name_ptr) {
             groups = JS_NewObjectProto(ctx, JS_NULL);
             if (JS_IsException(groups))
                 goto fail;
-            re_bytecode_len = get_u32(re_bytecode + 3);
-            group_name_ptr = (char *)(re_bytecode + 7 + re_bytecode_len);
         }
 
         for(i = 0; i < capture_count; i++) {
@@ -43724,6 +43985,7 @@ static const JSCFunctionListEntry js_reflect_funcs[] = {
     JS_CFUNC_MAGIC_DEF("preventExtensions", 1, js_object_preventExtensions, 1 ),
     JS_CFUNC_DEF("set", 3, js_reflect_set ),
     JS_CFUNC_DEF("setPrototypeOf", 2, js_reflect_setPrototypeOf ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "Reflect", JS_PROP_CONFIGURABLE ),
 };
 
 static const JSCFunctionListEntry js_reflect_obj[] = {
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index db293728ec..bb84829b96 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -412,6 +412,8 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s);
 void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt);
 
 /* atom support */
+#define JS_ATOM_NULL 0
+
 JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len);
 JSAtom JS_NewAtom(JSContext *ctx, const char *str);
 JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n);
@@ -835,6 +837,8 @@ typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);
 /* if can_block is TRUE, Atomics.wait() can be used */
 void JS_SetCanBlock(JSRuntime *rt, JS_BOOL can_block);
+/* set the [IsHTMLDDA] internal slot */
+void JS_SetIsHTMLDDA(JSContext *ctx, JSValueConst obj);
 
 typedef struct JSModuleDef JSModuleDef;
 
@@ -886,6 +890,12 @@ JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
    returns a module. */
 int JS_ResolveModule(JSContext *ctx, JSValueConst obj);
 
+/* only exported for os.Worker() */
+JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels);
+/* only exported for os.Worker() */
+JSModuleDef *JS_RunModule(JSContext *ctx, const char *basename,
+                          const char *filename);
+
 /* C function definition */
 typedef enum JSCFunctionEnum {  /* XXX: should rename for namespace isolation */
     JS_CFUNC_generic,

From 06be240c3a5a0fad3f9ba39ada7bfb21180dc5e3 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 27 Sep 2020 15:23:33 +0300
Subject: [PATCH 074/185] gcc-8 compilation fix (constexpr)

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 392db85d0e..c98db4b655 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1079,7 +1079,7 @@ class Context
             template <auto FGet, auto FSet = nullptr>
             class_registrar& property(const char * name)
             {
-                if constexpr (FSet == nullptr)
+                if /*constexpr*/ (FSet == nullptr)
                     prototype.add_getter<FGet>(name);
                 else
                     prototype.add_getter_setter<FGet, FSet>(name);

From bdba242126d7d6ba80f613707aaa09b49b182387 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A1s=20Fridvalszky?= <flankonad@gmail.com>
Date: Mon, 16 Nov 2020 09:19:49 +0100
Subject: [PATCH 075/185] fix function object registration: missing ctx param,
 functions without parameters throw qjs::exception from unwrapped js function

---
 quickjspp.hpp | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index c98db4b655..787608a482 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1027,7 +1027,7 @@ class Context
         template <typename F>
         Module& function(const char * name, F&& f)
         {
-            return add(name, js_traits<decltype(std::function{std::forward<F>(f)})>::wrap(std::forward<F>(f)));
+            return add(name, js_traits<decltype(std::function{std::forward<F>(f)})>::wrap(ctx, std::forward<F>(f)));
         }
 
         // class register wrapper
@@ -1258,14 +1258,29 @@ struct js_traits<std::function<R(Args...)>>
 {
     static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
     {
-        return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
-            const int argc = sizeof...(Args);
-            JSValue argv[argc];
-            detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
-            JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst *>(argv));
-            for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
-            return detail::unwrap_free<R>(jsfun_obj.ctx, result);
-        };
+        const int argc = sizeof...(Args);
+        if constexpr (argc == 0) {
+            return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }]()->R {
+                JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, 0, nullptr);
+                if (JS_IsException(result)) {
+                    JS_FreeValue(jsfun_obj.ctx, result);
+                    throw exception{};
+                }
+                return detail::unwrap_free<R>(jsfun_obj.ctx, result);
+            };
+        } else {
+            return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }](Args&& ... args)->R {
+                JSValue argv[argc];
+                detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
+                JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
+                for (int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
+                if (JS_IsException(result)) {
+                    JS_FreeValue(jsfun_obj.ctx, result);
+                    throw exception{};
+                }
+                return detail::unwrap_free<R>(jsfun_obj.ctx, result);
+            };
+        }
     }
 
     /** Convert from function object functor to JSValue.

From fd9e30676cf18e6c22a26d6731516fe96d757c28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A1s=20Fridvalszky?= <flankonad@gmail.com>
Date: Mon, 16 Nov 2020 09:21:49 +0100
Subject: [PATCH 076/185] change code style

---
 quickjspp.hpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 787608a482..f6f9cb0706 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1259,22 +1259,27 @@ struct js_traits<std::function<R(Args...)>>
     static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
     {
         const int argc = sizeof...(Args);
-        if constexpr (argc == 0) {
+        if constexpr(argc == 0)
+        {
             return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }]()->R {
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, 0, nullptr);
-                if (JS_IsException(result)) {
+                if(JS_IsException(result))
+                {
                     JS_FreeValue(jsfun_obj.ctx, result);
                     throw exception{};
                 }
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
-        } else {
+        } 
+        else 
+        {
             return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }](Args&& ... args)->R {
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
-                for (int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
-                if (JS_IsException(result)) {
+                for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
+                if(JS_IsException(result))
+                {
                     JS_FreeValue(jsfun_obj.ctx, result);
                     throw exception{};
                 }

From 8bd631bb76aa2dca2bc1e0cfbd6b9e8d40c68481 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 16 Nov 2020 14:18:25 +0300
Subject: [PATCH 077/185] update quickjs to 2020-11-08

---
 quickjs/VERSION          |    2 +-
 quickjs/libbf.h          |    2 +-
 quickjs/libregexp.c      |   26 +-
 quickjs/quickjs-atom.h   |    1 +
 quickjs/quickjs-libc.c   |   95 +-
 quickjs/quickjs-opcode.h |   13 +-
 quickjs/quickjs.c        | 2541 +++++++++++++++++++++-----------------
 quickjs/quickjs.h        |    9 +-
 8 files changed, 1509 insertions(+), 1180 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index c67790a714..78749b0c7e 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-09-06
+2020-11-08
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index 6749b35c69..4576bf8854 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -27,7 +27,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#if defined(__x86_64__)
+#if INTPTR_MAX >= INT64_MAX
 #define LIMB_LOG2_BITS 6
 #else
 #define LIMB_LOG2_BITS 5
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index bbb5e9d701..379bfc7a95 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -75,7 +75,7 @@ typedef struct {
     int capture_count;
     int total_capture_count; /* -1 = not computed yet */
     int has_named_captures; /* -1 = don't know, 0 = no, 1 = yes */
-    void *mem_opaque;
+    void *opaque;
     DynBuf group_names;
     union {
         char error_msg[TMP_BUF_SIZE];
@@ -230,7 +230,7 @@ static int cr_init_char_range(REParseState *s, CharRange *cr, uint32_t c)
     invert = c & 1;
     c_pt = char_range_table[c >> 1];
     len = *c_pt++;
-    cr_init(cr, s->mem_opaque, lre_realloc);
+    cr_init(cr, s->opaque, lre_realloc);
     for(i = 0; i < len * 2; i++) {
         if (cr_add_point(cr, c_pt[i]))
             goto fail;
@@ -625,7 +625,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
     p++;
     q = name;
     while (is_unicode_char(*p)) {
-        if ((q - name) > sizeof(name) - 1)
+        if ((q - name) >= sizeof(name) - 1)
             goto unknown_property_name;
         *q++ = *p++;
     }
@@ -634,7 +634,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
     if (*p == '=') {
         p++;
         while (is_unicode_char(*p)) {
-            if ((q - value) > sizeof(value) - 1)
+            if ((q - value) >= sizeof(value) - 1)
                 return re_parse_error(s, "unknown unicode property value");
             *q++ = *p++;
         }
@@ -651,7 +651,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
     } else if (!strcmp(name, "Script_Extensions") || !strcmp(name, "scx")) {
         script_ext = TRUE;
     do_script:
-        cr_init(cr, s->mem_opaque, lre_realloc);
+        cr_init(cr, s->opaque, lre_realloc);
         ret = unicode_script(cr, value, script_ext);
         if (ret) {
             cr_free(cr);
@@ -661,7 +661,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
                 goto out_of_memory;
         }
     } else if (!strcmp(name, "General_Category") || !strcmp(name, "gc")) {
-        cr_init(cr, s->mem_opaque, lre_realloc);
+        cr_init(cr, s->opaque, lre_realloc);
         ret = unicode_general_category(cr, value);
         if (ret) {
             cr_free(cr);
@@ -671,7 +671,7 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
                 goto out_of_memory;
         }
     } else if (value[0] == '\0') {
-        cr_init(cr, s->mem_opaque, lre_realloc);
+        cr_init(cr, s->opaque, lre_realloc);
         ret = unicode_general_category(cr, name);
         if (ret == -1) {
             cr_free(cr);
@@ -864,7 +864,7 @@ static int re_parse_char_class(REParseState *s, const uint8_t **pp)
     CharRange cr1_s, *cr1 = &cr1_s;
     BOOL invert;
     
-    cr_init(cr, s->mem_opaque, lre_realloc);
+    cr_init(cr, s->opaque, lre_realloc);
     p = *pp;
     p++;    /* skip '[' */
     invert = FALSE;
@@ -1147,9 +1147,13 @@ static int re_parse_captures(REParseState *s, int *phas_named_captures,
                         }
                     }
                     capture_index++;
+                    if (capture_index >= CAPTURE_COUNT_MAX)
+                        goto done;
                 }
             } else {
                 capture_index++;
+                if (capture_index >= CAPTURE_COUNT_MAX)
+                    goto done;
             }
             break;
         case '\\':
@@ -1163,6 +1167,7 @@ static int re_parse_captures(REParseState *s, int *phas_named_captures,
             break;
         }
     }
+ done:
     if (capture_name)
         return -1;
     else
@@ -1734,6 +1739,9 @@ static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
 {
     int start, len, pos;
 
+    if (lre_check_stack_overflow(s->opaque, 0))
+        return re_parse_error(s, "stack overflow");
+    
     start = s->byte_code.size;
     if (re_parse_alternative(s, is_backward_dir))
         return -1;
@@ -1819,7 +1827,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     BOOL is_sticky;
     
     memset(s, 0, sizeof(*s));
-    s->mem_opaque = opaque;
+    s->opaque = opaque;
     s->buf_ptr = (const uint8_t *)buf;
     s->buf_end = s->buf_ptr + buf_len;
     s->buf_start = s->buf_ptr;
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index a353ad4426..4c2279452a 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -113,6 +113,7 @@ DEF(caller, "caller")
 DEF(_eval_, "<eval>")
 DEF(_ret_, "<ret>")
 DEF(_var_, "<var>")
+DEF(_arg_var_, "<arg_var>")
 DEF(_with_, "<with>")
 DEF(lastIndex, "lastIndex")
 DEF(target, "target")
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index 00a7536d77..e8b81e910c 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -623,6 +623,97 @@ static JSValue js_std_getenv(JSContext *ctx, JSValueConst this_val,
         return JS_NewString(ctx, str);
 }
 
+#if defined(_WIN32)
+static void setenv(const char *name, const char *value, int overwrite)
+{
+    char *str;
+    size_t name_len, value_len;
+    name_len = strlen(name);
+    value_len = strlen(value);
+    str = malloc(name_len + 1 + value_len + 1);
+    memcpy(str, name, name_len);
+    str[name_len] = '=';
+    memcpy(str + name_len + 1, value, value_len);
+    str[name_len + 1 + value_len] = '\0';
+    _putenv(str);
+    free(str);
+}
+
+static void unsetenv(const char *name)
+{
+    setenv(name, "", TRUE);
+}
+#endif /* _WIN32 */
+
+static JSValue js_std_setenv(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
+{
+    const char *name, *value;
+    name = JS_ToCString(ctx, argv[0]);
+    if (!name)
+        return JS_EXCEPTION;
+    value = JS_ToCString(ctx, argv[1]);
+    if (!value) {
+        JS_FreeCString(ctx, name);
+        return JS_EXCEPTION;
+    }
+    setenv(name, value, TRUE);
+    JS_FreeCString(ctx, name);
+    JS_FreeCString(ctx, value);
+    return JS_UNDEFINED;
+}
+
+static JSValue js_std_unsetenv(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
+{
+    const char *name;
+    name = JS_ToCString(ctx, argv[0]);
+    if (!name)
+        return JS_EXCEPTION;
+    unsetenv(name);
+    JS_FreeCString(ctx, name);
+    return JS_UNDEFINED;
+}
+
+/* return an object containing the list of the available environment
+   variables. */
+static JSValue js_std_getenviron(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    char **envp;
+    const char *name, *p, *value;
+    JSValue obj;
+    uint32_t idx;
+    size_t name_len;
+    JSAtom atom;
+    int ret;
+
+    obj = JS_NewObject(ctx);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    envp = environ;
+    for(idx = 0; envp[idx] != NULL; idx++) {
+        name = envp[idx];
+        p = strchr(name, '=');
+        name_len = p - name;
+        if (!p)
+            continue;
+        value = p + 1;
+        atom = JS_NewAtomLen(ctx, name, name_len);
+        if (atom == JS_ATOM_NULL)
+            goto fail;
+        ret = JS_DefinePropertyValue(ctx, obj, atom, JS_NewString(ctx, value),
+                                     JS_PROP_C_W_E);
+        JS_FreeAtom(ctx, atom);
+        if (ret < 0)
+            goto fail;
+    }
+    return obj;
+ fail:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
 static JSValue js_std_gc(JSContext *ctx, JSValueConst this_val,
                          int argc, JSValueConst *argv)
 {
@@ -1395,6 +1486,9 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("evalScript", 1, js_evalScript ),
     JS_CFUNC_DEF("loadScript", 1, js_loadScript ),
     JS_CFUNC_DEF("getenv", 1, js_std_getenv ),
+    JS_CFUNC_DEF("setenv", 1, js_std_setenv ),
+    JS_CFUNC_DEF("unsetenv", 1, js_std_unsetenv ),
+    JS_CFUNC_DEF("getenviron", 1, js_std_getenviron ),
     JS_CFUNC_DEF("urlGet", 1, js_std_urlGet ),
     JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
     JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
@@ -1412,7 +1506,6 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_PROP_INT32_DEF("SEEK_CUR", SEEK_CUR, JS_PROP_CONFIGURABLE ),
     JS_PROP_INT32_DEF("SEEK_END", SEEK_END, JS_PROP_CONFIGURABLE ),
     JS_OBJECT_DEF("Error", js_std_error_props, countof(js_std_error_props), JS_PROP_CONFIGURABLE),
-    /* setenv, ... */
 };
     
 static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 387363c370..c731a14a9c 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -114,7 +114,7 @@ DEF(    check_brand, 1, 2, 2, none) /* this_obj func -> this_obj func */
 DEF(      add_brand, 1, 2, 0, none) /* this_obj home_obj -> */
 DEF(   return_async, 1, 1, 0, none)
 DEF(          throw, 1, 1, 0, none)
-DEF(      throw_var, 6, 0, 0, atom_u8)
+DEF(    throw_error, 6, 0, 0, atom_u8)
 DEF(           eval, 5, 1, 1, npop_u16) /* func args... -> ret_val */
 DEF(     apply_eval, 3, 2, 1, u16) /* func array -> ret_eval */
 DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern and a
@@ -205,16 +205,15 @@ DEF(   for_of_start, 1, 1, 3, none)
 DEF(for_await_of_start, 1, 1, 3, none)
 DEF(    for_in_next, 1, 1, 3, none)
 DEF(    for_of_next, 2, 3, 5, u8)
-DEF(for_await_of_next, 1, 3, 4, none)
+DEF(iterator_check_object, 1, 1, 1, none)
 DEF(iterator_get_value_done, 1, 1, 2, none)
 DEF( iterator_close, 1, 3, 0, none)
 DEF(iterator_close_return, 1, 4, 4, none)
-DEF(async_iterator_close, 1, 3, 2, none)
-DEF(async_iterator_next, 1, 4, 4, none)
-DEF(async_iterator_get, 2, 4, 5, u8)
+DEF(  iterator_next, 1, 4, 4, none)
+DEF(  iterator_call, 2, 4, 5, u8)
 DEF(  initial_yield, 1, 0, 0, none)
 DEF(          yield, 1, 1, 2, none)
-DEF(     yield_star, 1, 2, 2, none)
+DEF(     yield_star, 1, 1, 2, none)
 DEF(async_yield_star, 1, 1, 2, none)
 DEF(          await, 1, 1, 1, none)
 
@@ -266,8 +265,6 @@ DEF(            nop, 1, 0, 0, none)
 
 /* temporary opcodes: never emitted in the final bytecode */
 
-def(set_arg_valid_upto, 3, 0, 0, arg) /* emitted in phase 1, removed in phase 2 */
-
 def(    enter_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
 def(    leave_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
 
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index efc1d54aad..a39ff8f66c 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -199,7 +199,7 @@ typedef enum JSErrorEnum {
 } JSErrorEnum;
 
 #define JS_MAX_LOCAL_VARS 65536
-#define JS_STACK_SIZE_MAX 65536
+#define JS_STACK_SIZE_MAX 65534
 #define JS_STRING_LEN_MAX ((1 << 30) - 1)
 
 #define __exception __attribute__((warn_unused_result))
@@ -506,14 +506,17 @@ typedef struct JSClosureVar {
     uint8_t is_arg : 1;
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
-    uint8_t var_kind : 3; /* see JSVarKindEnum */
-    /* 9 bits available */
+    uint8_t var_kind : 4; /* see JSVarKindEnum */
+    /* 8 bits available */
     uint16_t var_idx; /* is_local = TRUE: index to a normal variable of the
                     parent function. otherwise: index to a closure
                     variable of the parent function */
     JSAtom var_name;
 } JSClosureVar;
 
+#define ARG_SCOPE_INDEX 1
+#define ARG_SCOPE_END (-2)
+
 typedef struct JSVarScope {
     int parent;  /* index into fd->scopes of the enclosing scope */
     int first;   /* index into fd->vars of the last variable in this scope */
@@ -526,6 +529,7 @@ typedef enum {
     JS_VAR_NEW_FUNCTION_DECL, /* lexical var with async/generator
                                  function declaration */
     JS_VAR_CATCH,
+    JS_VAR_FUNCTION_NAME, /* function expression name */
     JS_VAR_PRIVATE_FIELD,
     JS_VAR_PRIVATE_METHOD,
     JS_VAR_PRIVATE_GETTER,
@@ -533,12 +537,21 @@ typedef enum {
     JS_VAR_PRIVATE_GETTER_SETTER, /* must come after JS_VAR_PRIVATE_SETTER */
 } JSVarKindEnum;
 
+/* XXX: could use a different structure in bytecode functions to save
+   memory */
 typedef struct JSVarDef {
     JSAtom var_name;
-    int scope_level;   /* index into fd->scopes of this variable lexical scope */
-    int scope_next;    /* index into fd->vars of the next variable in the
-                        * same or enclosing lexical scope */
-    uint8_t is_func_var : 1; /* used for the function self reference */
+    /* index into fd->scopes of this variable lexical scope */
+    int scope_level;
+    /* during compilation: 
+        - if scope_level = 0: scope in which the variable is defined
+        - if scope_level != 0: index into fd->vars of the next
+          variable in the same or enclosing lexical scope
+       in a bytecode function:
+       index into fd->vars of the next
+       variable in the same or enclosing lexical scope
+    */
+    int scope_next;    
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
     uint8_t is_captured : 1;
@@ -548,7 +561,9 @@ typedef struct JSVarDef {
        JS_VAR_FUNCTION_DECL/JS_VAR_NEW_FUNCTION_DECL or scope level of
        the definition of the 'var' variables (they have scope_level =
        0) */
-    int func_pool_or_scope_idx : 24; /* only used during compilation */
+    int func_pool_idx : 24; /* only used during compilation : index in
+                               the constant pool for hoisted function
+                               definition */
 } JSVarDef;
 
 /* for the encoding of the pc2line table */
@@ -855,7 +870,7 @@ struct JSObject {
             uint8_t extensible : 1;
             uint8_t free_mark : 1; /* only used when freeing objects with cycles */
             uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
-            uint8_t fast_array : 1; /* TRUE if u.array is used for get/put */
+            uint8_t fast_array : 1; /* TRUE if u.array is used for get/put (for JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS and typed arrays) */
             uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
             uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
             uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
@@ -1000,7 +1015,7 @@ static JSValue JS_CallFree(JSContext *ctx, JSValue func_obj, JSValueConst this_o
 static JSValue JS_InvokeFree(JSContext *ctx, JSValue this_val, JSAtom atom,
                              int argc, JSValueConst *argv);
 static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
-                                            JSValue val);
+                                            JSValue val, BOOL is_array_ctor);
 static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
                              JSValueConst val, int flags, int scope_idx);
 JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
@@ -1226,11 +1241,11 @@ static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
                           JSGCObjectTypeEnum type);
 static void remove_gc_object(JSGCObjectHeader *h);
 static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s);
-static int js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
-static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
+static JSValue js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
+static JSValue js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
                                  void *opaque);
-static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
-                                          JSAtom atom, void *opaque);
+static JSValue JS_InstantiateFunctionListItem2(JSContext *ctx, JSObject *p,
+                                               JSAtom atom, void *opaque);
 void JS_SetUncatchableError(JSContext *ctx, JSValueConst val, BOOL flag);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
@@ -6710,6 +6725,21 @@ static JSValue JS_ThrowReferenceErrorUninitialized(JSContext *ctx, JSAtom name)
                                   JS_AtomGetStr(ctx, buf, sizeof(buf), name));
 }
 
+static JSValue JS_ThrowReferenceErrorUninitialized2(JSContext *ctx,
+                                                    JSFunctionBytecode *b,
+                                                    int idx, BOOL is_ref)
+{
+    JSAtom atom = JS_ATOM_NULL;
+    if (is_ref) {
+        atom = b->closure_var[idx].var_name;
+    } else {
+        /* not present if the function is stripped and contains no eval() */
+        if (b->vardefs)
+            atom = b->vardefs[b->arg_count + idx].var_name;
+    }
+    return JS_ThrowReferenceErrorUninitialized(ctx, atom);
+}
+
 static JSValue JS_ThrowTypeErrorInvalidClass(JSContext *ctx, int class_id)
 {
     JSRuntime *rt = ctx->rt;
@@ -6986,25 +7016,37 @@ int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj)
     return JS_OrdinaryIsInstanceOf(ctx, val, obj);
 }
 
-typedef int JSAutoInitFunc(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
+/* return the value associated to the autoinit property or an exception */
+typedef JSValue JSAutoInitFunc(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
 
 static JSAutoInitFunc *js_autoinit_func_table[] = {
     js_instantiate_prototype, /* JS_AUTOINIT_ID_PROTOTYPE */
     js_module_ns_autoinit, /* JS_AUTOINIT_ID_MODULE_NS */
-    JS_InstantiateFunctionListItem, /* JS_AUTOINIT_ID_PROP */
+    JS_InstantiateFunctionListItem2, /* JS_AUTOINIT_ID_PROP */
 };
 
+/* warning: 'prs' is reallocated after it */
 static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
-                               JSProperty *pr)
+                               JSProperty *pr, JSShapeProperty *prs)
 {
-    int ret;
+    JSValue val;
     JSContext *realm;
     JSAutoInitFunc *func;
-    
+
+    if (js_shape_prepare_update(ctx, p, &prs))
+        return -1;
+
     realm = js_autoinit_get_realm(pr);
     func = js_autoinit_func_table[js_autoinit_get_id(pr)];
-    ret = func(realm, p, prop, pr->u.init.opaque);
-    return ret;
+    /* 'func' shall not modify the object properties 'pr' */
+    val = func(realm, p, prop, pr->u.init.opaque);
+    js_autoinit_free(ctx->rt, pr);
+    prs->flags &= ~JS_PROP_TMASK;
+    pr->u.value = JS_UNDEFINED;
+    if (JS_IsException(val))
+        return -1;
+    pr->u.value = val;
+    return 0;
 }
 
 JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
@@ -7075,7 +7117,7 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
                     return JS_DupValue(ctx, val);
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
                     /* Instantiate property and retry */
-                    if (JS_AutoInitProperty(ctx, p, prop, pr))
+                    if (JS_AutoInitProperty(ctx, p, prop, pr, prs))
                         return JS_EXCEPTION;
                     continue;
                 }
@@ -7093,7 +7135,7 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
                         return JS_GetPropertyUint32(ctx, JS_MKPTR(JS_TAG_OBJECT, p), idx);
                     } else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
                                p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
-                        goto typed_array_oob;
+                        return JS_UNDEFINED;
                     }
                 } else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
                            p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
@@ -7102,9 +7144,6 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
                     if (ret != 0) {
                         if (ret < 0)
                             return JS_EXCEPTION;
-                    typed_array_oob:
-                        if (typed_array_is_detached(ctx, p))
-                            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
                         return JS_UNDEFINED;
                     }
                 }
@@ -7337,6 +7376,22 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     return 0;
 }
 
+static uint32_t js_string_obj_get_length(JSContext *ctx,
+                                         JSValueConst obj)
+{
+    JSObject *p;
+    JSString *p1;
+    uint32_t len = 0;
+
+    /* This is a class exotic method: obj class_id is JS_CLASS_STRING */
+    p = JS_VALUE_GET_OBJ(obj);
+    if (JS_VALUE_GET_TAG(p->u.object_data) == JS_TAG_STRING) {
+        p1 = JS_VALUE_GET_STRING(p->u.object_data);
+        len = p1->len;
+    }
+    return len;
+}
+
 static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
 {
     JSContext *ctx = opaque;
@@ -7379,7 +7434,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
     JSPropertyEnum *tab_atom, *tab_exotic;
     JSAtom atom;
     uint32_t num_keys_count, str_keys_count, sym_keys_count, atom_count;
-    uint32_t num_index, str_index, sym_index, exotic_count;
+    uint32_t num_index, str_index, sym_index, exotic_count, exotic_keys_count;
     BOOL is_enumerable, num_sorted;
     uint32_t num_key;
     JSAtomKindEnum kind;
@@ -7392,6 +7447,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
     num_keys_count = 0;
     str_keys_count = 0;
     sym_keys_count = 0;
+    exotic_keys_count = 0;
     exotic_count = 0;
     tab_exotic = NULL;
     sh = p->shape;
@@ -7425,19 +7481,13 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
 
     if (p->is_exotic) {
         if (p->fast_array) {
-            /* the implicit GetOwnProperty raises an exception if the
-               typed array is detached */
-            if ((flags & (JS_GPN_SET_ENUM | JS_GPN_ENUM_ONLY)) &&
-                 (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
-                  p->class_id <= JS_CLASS_FLOAT64_ARRAY) &&
-                 typed_array_is_detached(ctx, p) &&
-                typed_array_get_length(ctx, p) != 0) {
-                JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-                return -1;
-            }
             if (flags & JS_GPN_STRING_MASK) {
                 num_keys_count += p->u.array.count;
             }
+        } else if (p->class_id == JS_CLASS_STRING) {
+            if (flags & JS_GPN_STRING_MASK) {
+                num_keys_count += js_string_obj_get_length(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+            }
         } else {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
             if (em && em->get_own_property_names) {
@@ -7466,13 +7516,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
                             tab_exotic[i].is_enumerable = is_enumerable;
                         }
                         if (!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) {
-                            if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
-                                num_keys_count++;
-                            } else if (kind == JS_ATOM_KIND_STRING) {
-                                str_keys_count++;
-                            } else {
-                                sym_keys_count++;
-                            }
+                            exotic_keys_count++;
                         }
                     }
                 }
@@ -7482,7 +7526,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
 
     /* fill them */
 
-    atom_count = num_keys_count + str_keys_count + sym_keys_count;
+    atom_count = num_keys_count + str_keys_count + sym_keys_count + exotic_keys_count;
     /* avoid allocating 0 bytes */
     tab_atom = js_malloc(ctx, sizeof(tab_atom[0]) * max_int(atom_count, 1));
     if (!tab_atom) {
@@ -7518,12 +7562,19 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
     }
 
     if (p->is_exotic) {
+        int len;
         if (p->fast_array) {
             if (flags & JS_GPN_STRING_MASK) {
-                for(i = 0; i < p->u.array.count; i++) {
+                len = p->u.array.count;
+                goto add_array_keys;
+            }
+        } else if (p->class_id == JS_CLASS_STRING) {
+            if (flags & JS_GPN_STRING_MASK) {
+                len = js_string_obj_get_length(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+            add_array_keys:
+                for(i = 0; i < len; i++) {
                     tab_atom[num_index].atom = __JS_AtomFromUInt32(i);
                     if (tab_atom[num_index].atom == JS_ATOM_NULL) {
-                        js_free_prop_enum(ctx, tab_exotic, exotic_count);
                         js_free_prop_enum(ctx, tab_atom, num_index);
                         return -1;
                     }
@@ -7531,30 +7582,23 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
                     num_index++;
                 }
             }
-        }
-        if (exotic_count > 0) {
+        } else {
+            /* Note: exotic keys are not reordered and comes after the object own properties. */
             for(i = 0; i < exotic_count; i++) {
                 atom = tab_exotic[i].atom;
                 is_enumerable = tab_exotic[i].is_enumerable;
                 kind = JS_AtomGetKind(ctx, atom);
                 if ((!(flags & JS_GPN_ENUM_ONLY) || is_enumerable) &&
                     ((flags >> kind) & 1) != 0) {
-                    if (JS_AtomIsArrayIndex(ctx, &num_key, atom)) {
-                        j = num_index++;
-                        num_sorted = FALSE;
-                    } else if (kind == JS_ATOM_KIND_STRING) {
-                        j = str_index++;
-                    } else {
-                        j = sym_index++;
-                    }
-                    tab_atom[j].atom = atom;
-                    tab_atom[j].is_enumerable = is_enumerable;
+                    tab_atom[sym_index].atom = atom;
+                    tab_atom[sym_index].is_enumerable = is_enumerable;
+                    sym_index++;
                 } else {
                     JS_FreeAtom(ctx, atom);
                 }
             }
+            js_free(ctx, tab_exotic);
         }
-        js_free(ctx, tab_exotic);
     }
 
     assert(num_index == num_keys_count);
@@ -7614,7 +7658,7 @@ static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
                     desc->value = JS_DupValue(ctx, val);
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
                     /* Instantiate property and retry */
-                    if (JS_AutoInitProperty(ctx, p, prop, pr))
+                    if (JS_AutoInitProperty(ctx, p, prop, pr, prs))
                         return -1;
                     goto retry;
                 }
@@ -7642,10 +7686,8 @@ static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
                 idx = __JS_AtomToUInt32(prop);
                 if (idx < p->u.array.count) {
                     if (desc) {
-                        desc->flags = JS_PROP_WRITABLE | JS_PROP_ENUMERABLE;
-                        if (p->class_id == JS_CLASS_ARRAY ||
-                            p->class_id == JS_CLASS_ARGUMENTS)
-                            desc->flags |= JS_PROP_CONFIGURABLE;
+                        desc->flags = JS_PROP_WRITABLE | JS_PROP_ENUMERABLE |
+                            JS_PROP_CONFIGURABLE;
                         desc->getter = JS_UNDEFINED;
                         desc->setter = JS_UNDEFINED;
                         desc->value = JS_GetPropertyUint32(ctx, JS_MKPTR(JS_TAG_OBJECT, p), idx);
@@ -7653,19 +7695,6 @@ static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
                     return TRUE;
                 }
             }
-            if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
-                p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
-                int ret;
-                ret = JS_AtomIsNumericIndex(ctx, prop);
-                if (ret != 0) {
-                    if (ret < 0)
-                        return -1;
-                    if (typed_array_is_detached(ctx, p)) {
-                        JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-                        return -1;
-                    }
-                }
-            }
         } else {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
             if (em && em->get_own_property) {
@@ -7748,8 +7777,6 @@ int JS_HasProperty(JSContext *ctx, JSValueConst obj, JSAtom prop)
             if (ret != 0) {
                 if (ret < 0)
                     return -1;
-                /* the detached array test was done in
-                   JS_GetOwnPropertyInternal() */
                 return FALSE;
             }
         }
@@ -8074,7 +8101,7 @@ static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
                         return -1;
                     goto redo;
                 } else {
-                    return FALSE; /* not configurable */
+                    return FALSE;
                 }
             }
         } else {
@@ -8114,15 +8141,19 @@ static int call_setter(JSContext *ctx, JSObject *setter,
 }
 
 /* set the array length and remove the array elements if necessary. */
-static int set_array_length(JSContext *ctx, JSObject *p, JSValue val, int flags)
+static int set_array_length(JSContext *ctx, JSObject *p, JSValue val,
+                            int flags)
 {
     uint32_t len, idx, cur_len;
     int i, ret;
 
     /* Note: this call can reallocate the properties of 'p' */
-    ret = JS_ToArrayLengthFree(ctx, &len, val);
+    ret = JS_ToArrayLengthFree(ctx, &len, val, FALSE);
     if (ret)
         return -1;
+    /* JS_ToArrayLengthFree() must be done before the read-only test */
+    if (unlikely(!(p->shape->prop[0].flags & JS_PROP_WRITABLE)))
+        return JS_ThrowTypeErrorReadOnly(ctx, flags, JS_ATOM_length);
 
     if (likely(p->fast_array)) {
         uint32_t old_len = p->u.array.count;
@@ -8382,8 +8413,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
             /* fast case */
             set_value(ctx, &pr->u.value, val);
             return TRUE;
-        } else if ((prs->flags & (JS_PROP_LENGTH | JS_PROP_WRITABLE)) ==
-                   (JS_PROP_LENGTH | JS_PROP_WRITABLE)) {
+        } else if (prs->flags & JS_PROP_LENGTH) {
             assert(p->class_id == JS_CLASS_ARRAY);
             assert(prop == JS_ATOM_length);
             return set_array_length(ctx, p, val, flags);
@@ -8399,7 +8429,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
             return TRUE;
         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
             /* Instantiate property and retry (potentially useless) */
-            if (JS_AutoInitProperty(ctx, p, prop, pr)) {
+            if (JS_AutoInitProperty(ctx, p, prop, pr, prs)) {
                 JS_FreeValue(ctx, val);
                 return -1;
             }
@@ -8437,10 +8467,6 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                         JS_FreeValue(ctx, val);
                         if (JS_IsException(val))
                             return -1;
-                        if (typed_array_is_detached(ctx, p1)) {
-                            JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-                            return -1;
-                        }
                         return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound numeric index");
                     }
                 }
@@ -8509,7 +8535,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                 return call_setter(ctx, pr->u.getset.setter, this_obj, val, flags);
             } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
                 /* Instantiate property and retry (potentially useless) */
-                if (JS_AutoInitProperty(ctx, p1, prop, pr))
+                if (JS_AutoInitProperty(ctx, p1, prop, pr, prs))
                     return -1;
                 goto retry2;
             } else if (!(prs->flags & JS_PROP_WRITABLE)) {
@@ -8677,12 +8703,7 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
                 return -1;
             if (unlikely(idx >= (uint32_t)p->u.array.count)) {
             ta_out_of_bound:
-                if (typed_array_is_detached(ctx, p)) {
-                    JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-                    return -1;
-                } else {
-                    return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound numeric index");
-                }
+                return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound numeric index");
             }
             p->u.array.u.double_ptr[idx] = d;
             break;
@@ -8967,13 +8988,32 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
  redo_prop_update:
     prs = find_own_property(&pr, p, prop);
     if (prs) {
+        /* the range of the Array length property is always tested before */
+        if ((prs->flags & JS_PROP_LENGTH) && (flags & JS_PROP_HAS_VALUE)) {
+            uint32_t array_length;
+            if (JS_ToArrayLengthFree(ctx, &array_length,
+                                     JS_DupValue(ctx, val), FALSE)) {
+                return -1;
+            }
+            /* this code relies on the fact that Uint32 are never allocated */
+            val = (JSValueConst)JS_NewUint32(ctx, array_length);
+            /* prs may have been modified */
+            prs = find_own_property(&pr, p, prop);
+            assert(prs != NULL);
+        }
         /* property already exists */
         if (!check_define_prop_flags(prs->flags, flags)) {
         not_configurable:
             return JS_ThrowTypeErrorOrFalse(ctx, flags, "property is not configurable");
         }
 
-    retry:
+        if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
+            /* Instantiate property and retry */
+            if (JS_AutoInitProperty(ctx, p, prop, pr, prs))
+                return -1;
+            goto redo_prop_update;
+        }
+
         if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
                      JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
             if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
@@ -8996,14 +9036,6 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                     /* convert to getset */
                     if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
                         free_var_ref(ctx->rt, pr->u.var_ref);
-                    } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                        /* clear property and update */
-                        if (js_shape_prepare_update(ctx, p, &prs))
-                            return -1;
-                        js_autoinit_free(ctx->rt, pr);
-                        prs->flags &= ~JS_PROP_TMASK;
-                        pr->u.value = JS_UNDEFINED;
-                        goto retry;
                     } else {
                         JS_FreeValue(ctx, pr->u.value);
                     }
@@ -9051,39 +9083,17 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                     pr->u.value = JS_UNDEFINED;
                 } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
                     /* Note: JS_PROP_VARREF is always writable */
-                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                    /* clear property and update */
-                    if (js_shape_prepare_update(ctx, p, &prs))
-                        return -1;
-                    js_autoinit_free(ctx->rt, pr);
-                    prs->flags &= ~JS_PROP_TMASK;
-                    pr->u.value = JS_UNDEFINED;
                 } else {
                     if ((prs->flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0 &&
-                        (flags & JS_PROP_HAS_VALUE) &&
-                        !js_same_value(ctx, val, pr->u.value)) {
-                        goto not_configurable;
+                        (flags & JS_PROP_HAS_VALUE)) {
+                        if (!js_same_value(ctx, val, pr->u.value)) {
+                            goto not_configurable;
+                        } else {
+                            return TRUE;
+                        }
                     }
                 }
-                if (prs->flags & JS_PROP_LENGTH) {
-                    if (flags & JS_PROP_HAS_VALUE) {
-                        res = set_array_length(ctx, p, JS_DupValue(ctx, val),
-                                               flags);
-                    } else {
-                        res = TRUE;
-                    }
-                    /* still need to reset the writable flag if needed.
-                       The JS_PROP_LENGTH is reset to have the correct
-                       read-only behavior in JS_SetProperty(). */
-                    if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
-                        JS_PROP_HAS_WRITABLE) {
-                        prs = get_shape_prop(p->shape);
-                        if (js_update_property_flags(ctx, p, &prs,
-                                                     prs->flags & ~(JS_PROP_WRITABLE | JS_PROP_LENGTH)))
-                            return -1;
-                    }
-                    return res;
-                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
+                if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
                     if (flags & JS_PROP_HAS_VALUE) {
                         if (p->class_id == JS_CLASS_MODULE_NS) {
                             /* JS_PROP_WRITABLE is always true for variable
@@ -9107,9 +9117,27 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                         pr->u.value = val1;
                         prs->flags &= ~(JS_PROP_TMASK | JS_PROP_WRITABLE);
                     }
-                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                    /* XXX: should never happen, type was reset above */
-                    abort();
+                } else if (prs->flags & JS_PROP_LENGTH) {
+                    if (flags & JS_PROP_HAS_VALUE) {
+                        /* Note: no JS code is executable because
+                           'val' is guaranted to be a Uint32 */
+                        res = set_array_length(ctx, p, JS_DupValue(ctx, val),
+                                               flags);
+                    } else {
+                        res = TRUE;
+                    }
+                    /* still need to reset the writable flag if
+                       needed.  The JS_PROP_LENGTH is kept because the
+                       Uint32 test is still done if the length
+                       property is read-only. */
+                    if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
+                        JS_PROP_HAS_WRITABLE) {
+                        prs = get_shape_prop(p->shape);
+                        if (js_update_property_flags(ctx, p, &prs,
+                                                     prs->flags & ~JS_PROP_WRITABLE))
+                            return -1;
+                    }
+                    return res;
                 } else {
                     if (flags & JS_PROP_HAS_VALUE) {
                         JS_FreeValue(ctx, pr->u.value);
@@ -9194,9 +9222,9 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
             typed_array_oob:
                 return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound index in typed array");
             }
-            prop_flags = get_prop_flags(flags, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE);
+            prop_flags = get_prop_flags(flags, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
             if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET) ||
-                prop_flags != (JS_PROP_ENUMERABLE | JS_PROP_WRITABLE)) {
+                prop_flags != (JS_PROP_ENUMERABLE | JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE)) {
                 return JS_ThrowTypeErrorOrFalse(ctx, flags, "invalid descriptor flags");
             }
             if (flags & JS_PROP_HAS_VALUE) {
@@ -9581,9 +9609,8 @@ static int JS_SetGlobalVar(JSContext *ctx, JSAtom prop, JSValue val,
         set_value(ctx, &pr->u.value, val);
         return 0;
     }
-
     flags = JS_PROP_THROW_STRICT;
-    if (flag != 2 && is_strict_mode(ctx))
+    if (is_strict_mode(ctx)) 
         flags |= JS_PROP_NO_ADD;
     return JS_SetPropertyInternal(ctx, ctx->global_obj, prop, val, flags);
 }
@@ -10918,11 +10945,10 @@ static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
 }
 
 static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
-                                            JSValue val)
+                                            JSValue val, BOOL is_array_ctor)
 {
     uint32_t tag, len;
 
- redo:
     tag = JS_VALUE_GET_TAG(val);
     switch(tag) {
     case JS_TAG_INT:
@@ -10959,16 +10985,36 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
             double d;
             d = JS_VALUE_GET_FLOAT64(val);
             len = (uint32_t)d;
-            if (len != d) {
-            fail:
-                JS_ThrowRangeError(ctx, "invalid array length");
-                return -1;
-            }
+            if (len != d)
+                goto fail;
         } else {
-            val = JS_ToNumberFree(ctx, val);
-            if (JS_IsException(val))
-                return -1;
-            goto redo;
+            uint32_t len1;
+
+            if (is_array_ctor) {
+                val = JS_ToNumberFree(ctx, val);
+                if (JS_IsException(val))
+                    return -1;
+                /* cannot recurse because val is a number */
+                if (JS_ToArrayLengthFree(ctx, &len, val, TRUE))
+                    return -1;
+            } else {
+                /* legacy behavior: must do the conversion twice and compare */
+                if (JS_ToUint32(ctx, &len, val)) {
+                    JS_FreeValue(ctx, val);
+                    return -1;
+                }
+                val = JS_ToNumberFree(ctx, val);
+                if (JS_IsException(val))
+                    return -1;
+                /* cannot recurse because val is a number */
+                if (JS_ToArrayLengthFree(ctx, &len1, val, FALSE))
+                    return -1;
+                if (len1 != len) {
+                fail:
+                    JS_ThrowRangeError(ctx, "invalid array length");
+                    return -1;
+                }
+            }
         }
         break;
     }
@@ -15031,15 +15077,6 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
             if (prs->flags & JS_PROP_ENUMERABLE)
                 goto normal_case;
         }
-        /* the implicit GetOwnProperty raises an exception if the
-           typed array is detached */
-        if ((p->class_id >= JS_CLASS_UINT8C_ARRAY &&
-             p->class_id <= JS_CLASS_FLOAT64_ARRAY) &&
-            typed_array_is_detached(ctx, p) &&
-            typed_array_get_length(ctx, p) != 0) {
-            JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-            goto fail;
-        }
         /* for fast arrays, we only store the number of elements */
         it->is_array = TRUE;
         it->array_length = p->u.array.count;
@@ -15349,16 +15386,6 @@ static __exception int js_for_of_next(JSContext *ctx, JSValue *sp, int offset)
     return 0;
 }
 
-static __exception int js_for_await_of_next(JSContext *ctx, JSValue *sp)
-{
-    JSValue result;
-    result = JS_Call(ctx, sp[-2], sp[-3], 0, NULL);
-    if (JS_IsException(result))
-        return -1;
-    sp[0] = result;
-    return 0;
-}
-
 static JSValue JS_IteratorGetCompleteValue(JSContext *ctx, JSValueConst obj,
                                            BOOL *pdone)
 {
@@ -15663,7 +15690,7 @@ static JSValue js_closure2(JSContext *ctx, JSValue func_obj,
     return JS_EXCEPTION;
 }
 
-static int js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque)
+static JSValue js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque)
 {
     JSValue obj, this_val;
     int ret;
@@ -15671,15 +15698,17 @@ static int js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, vo
     this_val = JS_MKPTR(JS_TAG_OBJECT, p);
     obj = JS_NewObject(ctx);
     if (JS_IsException(obj))
-        return -1;
+        return JS_EXCEPTION;
     set_cycle_flag(ctx, obj);
     set_cycle_flag(ctx, this_val);
     ret = JS_DefinePropertyValue(ctx, obj, JS_ATOM_constructor,
                                  JS_DupValue(ctx, this_val),
                                  JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    if (JS_DefinePropertyValue(ctx, this_val, atom, obj, JS_PROP_WRITABLE) < 0 || ret < 0)
-        return -1;
-    return 0;
+    if (ret < 0) {
+        JS_FreeValue(ctx, obj);
+        return JS_EXCEPTION;
+    }
+    return obj;
 }
 
 static const uint16_t func_kind_to_class_id[] = {
@@ -16645,11 +16674,12 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             JS_Throw(ctx, *--sp);
             goto exception;
 
-        CASE(OP_throw_var):
+        CASE(OP_throw_error):
 #define JS_THROW_VAR_RO             0
 #define JS_THROW_VAR_REDECL         1
 #define JS_THROW_VAR_UNINITIALIZED  2
-#define JS_THROW_VAR_DELETE_SUPER   3
+#define JS_THROW_ERROR_DELETE_SUPER   3
+#define JS_THROW_ERROR_ITERATOR_THROW 4
             {
                 JSAtom atom;
                 int type;
@@ -16665,8 +16695,11 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 if (type == JS_THROW_VAR_UNINITIALIZED)
                     JS_ThrowReferenceErrorUninitialized(ctx, atom);
                 else
-                if (type == JS_THROW_VAR_DELETE_SUPER)
+                if (type == JS_THROW_ERROR_DELETE_SUPER)
                     JS_ThrowReferenceError(ctx, "unsupported reference to 'super'");
+                else
+                if (type == JS_THROW_ERROR_ITERATOR_THROW)
+                    JS_ThrowTypeError(ctx, "iterator does not have a throw method");
                 else
                     JS_ThrowInternalError(ctx, "invalid throw var type %d", type);
             }
@@ -16995,7 +17028,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 pc += 2;
                 val = *var_refs[idx]->pvalue;
                 if (unlikely(JS_IsUninitialized(val))) {
-                    JS_ThrowReferenceErrorUninitialized(ctx, JS_ATOM_NULL);
+                    JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, TRUE);
                     goto exception;
                 }
                 sp[0] = JS_DupValue(ctx, val);
@@ -17008,7 +17041,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 idx = get_u16(pc);
                 pc += 2;
                 if (unlikely(JS_IsUninitialized(*var_refs[idx]->pvalue))) {
-                    JS_ThrowReferenceErrorUninitialized(ctx, JS_ATOM_NULL);
+                    JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, TRUE);
                     goto exception;
                 }
                 set_value(ctx, var_refs[idx]->pvalue, sp[-1]);
@@ -17021,7 +17054,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 idx = get_u16(pc);
                 pc += 2;
                 if (unlikely(!JS_IsUninitialized(*var_refs[idx]->pvalue))) {
-                    JS_ThrowReferenceErrorUninitialized(ctx, JS_ATOM_NULL);
+                    JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, TRUE);
                     goto exception;
                 }
                 set_value(ctx, var_refs[idx]->pvalue, sp[-1]);
@@ -17042,7 +17075,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 idx = get_u16(pc);
                 pc += 2;
                 if (unlikely(JS_IsUninitialized(var_buf[idx]))) {
-                    JS_ThrowReferenceErrorUninitialized(ctx, JS_ATOM_NULL);
+                    JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, FALSE);
                     goto exception;
                 }
                 sp[0] = JS_DupValue(ctx, var_buf[idx]);
@@ -17055,7 +17088,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 idx = get_u16(pc);
                 pc += 2;
                 if (unlikely(JS_IsUninitialized(var_buf[idx]))) {
-                    JS_ThrowReferenceErrorUninitialized(ctx, JS_ATOM_NULL);
+                    JS_ThrowReferenceErrorUninitialized2(ctx, b, idx, FALSE);
                     goto exception;
                 }
                 set_value(ctx, &var_buf[idx], sp[-1]);
@@ -17294,16 +17327,17 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             sp += 1;
             *sp++ = JS_NewCatchOffset(ctx, 0);
             BREAK;
-        CASE(OP_for_await_of_next):
-            if (js_for_await_of_next(ctx, sp))
-                goto exception;
-            sp += 1;
-            BREAK;
         CASE(OP_iterator_get_value_done):
             if (js_iterator_get_value_done(ctx, sp))
                 goto exception;
             sp += 1;
             BREAK;
+        CASE(OP_iterator_check_object):
+            if (unlikely(!JS_IsObject(sp[-1]))) {
+                JS_ThrowTypeError(ctx, "iterator must return an object");
+                goto exception;
+            }
+            BREAK;
 
         CASE(OP_iterator_close):
             /* iter_obj next catch_offset -> */
@@ -17340,37 +17374,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
 
-        CASE(OP_async_iterator_close):
-            /* iter_obj next catch_offset -> value flag */
-            {
-                JSValue ret, method;
-                int ret_flag;
-                sp--; /* remove the catch offset */
-                method = JS_GetProperty(ctx, sp[-2], JS_ATOM_return);
-                if (JS_IsException(method))
-                    goto exception;
-                if (JS_IsUndefined(method) || JS_IsNull(method)) {
-                    ret = JS_UNDEFINED;
-                    ret_flag = TRUE;
-                } else {
-                    ret = JS_CallFree(ctx, method, sp[-2], 0, NULL);
-                    if (JS_IsException(ret))
-                        goto exception;
-                    if (!JS_IsObject(ret)) {
-                        JS_FreeValue(ctx, ret);
-                        JS_ThrowTypeErrorNotAnObject(ctx);
-                        goto exception;
-                    }
-                    ret_flag = FALSE;
-                }
-                JS_FreeValue(ctx, sp[-2]);
-                JS_FreeValue(ctx, sp[-1]);
-                sp[-2] = ret;
-                sp[-1] = JS_NewBool(ctx, ret_flag);
-            }
-            BREAK;
-
-        CASE(OP_async_iterator_next):
+        CASE(OP_iterator_next):
             /* stack: iter_obj next catch_offset val */
             {
                 JSValue ret;
@@ -17383,26 +17387,28 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
 
-        CASE(OP_async_iterator_get):
+        CASE(OP_iterator_call):
             /* stack: iter_obj next catch_offset val */
             {
                 JSValue method, ret;
                 BOOL ret_flag;
                 int flags;
                 flags = *pc++;
-                /* XXX: use another opcode such as OP_throw_var */
-                if (flags == 2) {
-                    JS_ThrowTypeError(ctx, "iterator does not have a throw method");
-                    goto exception;
-                }
-                method = JS_GetProperty(ctx, sp[-4], flags ? JS_ATOM_throw : JS_ATOM_return);
+                method = JS_GetProperty(ctx, sp[-4], (flags & 1) ?
+                                        JS_ATOM_throw : JS_ATOM_return);
                 if (JS_IsException(method))
                     goto exception;
                 if (JS_IsUndefined(method) || JS_IsNull(method)) {
                     ret_flag = TRUE;
                 } else {
-                    ret = JS_CallFree(ctx, method, sp[-4],
-                                      1, (JSValueConst *)(sp - 1));
+                    if (flags & 2) {
+                        /* no argument */
+                        ret = JS_CallFree(ctx, method, sp[-4],
+                                          0, NULL);
+                    } else {
+                        ret = JS_CallFree(ctx, method, sp[-4],
+                                          1, (JSValueConst *)(sp - 1));
+                    }
                     if (JS_IsException(ret))
                         goto exception;
                     JS_FreeValue(ctx, sp[-1]);
@@ -17728,7 +17734,8 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
         CASE(OP_put_ref_value):
             {
-                int ret;
+                int ret, flags;
+                flags = JS_PROP_THROW_STRICT;
                 if (unlikely(JS_IsUndefined(sp[-3]))) {
                     if (is_strict_mode(ctx)) {
                         JSAtom atom = JS_ValueToAtom(ctx, sp[-2]);
@@ -17740,8 +17747,11 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     } else {
                         sp[-3] = JS_DupValue(ctx, ctx->global_obj);
                     }
+                } else {
+                    if (is_strict_mode(ctx))
+                        flags |= JS_PROP_NO_ADD;
                 }
-                ret = JS_SetPropertyValue(ctx, sp[-3], sp[-2], sp[-1], JS_PROP_THROW_STRICT);
+                ret = JS_SetPropertyValue(ctx, sp[-3], sp[-2], sp[-1], flags);
                 JS_FreeValue(ctx, sp[-3]);
                 sp -= 3;
                 if (unlikely(ret < 0))
@@ -18084,8 +18094,12 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     var_buf[idx] = JS_NewInt32(ctx, val + 1);
                 } else {
                 inc_loc_slow:
-                    if (js_unary_arith_slow(ctx, var_buf + idx + 1, OP_inc))
+                    /* must duplicate otherwise the variable value may
+                       be destroyed before JS code accesses it */
+                    op1 = JS_DupValue(ctx, op1);
+                    if (js_unary_arith_slow(ctx, &op1 + 1, OP_inc))
                         goto exception;
+                    set_value(ctx, &var_buf[idx], op1);
                 }
             }
             BREAK;
@@ -18105,8 +18119,12 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     var_buf[idx] = JS_NewInt32(ctx, val - 1);
                 } else {
                 dec_loc_slow:
-                    if (js_unary_arith_slow(ctx, var_buf + idx + 1, OP_dec))
+                    /* must duplicate otherwise the variable value may
+                       be destroyed before JS code accesses it */
+                    op1 = JS_DupValue(ctx, op1);
+                    if (js_unary_arith_slow(ctx, &op1 + 1, OP_dec))
                         goto exception;
+                    set_value(ctx, &var_buf[idx], op1);
                 }
             }
             BREAK;
@@ -18432,6 +18450,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                         set_value(ctx, &sp[-1], val);
                         break;
                     case OP_with_put_var:
+                        /* XXX: check if strict mode */
                         ret = JS_SetPropertyInternal(ctx, obj, atom, sp[-2],
                                                      JS_PROP_THROW_STRICT);
                         JS_FreeValue(ctx, sp[-1]);
@@ -18922,13 +18941,11 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
     JSGeneratorData *s = JS_GetOpaque(this_val, JS_CLASS_GENERATOR);
     JSStackFrame *sf;
     JSValue ret, func_ret;
-    JSValueConst iter_args[1];
 
     *pdone = TRUE;
     if (!s)
         return JS_ThrowTypeError(ctx, "not a generator");
     sf = &s->func_state.frame;
- redo:
     switch(s->state) {
     default:
     case JS_GENERATOR_STATE_SUSPENDED_START:
@@ -18940,85 +18957,16 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
         }
         break;
     case JS_GENERATOR_STATE_SUSPENDED_YIELD_STAR:
-        {
-            int done;
-            JSValue method, iter_obj;
-
-            iter_obj = sf->cur_sp[-2];
-            if (magic == GEN_MAGIC_NEXT) {
-                method = JS_DupValue(ctx, sf->cur_sp[-1]);
-            } else {
-                method = JS_GetProperty(ctx, iter_obj,
-                                        magic == GEN_MAGIC_RETURN ?
-                                        JS_ATOM_return : JS_ATOM_throw);
-                if (JS_IsException(method))
-                    goto iter_exception;
-            }
-            if (magic != GEN_MAGIC_NEXT &&
-                (JS_IsUndefined(method) || JS_IsNull(method))) {
-                /* default action */
-                if (magic == GEN_MAGIC_RETURN) {
-                    ret = JS_DupValue(ctx, argv[0]);
-                    goto iter_done;
-                } else {
-                    if (JS_IteratorClose(ctx, iter_obj, FALSE))
-                        goto iter_exception;
-                    JS_ThrowTypeError(ctx, "iterator does not have a throw method");
-                    goto iter_exception;
-                }
-            }
-            ret = JS_IteratorNext2(ctx, iter_obj, method, argc, argv, &done);
-            JS_FreeValue(ctx, method);
-            if (JS_IsException(ret)) {
-            iter_exception:
-                goto exec_throw;
-            }
-            /* if not done, the iterator returns the exact object
-               returned by 'method' */
-            if (done == 2) {
-                JSValue done_val, value;
-                done_val = JS_GetProperty(ctx, ret, JS_ATOM_done);
-                if (JS_IsException(done_val)) {
-                    JS_FreeValue(ctx, ret);
-                    goto iter_exception;
-                }
-                done = JS_ToBoolFree(ctx, done_val);
-                if (done) {
-                    value = JS_GetProperty(ctx, ret, JS_ATOM_value);
-                    JS_FreeValue(ctx, ret);
-                    if (JS_IsException(value))
-                        goto iter_exception;
-                    ret = value;
-                    goto iter_done;
-                } else {
-                    *pdone = 2;
-                }
-            } else {
-                if (done) {
-                    /* 'yield *' returns the value associated to done = true */
-                iter_done:
-                    JS_FreeValue(ctx, sf->cur_sp[-2]);
-                    JS_FreeValue(ctx, sf->cur_sp[-1]);
-                    sf->cur_sp--;
-                    goto exec_arg;
-                } else {
-                    *pdone = FALSE;
-                }
-            }
-            break;
-        }
-        break;
     case JS_GENERATOR_STATE_SUSPENDED_YIELD:
         /* cur_sp[-1] was set to JS_UNDEFINED in the previous call */
         ret = JS_DupValue(ctx, argv[0]);
-        if (magic == GEN_MAGIC_THROW) {
+        if (magic == GEN_MAGIC_THROW &&
+            s->state == JS_GENERATOR_STATE_SUSPENDED_YIELD) {
             JS_Throw(ctx, ret);
-        exec_throw:
             s->func_state.throw_flag = TRUE;
         } else {
-        exec_arg:
             sf->cur_sp[-1] = ret;
-            sf->cur_sp[0] = JS_NewBool(ctx, (magic == GEN_MAGIC_RETURN));
+            sf->cur_sp[0] = JS_NewInt32(ctx, magic);
             sf->cur_sp++;
         exec_no_arg:
             s->func_state.throw_flag = FALSE;
@@ -19032,17 +18980,14 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
             return func_ret;
         }
         if (JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT) {
+            /* get the returned yield value at the top of the stack */
+            ret = sf->cur_sp[-1];
+            sf->cur_sp[-1] = JS_UNDEFINED;
             if (JS_VALUE_GET_INT(func_ret) == FUNC_RET_YIELD_STAR) {
-                /* 'yield *' */
                 s->state = JS_GENERATOR_STATE_SUSPENDED_YIELD_STAR;
-                iter_args[0] = JS_UNDEFINED;
-                argc = 1;
-                argv = iter_args;
-                goto redo;
+                /* return (value, done) object */
+                *pdone = 2;
             } else {
-                /* get the return the yield value at the top of the stack */
-                ret = sf->cur_sp[-1];
-                sf->cur_sp[-1] = JS_UNDEFINED;
                 *pdone = FALSE;
             }
         } else {
@@ -19853,15 +19798,15 @@ typedef struct BlockEnv {
     int has_iterator;
 } BlockEnv;
 
-typedef struct JSHoistedDef {
-    int cpool_idx; /* -1 means variable global definition */
-    uint8_t force_init : 1; /* initialize to undefined */
+typedef struct JSGlobalVar {
+    int cpool_idx; /* if >= 0, index in the constant pool for hoisted
+                      function defintion*/
+    uint8_t force_init : 1; /* force initialization to undefined */
     uint8_t is_lexical : 1; /* global let/const definition */
     uint8_t is_const   : 1; /* const definition */
-    int var_idx;   /* function object index if cpool_idx >= 0 */
     int scope_level;    /* scope of definition */
-    JSAtom var_name;  /* variable name if cpool_idx < 0 */
-} JSHoistedDef;
+    JSAtom var_name;  /* variable name */
+} JSGlobalVar;
 
 typedef struct RelocEntry {
     struct RelocEntry *next;
@@ -19924,6 +19869,7 @@ typedef struct JSFunctionDef {
     BOOL has_home_object; /* TRUE if the home object is available */
     BOOL has_prototype; /* true if a prototype field is necessary */
     BOOL has_simple_parameter_list;
+    BOOL has_parameter_expressions; /* if true, an argument scope is created */
     BOOL has_use_strict; /* to reject directive in special cases */
     BOOL has_eval_call; /* true if the function contains a call to eval() */
     BOOL has_arguments_binding; /* true if the 'arguments' binding is
@@ -19951,7 +19897,10 @@ typedef struct JSFunctionDef {
     int arg_count; /* number of arguments */
     int defined_arg_count;
     int var_object_idx; /* -1 if none */
+    int arg_var_object_idx; /* -1 if none (var object for the argument scope) */
     int arguments_var_idx; /* -1 if none */
+    int arguments_arg_idx; /* argument variable definition in argument scope, 
+                              -1 if none */
     int func_var_idx; /* variable containing the current function (-1
                          if none, only used if is_func_expr is true) */
     int eval_ret_idx; /* variable containing the return value of the eval, -1 if none */
@@ -19967,10 +19916,11 @@ typedef struct JSFunctionDef {
     int scope_count;    /* number of entries used in the fd->scopes array */
     JSVarScope *scopes;
     JSVarScope def_scope_array[4];
+    int body_scope; /* scope of the body of the function or eval */
 
-    int hoisted_def_count;
-    int hoisted_def_size;
-    JSHoistedDef *hoisted_def;
+    int global_var_count;
+    int global_var_size;
+    JSGlobalVar *global_vars;
 
     DynBuf byte_code;
     int last_opcode_pos; /* -1 if no last opcode */
@@ -21475,7 +21425,7 @@ static BOOL js_is_live_code(JSParseState *s) {
     case OP_return_undef:
     case OP_return_async:
     case OP_throw:
-    case OP_throw_var:
+    case OP_throw_error:
     case OP_goto:
 #if SHORT_OPCODES
     case OP_goto8:
@@ -21647,6 +21597,21 @@ static int find_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     return find_arg(ctx, fd, name);
 }
 
+/* find a variable declaration in a given scope */
+static int find_var_in_scope(JSContext *ctx, JSFunctionDef *fd,
+                             JSAtom name, int scope_level)
+{
+    int scope_idx;
+    for(scope_idx = fd->scopes[scope_level].first; scope_idx >= 0;
+        scope_idx = fd->vars[scope_idx].scope_next) {
+        if (fd->vars[scope_idx].scope_level != scope_level)
+            break;
+        if (fd->vars[scope_idx].var_name == name)
+            return scope_idx;
+    }
+    return -1;
+}
+
 /* return true if scope == parent_scope or if scope is a child of
    parent_scope */
 static BOOL is_child_scope(JSContext *ctx, JSFunctionDef *fd,
@@ -21668,7 +21633,7 @@ static int find_var_in_child_scope(JSContext *ctx, JSFunctionDef *fd,
     for(i = 0; i < fd->var_count; i++) {
         JSVarDef *vd = &fd->vars[i];
         if (vd->var_name == name && vd->scope_level == 0) {
-            if (is_child_scope(ctx, fd, vd->func_pool_or_scope_idx,
+            if (is_child_scope(ctx, fd, vd->scope_next,
                                scope_level))
                 return i;
         }
@@ -21677,11 +21642,11 @@ static int find_var_in_child_scope(JSContext *ctx, JSFunctionDef *fd,
 }
 
 
-static JSHoistedDef *find_hoisted_def(JSFunctionDef *fd, JSAtom name)
+static JSGlobalVar *find_global_var(JSFunctionDef *fd, JSAtom name)
 {
     int i;
-    for(i = 0; i < fd->hoisted_def_count; i++) {
-        JSHoistedDef *hf = &fd->hoisted_def[i];
+    for(i = 0; i < fd->global_var_count; i++) {
+        JSGlobalVar *hf = &fd->global_vars[i];
         if (hf->var_name == name)
             return hf;
     }
@@ -21689,9 +21654,9 @@ static JSHoistedDef *find_hoisted_def(JSFunctionDef *fd, JSAtom name)
 
 }
 
-static JSHoistedDef *find_lexical_hoisted_def(JSFunctionDef *fd, JSAtom name)
+static JSGlobalVar *find_lexical_global_var(JSFunctionDef *fd, JSAtom name)
 {
-    JSHoistedDef *hf = find_hoisted_def(fd, name);
+    JSGlobalVar *hf = find_global_var(fd, name);
     if (hf && hf->is_lexical)
         return hf;
     else
@@ -21711,7 +21676,7 @@ static int find_lexical_decl(JSContext *ctx, JSFunctionDef *fd, JSAtom name,
     }
 
     if (fd->is_eval && fd->eval_type == JS_EVAL_TYPE_GLOBAL) {
-        if (find_lexical_hoisted_def(fd, name))
+        if (find_lexical_global_var(fd, name))
             return GLOBAL_VAR_OFFSET;
     }
     return -1;
@@ -21800,6 +21765,7 @@ static int add_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     vd = &fd->vars[fd->var_count++];
     memset(vd, 0, sizeof(*vd));
     vd->var_name = JS_DupAtom(ctx, name);
+    vd->func_pool_idx = -1;
     return fd->var_count - 1;
 }
 
@@ -21823,22 +21789,47 @@ static int add_func_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     int idx = fd->func_var_idx;
     if (idx < 0 && (idx = add_var(ctx, fd, name)) >= 0) {
         fd->func_var_idx = idx;
-        fd->vars[idx].is_func_var = TRUE;
+        fd->vars[idx].var_kind = JS_VAR_FUNCTION_NAME;
         if (fd->js_mode & JS_MODE_STRICT)
             fd->vars[idx].is_const = TRUE;
     }
     return idx;
 }
 
-static int add_arguments_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
+static int add_arguments_var(JSContext *ctx, JSFunctionDef *fd)
 {
     int idx = fd->arguments_var_idx;
-    if (idx < 0 && (idx = add_var(ctx, fd, name)) >= 0) {
+    if (idx < 0 && (idx = add_var(ctx, fd, JS_ATOM_arguments)) >= 0) {
         fd->arguments_var_idx = idx;
     }
     return idx;
 }
 
+/* add an argument definition in the argument scope. Only needed when
+   "eval()" may be called in the argument scope. Return 0 if OK. */
+static int add_arguments_arg(JSContext *ctx, JSFunctionDef *fd)
+{
+    int idx;
+    if (fd->arguments_arg_idx < 0) {
+        idx = find_var_in_scope(ctx, fd, JS_ATOM_arguments, ARG_SCOPE_INDEX);
+        if (idx < 0) {
+            /* XXX: the scope links are not fully updated. May be an
+               issue if there are child scopes of the argument
+               scope */
+            idx = add_var(ctx, fd, JS_ATOM_arguments);
+            if (idx < 0)
+                return -1;
+            fd->vars[idx].scope_next = fd->scopes[ARG_SCOPE_INDEX].first;
+            fd->scopes[ARG_SCOPE_INDEX].first = idx;
+            fd->vars[idx].scope_level = ARG_SCOPE_INDEX;
+            fd->vars[idx].is_lexical = TRUE;
+
+            fd->arguments_arg_idx = idx;
+        }
+    }
+    return 0;
+}
+
 static int add_arg(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
 {
     JSVarDef *vd;
@@ -21854,32 +21845,27 @@ static int add_arg(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
     vd = &fd->args[fd->arg_count++];
     memset(vd, 0, sizeof(*vd));
     vd->var_name = JS_DupAtom(ctx, name);
+    vd->func_pool_idx = -1;
     return fd->arg_count - 1;
 }
 
-/* add a Hoisted definition for a function (cpool_idx >= 0) or a
-   global variable (cpool_idx = -1) */
-static JSHoistedDef *add_hoisted_def(JSContext *ctx,
-                                     JSFunctionDef *s, int cpool_idx,
-                                     JSAtom name, int var_idx, BOOL is_lexical)
+/* add a global variable definition */
+static JSGlobalVar *add_global_var(JSContext *ctx, JSFunctionDef *s,
+                                     JSAtom name)
 {
-    JSHoistedDef *hf;
+    JSGlobalVar *hf;
 
-    if (js_resize_array(ctx, (void **)&s->hoisted_def,
-                        sizeof(s->hoisted_def[0]),
-                        &s->hoisted_def_size, s->hoisted_def_count + 1))
+    if (js_resize_array(ctx, (void **)&s->global_vars,
+                        sizeof(s->global_vars[0]),
+                        &s->global_var_size, s->global_var_count + 1))
         return NULL;
-    hf = &s->hoisted_def[s->hoisted_def_count++];
-    hf->cpool_idx = cpool_idx;
-    hf->force_init = 0;
-    hf->is_lexical = is_lexical;
+    hf = &s->global_vars[s->global_var_count++];
+    hf->cpool_idx = -1;
+    hf->force_init = FALSE;
+    hf->is_lexical = FALSE;
     hf->is_const = FALSE;
-    hf->var_idx = var_idx;
     hf->scope_level = s->scope_level;
-    hf->var_name = JS_ATOM_NULL;
-    if (name != JS_ATOM_NULL) {
-        hf->var_name = JS_DupAtom(ctx, name);
-    }
+    hf->var_name = JS_DupAtom(ctx, name);
     return hf;
 }
 
@@ -21924,7 +21910,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
                     goto redef_lex_error;
                 }
             } else {
-                if (fd->scope_level == 1) {
+                if (fd->scope_level == fd->body_scope) {
                 redef_lex_error:
                     /* redefining a scoped var in the same scope: error */
                     return js_parse_error(s, "invalid redefinition of lexical identifier");
@@ -21933,7 +21919,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         }
         if (var_def_type != JS_VAR_DEF_FUNCTION_DECL &&
             var_def_type != JS_VAR_DEF_NEW_FUNCTION_DECL &&
-            fd->scope_level == 1 &&
+            fd->scope_level == fd->body_scope &&
             find_arg(ctx, fd, name) >= 0) {
             /* lexical variable redefines a parameter name */
             return js_parse_error(s, "invalid redefinition of parameter name");
@@ -21944,8 +21930,8 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         }
         
         if (fd->is_global_var) {
-            JSHoistedDef *hf;
-            hf = find_hoisted_def(fd, name);
+            JSGlobalVar *hf;
+            hf = find_global_var(fd, name);
             if (hf && is_child_scope(ctx, fd, hf->scope_level,
                                      fd->scope_level)) {
                 return js_parse_error(s, "invalid redefinition of global identifier");
@@ -21955,11 +21941,12 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         if (fd->is_eval &&
             (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
              fd->eval_type == JS_EVAL_TYPE_MODULE) &&
-            fd->scope_level == 1) {
-            JSHoistedDef *hf;
-            hf = add_hoisted_def(s->ctx, fd, -1, name, -1, TRUE);
+            fd->scope_level == fd->body_scope) {
+            JSGlobalVar *hf;
+            hf = add_global_var(s->ctx, fd, name);
             if (!hf)
                 return -1;
+            hf->is_lexical = TRUE;
             hf->is_const = (var_def_type == JS_VAR_DEF_CONST);
             idx = GLOBAL_VAR_OFFSET;
         } else {
@@ -21991,13 +21978,13 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
             return js_parse_error(s, "invalid redefinition of lexical identifier");
         }
         if (fd->is_global_var) {
-            JSHoistedDef *hf;
-            hf = find_hoisted_def(fd, name);
+            JSGlobalVar *hf;
+            hf = find_global_var(fd, name);
             if (hf && hf->is_lexical && hf->scope_level == fd->scope_level &&
                 fd->eval_type == JS_EVAL_TYPE_MODULE) {
                 goto invalid_lexical_redefinition;
             }
-            hf = add_hoisted_def(s->ctx, fd, -1, name, -1, FALSE);
+            hf = add_global_var(s->ctx, fd, name);
             if (!hf)
                 return -1;
             idx = GLOBAL_VAR_OFFSET;
@@ -22010,7 +21997,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
             if (idx >= 0) {
                 if (name == JS_ATOM_arguments && fd->has_arguments_binding)
                     fd->arguments_var_idx = idx;
-                fd->vars[idx].func_pool_or_scope_idx = fd->scope_level;
+                fd->vars[idx].scope_next = fd->scope_level;
             }
         }
         break;
@@ -22052,8 +22039,9 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                                                int function_line_num,
                                                JSParseExportEnum export_flag,
                                                JSFunctionDef **pfd);
-static __exception int js_parse_assign_expr(JSParseState *s, int in_accepted);
-static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag);
+static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags);
+static __exception int js_parse_assign_expr(JSParseState *s);
+static __exception int js_parse_unary(JSParseState *s, int parse_flags);
 static void push_break_entry(JSFunctionDef *fd, BlockEnv *be,
                              JSAtom label_name,
                              int label_break, int label_cont,
@@ -22385,8 +22373,9 @@ static BOOL is_regexp_allowed(int tok)
     }
 }
 
-#define SKIP_HAS_SEMI      (1 << 0)
-#define SKIP_HAS_ELLIPSIS  (1 << 1)
+#define SKIP_HAS_SEMI       (1 << 0)
+#define SKIP_HAS_ELLIPSIS   (1 << 1)
+#define SKIP_HAS_ASSIGNMENT (1 << 2)
 
 /* XXX: improve speed with early bailout */
 /* XXX: no longer works if regexps are present. Could use previous
@@ -22459,7 +22448,10 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 bits |= SKIP_HAS_ELLIPSIS;
             }
             break;
-
+        case '=':
+            bits |= SKIP_HAS_ASSIGNMENT;
+            break;
+            
         case TOK_DIV_ASSIGN:
             tok_len = 2;
             goto parse_regexp;
@@ -22574,7 +22566,7 @@ static __exception int js_parse_object_literal(JSParseState *s)
         if (s->token.val == TOK_ELLIPSIS) {
             if (next_token(s))
                 return -1;
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 return -1;
             emit_op(s, OP_null);  /* dummy excludeList */
             emit_op(s, OP_copy_data_properties);
@@ -22633,7 +22625,7 @@ static __exception int js_parse_object_literal(JSParseState *s)
         } else {
             if (js_parse_expect(s, ':'))
                 goto fail;
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 goto fail;
             if (name == JS_ATOM_NULL) {
                 set_object_name_computed(s);
@@ -22668,8 +22660,23 @@ static __exception int js_parse_object_literal(JSParseState *s)
     return -1;
 }
 
-static __exception int js_parse_postfix_expr(JSParseState *s,
-                                             BOOL accept_lparen);
+/* allow the 'in' binary operator */
+#define PF_IN_ACCEPTED  (1 << 0) 
+/* allow function calls parsing in js_parse_postfix_expr() */
+#define PF_POSTFIX_CALL (1 << 1) 
+/* allow arrow functions parsing in js_parse_postfix_expr() */
+#define PF_ARROW_FUNC   (1 << 2) 
+/* allow the exponentiation operator in js_parse_unary() */
+#define PF_POW_ALLOWED  (1 << 3) 
+/* forbid the exponentiation operator in js_parse_unary() */
+#define PF_POW_FORBIDDEN (1 << 4) 
+
+static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags);
+
+static __exception int js_parse_left_hand_side_expr(JSParseState *s)
+{
+    return js_parse_postfix_expr(s, PF_POSTFIX_CALL);
+}
 
 /* XXX: is there is nicer solution ? */
 static __exception int js_parse_class_default_ctor(JSParseState *s,
@@ -22873,8 +22880,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         class_flags = JS_DEFINE_CLASS_HAS_HERITAGE;
         if (next_token(s))
             goto fail;
-        /* XXX: the grammar only allows LeftHandSideExpression */
-        if (js_parse_postfix_expr(s, TRUE))
+        if (js_parse_left_hand_side_expr(s))
             goto fail;
     } else {
         emit_op(s, OP_undefined);
@@ -23081,7 +23087,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
             if (s->token.val == '=') {
                 if (next_token(s))
                     goto fail;
-                if (js_parse_assign_expr(s, TRUE))
+                if (js_parse_assign_expr(s))
                     goto fail;
             } else {
                 emit_op(s, OP_undefined);
@@ -23285,7 +23291,7 @@ static __exception int js_parse_array_literal(JSParseState *s)
     while (s->token.val != ']' && idx < 32) {
         if (s->token.val == ',' || s->token.val == TOK_ELLIPSIS)
             break;
-        if (js_parse_assign_expr(s, TRUE))
+        if (js_parse_assign_expr(s))
             return -1;
         idx++;
         /* accept trailing comma */
@@ -23306,7 +23312,7 @@ static __exception int js_parse_array_literal(JSParseState *s)
             break;
         need_length = TRUE;
         if (s->token.val != ',') {
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 return -1;
             emit_op(s, OP_define_field);
             emit_u32(s, __JS_AtomFromUInt32(idx));
@@ -23341,7 +23347,7 @@ static __exception int js_parse_array_literal(JSParseState *s)
         if (s->token.val == TOK_ELLIPSIS) {
             if (next_token(s))
                 return -1;
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 return -1;
 #if 1
             emit_op(s, OP_append);
@@ -23373,7 +23379,7 @@ static __exception int js_parse_array_literal(JSParseState *s)
         } else {
             need_length = TRUE;
             if (s->token.val != ',') {
-                if (js_parse_assign_expr(s, TRUE))
+                if (js_parse_assign_expr(s))
                     return -1;
                 /* a idx val */
                 emit_op(s, OP_define_array_el);
@@ -23781,6 +23787,8 @@ static JSAtom js_parse_destructuring_var(JSParseState *s, int tok, int is_arg)
     return JS_ATOM_NULL;
 }
 
+/* Return -1 if error, 0 if no initializer, 1 if an initializer is
+   present at the top level. */
 static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                                         int hasval, int has_ellipsis,
                                         BOOL allow_initializer)
@@ -23789,7 +23797,8 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
     int start_addr, assign_addr;
     JSAtom prop_name, var_name;
     int opcode, scope, tok1, skip_bits;
-
+    BOOL has_initializer;
+    
     if (has_ellipsis < 0) {
         /* pre-parse destructuration target for spread detection */
         js_parse_skip_parens_token(s, &skip_bits, FALSE);
@@ -23842,7 +23851,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     label_lvalue = -1;
                     depth_lvalue = 0;
                 } else {
-                    if (js_parse_postfix_expr(s, TRUE))
+                    if (js_parse_left_hand_side_expr(s))
                         return -1;
 
                     if (get_lvalue(s, &opcode, &scope, &var_name,
@@ -23898,7 +23907,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                         emit_op(s, OP_get_field2);
                         emit_u32(s, prop_name);
                     }
-                    if (js_parse_destructuring_element(s, tok, is_arg, TRUE, -1, TRUE))
+                    if (js_parse_destructuring_element(s, tok, is_arg, TRUE, -1, TRUE) < 0)
                         return -1;
                     if (s->token.val == '}')
                         break;
@@ -23935,7 +23944,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     if (var_name == JS_ATOM_NULL)
                         goto prop_error;
                 } else {
-                    if (js_parse_postfix_expr(s, TRUE))
+                    if (js_parse_left_hand_side_expr(s))
                         goto prop_error;
                 lvalue:
                     if (get_lvalue(s, &opcode, &scope, &var_name,
@@ -24033,7 +24042,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                 if (next_token(s))
                     goto var_error;
                 emit_op(s, OP_drop);
-                if (js_parse_assign_expr(s, TRUE))
+                if (js_parse_assign_expr(s))
                     goto var_error;
                 if (opcode == OP_scope_get_var || opcode == OP_get_ref_value)
                     set_object_name(s, var_name);
@@ -24097,7 +24106,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     emit_u8(s, 0);
                     emit_op(s, OP_drop);
                 }
-                if (js_parse_destructuring_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
                     return -1;
             } else {
                 var_name = JS_ATOM_NULL;
@@ -24111,7 +24120,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     opcode = OP_scope_get_var;
                     scope = s->cur_func->scope_level;
                 } else {
-                    if (js_parse_postfix_expr(s, TRUE))
+                    if (js_parse_left_hand_side_expr(s))
                         return -1;
                     if (get_lvalue(s, &opcode, &scope, &var_name,
                                    &label_lvalue, &enum_depth, FALSE, '[')) {
@@ -24135,7 +24144,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     if (next_token(s))
                         goto var_error;
                     emit_op(s, OP_drop);
-                    if (js_parse_assign_expr(s, TRUE))
+                    if (js_parse_assign_expr(s))
                         goto var_error;
                     if (opcode == OP_scope_get_var || opcode == OP_get_ref_value)
                         set_object_name(s, var_name);
@@ -24170,10 +24179,11 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
         emit_label(s, label_parse);
         if (hasval)
             emit_op(s, OP_drop);
-        if (js_parse_assign_expr(s, TRUE))
+        if (js_parse_assign_expr(s))
             return -1;
         emit_goto(s, OP_goto, label_assign);
         emit_label(s, label_done);
+        has_initializer = TRUE;
     } else {
         /* normally hasval is true except if
            js_parse_skip_parens_token() was wrong in the parsing */
@@ -24186,8 +24196,9 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
         memset(s->cur_func->byte_code.buf + start_addr, OP_nop,
                assign_addr - start_addr);
         s->cur_func->label_slots[label_parse].ref_count--;
+        has_initializer = FALSE;
     }
-    return 0;
+    return has_initializer;
 
  prop_error:
     JS_FreeAtom(s->ctx, prop_name);
@@ -24220,10 +24231,12 @@ static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
     emit_label(s, label_next);
 }
 
-static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen)
+/* allowed parse_flags: PF_POSTFIX_CALL, PF_ARROW_FUNC */
+static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
 {
     FuncCallType call_type;
     int optional_chaining_label;
+    BOOL accept_lparen = (parse_flags & PF_POSTFIX_CALL) != 0;
     
     call_type = FUNC_CALL_NORMAL;
     switch(s->token.val) {
@@ -24321,7 +24334,8 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         }
         break;
     case '(':
-        if (js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) {
+        if ((parse_flags & PF_ARROW_FUNC) &&
+            js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) {
             if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
                                        JS_FUNC_NORMAL, JS_ATOM_NULL,
                                        s->token.ptr, s->token.line_num))
@@ -24369,7 +24383,8 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             if (s->token.u.ident.is_reserved) {
                 return js_parse_error_reserved_identifier(s);
             }
-            if (peek_token(s, TRUE) == TOK_ARROW) {
+            if ((parse_flags & PF_ARROW_FUNC) &&
+                peek_token(s, TRUE) == TOK_ARROW) {
                 if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
                                            JS_FUNC_NORMAL, JS_ATOM_NULL,
                                            s->token.ptr, s->token.line_num))
@@ -24388,10 +24403,11 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                                                JS_FUNC_ASYNC, JS_ATOM_NULL,
                                                source_ptr, source_line_num))
                         return -1;
-                } else if ((s->token.val == '(' &&
-                            js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) ||
-                           (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved &&
-                            peek_token(s, TRUE) == TOK_ARROW)) {
+                } else if ((parse_flags & PF_ARROW_FUNC) &&
+                           ((s->token.val == '(' &&
+                             js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) ||
+                            (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved &&
+                             peek_token(s, TRUE) == TOK_ARROW))) {
                     if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
                                                JS_FUNC_ASYNC, JS_ATOM_NULL,
                                                source_ptr, source_line_num))
@@ -24421,7 +24437,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         {
             int skip_bits;
             if (js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
-                if (js_parse_destructuring_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
                     return -1;
             } else {
                 if (s->token.val == '{') {
@@ -24450,7 +24466,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
             emit_atom(s, JS_ATOM_new_target);
             emit_u16(s, 0);
         } else {
-            if (js_parse_postfix_expr(s, FALSE))
+            if (js_parse_postfix_expr(s, 0))
                 return -1;
             accept_lparen = TRUE;
             if (s->token.val != '(') {
@@ -24503,7 +24519,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 return -1;
             if (!accept_lparen)
                 return js_parse_error(s, "invalid use of 'import()'");
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 return -1;
             if (js_parse_expect(s, ')'))
                 return -1;
@@ -24636,7 +24652,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                 }
                 if (s->token.val == TOK_ELLIPSIS)
                     break;
-                if (js_parse_assign_expr(s, TRUE))
+                if (js_parse_assign_expr(s))
                     return -1;
                 arg_count++;
                 if (s->token.val == ')')
@@ -24656,7 +24672,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                     if (s->token.val == TOK_ELLIPSIS) {
                         if (next_token(s))
                             return -1;
-                        if (js_parse_assign_expr(s, TRUE))
+                        if (js_parse_assign_expr(s))
                             return -1;
 #if 1
                         /* XXX: could pass is_last indicator? */
@@ -24687,7 +24703,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
                         emit_op(s, OP_nip1);
 #endif
                     } else {
-                        if (js_parse_assign_expr(s, TRUE))
+                        if (js_parse_assign_expr(s))
                             return -1;
                         /* array idx val */
                         emit_op(s, OP_define_array_el);
@@ -24789,16 +24805,19 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         } else if (s->token.val == '.') {
             if (next_token(s))
                 return -1;
+        parse_property:
             if (s->token.val == TOK_PRIVATE_NAME) {
                 /* private class field */
                 if (get_prev_opcode(fd) == OP_get_super) {
                     return js_parse_error(s, "private class field forbidden after super");
                 }
+                if (has_optional_chain) {
+                    optional_chain_test(s, &optional_chaining_label, 1);
+                }
                 emit_op(s, OP_scope_get_private_field);
                 emit_atom(s, s->token.u.ident.atom);
                 emit_u16(s, s->cur_func->scope_level);
             } else {
-            parse_property:
                 if (!token_is_ident(s->token.val)) {
                     return js_parse_error(s, "expecting field name");
                 }
@@ -24857,7 +24876,7 @@ static __exception int js_parse_delete(JSParseState *s)
 
     if (next_token(s))
         return -1;
-    if (js_parse_unary(s, -1))
+    if (js_parse_unary(s, PF_POW_FORBIDDEN))
         return -1;
     switch(opcode = get_prev_opcode(fd)) {
     case OP_get_field:
@@ -24896,9 +24915,9 @@ static __exception int js_parse_delete(JSParseState *s)
     case OP_scope_get_private_field:
         return js_parse_error(s, "cannot delete a private class field");
     case OP_get_super_value:
-        emit_op(s, OP_throw_var);
+        emit_op(s, OP_throw_error);
         emit_atom(s, JS_ATOM_NULL);
-        emit_u8(s, JS_THROW_VAR_DELETE_SUPER);
+        emit_u8(s, JS_THROW_ERROR_DELETE_SUPER);
         break;
     default:
     ret_true:
@@ -24909,7 +24928,8 @@ static __exception int js_parse_delete(JSParseState *s)
     return 0;
 }
 
-static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
+/* allowed parse_flags: PF_ARROW_FUNC, PF_POW_ALLOWED, PF_POW_FORBIDDEN */
+static __exception int js_parse_unary(JSParseState *s, int parse_flags)
 {
     int op;
 
@@ -24922,7 +24942,7 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
         op = s->token.val;
         if (next_token(s))
             return -1;
-        if (js_parse_unary(s, -1))
+        if (js_parse_unary(s, PF_POW_FORBIDDEN))
             return -1;
         switch(op) {
         case '-':
@@ -24944,7 +24964,7 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
         default:
             abort();
         }
-        exponentiation_flag = 0;
+        parse_flags = 0;
         break;
     case TOK_DEC:
     case TOK_INC:
@@ -24954,7 +24974,6 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             op = s->token.val;
             if (next_token(s))
                 return -1;
-            /* XXX: should parse LeftHandSideExpression */
             if (js_parse_unary(s, 0))
                 return -1;
             if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
@@ -24969,7 +24988,7 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             JSFunctionDef *fd;
             if (next_token(s))
                 return -1;
-            if (js_parse_unary(s, -1))
+            if (js_parse_unary(s, PF_POW_FORBIDDEN))
                 return -1;
             /* reference access should not return an exception, so we
                patch the get_var */
@@ -24978,13 +24997,13 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
                 fd->byte_code.buf[fd->last_opcode_pos] = OP_scope_get_var_undef;
             }
             emit_op(s, OP_typeof);
-            exponentiation_flag = 0;
+            parse_flags = 0;
         }
         break;
     case TOK_DELETE:
         if (js_parse_delete(s))
             return -1;
-        exponentiation_flag = 0;
+        parse_flags = 0;
         break;
     case TOK_AWAIT:
         if (!(s->cur_func->func_kind & JS_FUNC_ASYNC))
@@ -24993,13 +25012,14 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             return js_parse_error(s, "await in default expression");
         if (next_token(s))
             return -1;
-        if (js_parse_unary(s, -1))
+        if (js_parse_unary(s, PF_POW_FORBIDDEN))
             return -1;
         emit_op(s, OP_await);
-        exponentiation_flag = 0;
+        parse_flags = 0;
         break;
     default:
-        if (js_parse_postfix_expr(s, TRUE))
+        if (js_parse_postfix_expr(s, (parse_flags & PF_ARROW_FUNC) |
+                                  PF_POSTFIX_CALL))
             return -1;
         if (!s->got_lf &&
             (s->token.val == TOK_DEC || s->token.val == TOK_INC)) {
@@ -25016,21 +25036,21 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
         }
         break;
     }
-    if (exponentiation_flag) {
+    if (parse_flags & (PF_POW_ALLOWED | PF_POW_FORBIDDEN)) {
 #ifdef CONFIG_BIGNUM
         if (s->token.val == TOK_POW || s->token.val == TOK_MATH_POW) {
             /* Extended exponentiation syntax rules: we extend the ES7
                grammar in order to have more intuitive semantics:
                -2**2 evaluates to -4. */
             if (!(s->cur_func->js_mode & JS_MODE_MATH)) {
-                if (exponentiation_flag < 0) {
+                if (parse_flags & PF_POW_FORBIDDEN) {
                     JS_ThrowSyntaxError(s->ctx, "unparenthesized unary expression can't appear on the left-hand side of '**'");
                     return -1;
                 }
             }
             if (next_token(s))
                 return -1;
-            if (js_parse_unary(s, 1))
+            if (js_parse_unary(s, PF_POW_ALLOWED))
                 return -1;
             emit_op(s, OP_pow);
         }
@@ -25041,13 +25061,13 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
                regarding the precedence of prefix operators and the
                postifx exponential, ES7 specifies that -2**2 is a
                syntax error. */
-            if (exponentiation_flag < 0) {
+            if (parse_flags & PF_POW_FORBIDDEN) {
                 JS_ThrowSyntaxError(s->ctx, "unparenthesized unary expression can't appear on the left-hand side of '**'");
                 return -1;
             }
             if (next_token(s))
                 return -1;
-            if (js_parse_unary(s, 1))
+            if (js_parse_unary(s, PF_POW_ALLOWED))
                 return -1;
             emit_op(s, OP_pow);
         }
@@ -25056,15 +25076,17 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
     return 0;
 }
 
+/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
 static __exception int js_parse_expr_binary(JSParseState *s, int level,
-                                            BOOL in_accepted)
+                                            int parse_flags)
 {
     int op, opcode;
 
     if (level == 0) {
-        return js_parse_unary(s, 1);
+        return js_parse_unary(s, (parse_flags & PF_ARROW_FUNC) |
+                              PF_POW_ALLOWED);
     }
-    if (js_parse_expr_binary(s, level - 1, in_accepted))
+    if (js_parse_expr_binary(s, level - 1, parse_flags))
         return -1;
     for(;;) {
         op = s->token.val;
@@ -25134,7 +25156,7 @@ static __exception int js_parse_expr_binary(JSParseState *s, int level,
                 opcode = OP_instanceof;
                 break;
             case TOK_IN:
-                if (in_accepted) {
+                if (parse_flags & PF_IN_ACCEPTED) {
                     opcode = OP_in;
                 } else {
                     return 0;
@@ -25194,23 +25216,24 @@ static __exception int js_parse_expr_binary(JSParseState *s, int level,
         }
         if (next_token(s))
             return -1;
-        if (js_parse_expr_binary(s, level - 1, in_accepted))
+        if (js_parse_expr_binary(s, level - 1, parse_flags & ~PF_ARROW_FUNC))
             return -1;
         emit_op(s, opcode);
     }
     return 0;
 }
 
+/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
 static __exception int js_parse_logical_and_or(JSParseState *s, int op,
-                                               BOOL in_accepted)
+                                               int parse_flags)
 {
     int label1;
 
     if (op == TOK_LAND) {
-        if (js_parse_expr_binary(s, 8, in_accepted))
+        if (js_parse_expr_binary(s, 8, parse_flags))
             return -1;
     } else {
-        if (js_parse_logical_and_or(s, TOK_LAND, in_accepted))
+        if (js_parse_logical_and_or(s, TOK_LAND, parse_flags))
             return -1;
     }
     if (s->token.val == op) {
@@ -25224,10 +25247,11 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
             emit_op(s, OP_drop);
 
             if (op == TOK_LAND) {
-                if (js_parse_expr_binary(s, 8, in_accepted))
+                if (js_parse_expr_binary(s, 8, parse_flags & ~PF_ARROW_FUNC))
                     return -1;
             } else {
-                if (js_parse_logical_and_or(s, TOK_LAND, in_accepted))
+                if (js_parse_logical_and_or(s, TOK_LAND,
+                                            parse_flags & ~PF_ARROW_FUNC))
                     return -1;
             }
             if (s->token.val != op) {
@@ -25242,11 +25266,11 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
     return 0;
 }
 
-static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
+static __exception int js_parse_coalesce_expr(JSParseState *s, int parse_flags)
 {
     int label1;
     
-    if (js_parse_logical_and_or(s, TOK_LOR, in_accepted))
+    if (js_parse_logical_and_or(s, TOK_LOR, parse_flags))
         return -1;
     if (s->token.val == TOK_DOUBLE_QUESTION_MARK) {
         label1 = new_label(s);
@@ -25259,7 +25283,7 @@ static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
             emit_goto(s, OP_if_false, label1);
             emit_op(s, OP_drop);
             
-            if (js_parse_expr_binary(s, 8, in_accepted))
+            if (js_parse_expr_binary(s, 8, parse_flags & ~PF_ARROW_FUNC))
                 return -1;
             if (s->token.val != TOK_DOUBLE_QUESTION_MARK)
                 break;
@@ -25269,18 +25293,19 @@ static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
     return 0;
 }
 
-static __exception int js_parse_cond_expr(JSParseState *s, BOOL in_accepted)
+/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
+static __exception int js_parse_cond_expr(JSParseState *s, int parse_flags)
 {
     int label1, label2;
 
-    if (js_parse_coalesce_expr(s, in_accepted))
+    if (js_parse_coalesce_expr(s, parse_flags))
         return -1;
     if (s->token.val == '?') {
         if (next_token(s))
             return -1;
         label1 = emit_goto(s, OP_if_false, -1);
 
-        if (js_parse_assign_expr(s, TRUE))
+        if (js_parse_assign_expr(s))
             return -1;
         if (js_parse_expect(s, ':'))
             return -1;
@@ -25289,7 +25314,7 @@ static __exception int js_parse_cond_expr(JSParseState *s, BOOL in_accepted)
 
         emit_label(s, label1);
 
-        if (js_parse_assign_expr(s, in_accepted))
+        if (js_parse_assign_expr2(s, parse_flags & PF_IN_ACCEPTED))
             return -1;
 
         emit_label(s, label2);
@@ -25299,14 +25324,16 @@ static __exception int js_parse_cond_expr(JSParseState *s, BOOL in_accepted)
 
 static void emit_return(JSParseState *s, BOOL hasval);
 
-static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
+/* allowed parse_flags: PF_IN_ACCEPTED */
+static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
 {
     int opcode, op, scope;
     JSAtom name0 = JS_ATOM_NULL;
     JSAtom name;
 
     if (s->token.val == TOK_YIELD) {
-        BOOL is_star = FALSE;
+        BOOL is_star = FALSE, is_async;
+        
         if (!(s->cur_func->func_kind & JS_FUNC_GENERATOR))
             return js_parse_error(s, "unexpected 'yield' keyword");
         if (!s->cur_func->in_function_body)
@@ -25323,109 +25350,120 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                 if (next_token(s))
                     return -1;
             }
-            if (js_parse_assign_expr(s, in_accepted))
+            if (js_parse_assign_expr2(s, parse_flags))
                 return -1;
         } else {
             emit_op(s, OP_undefined);
         }
-        if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
+        is_async = (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR);
+
+        if (is_star) {
             int label_loop, label_return, label_next;
             int label_return1, label_yield, label_throw, label_throw1;
             int label_throw2;
 
-            if (is_star) {
-                label_loop = new_label(s);
-                label_yield = new_label(s);
-
-                emit_op(s, OP_for_await_of_start);
+            label_loop = new_label(s);
+            label_yield = new_label(s);
 
-                /* remove the catch offset (XXX: could avoid pushing back
-                   undefined) */
-                emit_op(s, OP_drop);
-                emit_op(s, OP_undefined);
+            emit_op(s, is_async ? OP_for_await_of_start : OP_for_of_start);
 
-                emit_op(s, OP_undefined); /* initial value */
-
-                emit_label(s, label_loop);
-                emit_op(s, OP_async_iterator_next);
+            /* remove the catch offset (XXX: could avoid pushing back
+               undefined) */
+            emit_op(s, OP_drop);
+            emit_op(s, OP_undefined);
+            
+            emit_op(s, OP_undefined); /* initial value */
+            
+            emit_label(s, label_loop);
+            emit_op(s, OP_iterator_next);
+            if (is_async)
                 emit_op(s, OP_await);
-                emit_op(s, OP_iterator_get_value_done);
-                label_next = emit_goto(s, OP_if_true, -1); /* end of loop */
+            emit_op(s, OP_iterator_check_object);
+            emit_op(s, OP_get_field2);
+            emit_atom(s, JS_ATOM_done);
+            label_next = emit_goto(s, OP_if_true, -1); /* end of loop */
+            emit_label(s, label_yield);
+            if (is_async) {
+                /* OP_async_yield_star takes the value as parameter */
+                emit_op(s, OP_get_field);
+                emit_atom(s, JS_ATOM_value);
                 emit_op(s, OP_await);
-                emit_label(s, label_yield);
                 emit_op(s, OP_async_yield_star);
-                emit_op(s, OP_dup);
-                label_return = emit_goto(s, OP_if_true, -1);
-                emit_op(s, OP_drop);
-                emit_goto(s, OP_goto, label_loop);
-
-                emit_label(s, label_return);
-                emit_op(s, OP_push_i32);
-                emit_u32(s, 2);
-                emit_op(s, OP_strict_eq);
-                label_throw = emit_goto(s, OP_if_true, -1);
-
-                /* return handling */
-                emit_op(s, OP_await);
-                emit_op(s, OP_async_iterator_get);
-                emit_u8(s, 0);
-                label_return1 = emit_goto(s, OP_if_true, -1);
+            } else {
+                /* OP_yield_star takes (value, done) as parameter */
+                emit_op(s, OP_yield_star);
+            }
+            emit_op(s, OP_dup);
+            label_return = emit_goto(s, OP_if_true, -1);
+            emit_op(s, OP_drop);
+            emit_goto(s, OP_goto, label_loop);
+            
+            emit_label(s, label_return);
+            emit_op(s, OP_push_i32);
+            emit_u32(s, 2);
+            emit_op(s, OP_strict_eq);
+            label_throw = emit_goto(s, OP_if_true, -1);
+            
+            /* return handling */
+            if (is_async)
                 emit_op(s, OP_await);
-                emit_op(s, OP_iterator_get_value_done);
-                /* XXX: the spec does not indicate that an await should be
-                   performed in case done = true, but the tests assume it */
-                emit_goto(s, OP_if_false, label_yield);
-
-                emit_label(s, label_return1);
-                emit_op(s, OP_nip);
-                emit_op(s, OP_nip);
-                emit_op(s, OP_nip);
-                emit_return(s, TRUE);
-
-                /* throw handling */
-                emit_label(s, label_throw);
-                emit_op(s, OP_async_iterator_get);
-                emit_u8(s, 1);
-                label_throw1 = emit_goto(s, OP_if_true, -1);
+            emit_op(s, OP_iterator_call);
+            emit_u8(s, 0);
+            label_return1 = emit_goto(s, OP_if_true, -1);
+            if (is_async)
                 emit_op(s, OP_await);
-                emit_op(s, OP_iterator_get_value_done);
-                emit_goto(s, OP_if_false, label_yield);
-                /* XXX: the spec does not indicate that an await should be
-                   performed in case done = true, but the tests assume it */
+            emit_op(s, OP_iterator_check_object);
+            emit_op(s, OP_get_field2);
+            emit_atom(s, JS_ATOM_done);
+            emit_goto(s, OP_if_false, label_yield);
+
+            emit_op(s, OP_get_field);
+            emit_atom(s, JS_ATOM_value);
+            
+            emit_label(s, label_return1);
+            emit_op(s, OP_nip);
+            emit_op(s, OP_nip);
+            emit_op(s, OP_nip);
+            emit_return(s, TRUE);
+            
+            /* throw handling */
+            emit_label(s, label_throw);
+            emit_op(s, OP_iterator_call);
+            emit_u8(s, 1);
+            label_throw1 = emit_goto(s, OP_if_true, -1);
+            if (is_async)
                 emit_op(s, OP_await);
-                emit_goto(s, OP_goto, label_next);
-                /* close the iterator and throw a type error exception */
-                emit_label(s, label_throw1);
-                emit_op(s, OP_async_iterator_get);
-                emit_u8(s, 0);
-                label_throw2 = emit_goto(s, OP_if_true, -1);
+            emit_op(s, OP_iterator_check_object);
+            emit_op(s, OP_get_field2);
+            emit_atom(s, JS_ATOM_done);
+            emit_goto(s, OP_if_false, label_yield);
+            emit_goto(s, OP_goto, label_next);
+            /* close the iterator and throw a type error exception */
+            emit_label(s, label_throw1);
+            emit_op(s, OP_iterator_call);
+            emit_u8(s, 2);
+            label_throw2 = emit_goto(s, OP_if_true, -1);
+            if (is_async)
                 emit_op(s, OP_await);
-                emit_label(s, label_throw2);
-                emit_op(s, OP_async_iterator_get);
-                emit_u8(s, 2); /* throw the type error exception */
-                emit_op(s, OP_drop); /* never reached */
+            emit_label(s, label_throw2);
 
-                emit_label(s, label_next);
-                emit_op(s, OP_nip); /* keep the value associated with
-                                       done = true */
-                emit_op(s, OP_nip);
-                emit_op(s, OP_nip);
-            } else {
-                emit_op(s, OP_await);
-                emit_op(s, OP_yield);
-                label_next = emit_goto(s, OP_if_false, -1);
-                emit_return(s, TRUE);
-                emit_label(s, label_next);
-            }
+            emit_op(s, OP_throw_error);
+            emit_atom(s, JS_ATOM_NULL);
+            emit_u8(s, JS_THROW_ERROR_ITERATOR_THROW);
+            
+            emit_label(s, label_next);
+            emit_op(s, OP_get_field);
+            emit_atom(s, JS_ATOM_value);
+            emit_op(s, OP_nip); /* keep the value associated with
+                                   done = true */
+            emit_op(s, OP_nip);
+            emit_op(s, OP_nip);
         } else {
             int label_next;
-            if (is_star) {
-                emit_op(s, OP_for_of_start);
-                emit_op(s, OP_drop);    /* drop the catch offset */
-                emit_op(s, OP_yield_star);
-            } else {
-                emit_op(s, OP_yield);
-            }
+            
+            if (is_async)
+                emit_op(s, OP_await);
+            emit_op(s, OP_yield);
             label_next = emit_goto(s, OP_if_false, -1);
             emit_return(s, TRUE);
             emit_label(s, label_next);
@@ -25436,7 +25474,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         /* name0 is used to check for OP_set_name pattern, not duplicated */
         name0 = s->token.u.ident.atom;
     }
-    if (js_parse_cond_expr(s, in_accepted))
+    if (js_parse_cond_expr(s, parse_flags | PF_ARROW_FUNC))
         return -1;
 
     op = s->token.val;
@@ -25447,7 +25485,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, (op != '='), op) < 0)
             return -1;
 
-        if (js_parse_assign_expr(s, in_accepted)) {
+        if (js_parse_assign_expr2(s, parse_flags)) {
             JS_FreeAtom(s->ctx, name);
             return -1;
         }
@@ -25491,7 +25529,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
                            -1);
         emit_op(s, OP_drop);
         
-        if (js_parse_assign_expr(s, in_accepted)) {
+        if (js_parse_assign_expr2(s, parse_flags)) {
             JS_FreeAtom(s->ctx, name);
             return -1;
         }
@@ -25533,11 +25571,17 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
     return 0;
 }
 
-static __exception int js_parse_expr2(JSParseState *s, BOOL in_accepted)
+static __exception int js_parse_assign_expr(JSParseState *s)
+{
+    return js_parse_assign_expr2(s, PF_IN_ACCEPTED);
+}
+
+/* allowed parse_flags: PF_IN_ACCEPTED */
+static __exception int js_parse_expr2(JSParseState *s, int parse_flags)
 {
     BOOL comma = FALSE;
     for(;;) {
-        if (js_parse_assign_expr(s, in_accepted))
+        if (js_parse_assign_expr2(s, parse_flags))
             return -1;
         if (comma) {
             /* prevent get_lvalue from using the last expression
@@ -25559,7 +25603,7 @@ static __exception int js_parse_expr2(JSParseState *s, BOOL in_accepted)
 
 static __exception int js_parse_expr(JSParseState *s)
 {
-    return js_parse_expr2(s, TRUE);
+    return js_parse_expr2(s, PF_IN_ACCEPTED);
 }
 
 static void push_break_entry(JSFunctionDef *fd, BlockEnv *be,
@@ -25655,12 +25699,25 @@ static void emit_return(JSParseState *s, BOOL hasval)
             }
             emit_op(s, OP_iterator_close_return);
             if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
-                int label_next;
-                emit_op(s, OP_async_iterator_close);
+                int label_next, label_next2;
+
+                emit_op(s, OP_drop); /* catch offset */
+                emit_op(s, OP_drop); /* next */
+                emit_op(s, OP_get_field2);
+                emit_atom(s, JS_ATOM_return);
+                /* stack: iter_obj return_func */
+                emit_op(s, OP_dup);
+                emit_op(s, OP_is_undefined_or_null);
                 label_next = emit_goto(s, OP_if_true, -1);
+                emit_op(s, OP_call_method);
+                emit_u16(s, 0);
+                emit_op(s, OP_iterator_check_object);
                 emit_op(s, OP_await);
+                label_next2 = emit_goto(s, OP_goto, -1);
                 emit_label(s, label_next);
                 emit_op(s, OP_drop);
+                emit_label(s, label_next2);
+                emit_op(s, OP_drop);
             } else {
                 emit_op(s, OP_iterator_close);
             }
@@ -25748,7 +25805,8 @@ static __exception int js_parse_block(JSParseState *s)
     return 0;
 }
 
-static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
+/* allowed parse_flags: PF_IN_ACCEPTED */
+static __exception int js_parse_var(JSParseState *s, int parse_flags, int tok,
                                     BOOL export_flag)
 {
     JSContext *ctx = s->ctx;
@@ -25788,7 +25846,7 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
                     emit_u16(s, fd->scope_level);
                     if (get_lvalue(s, &opcode, &scope, &name1, &label, NULL, FALSE, '=') < 0)
                         goto var_error;
-                    if (js_parse_assign_expr(s, in_accepted)) {
+                    if (js_parse_assign_expr2(s, parse_flags)) {
                         JS_FreeAtom(ctx, name1);
                         goto var_error;
                     }
@@ -25796,7 +25854,7 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
                     put_lvalue(s, opcode, scope, name1, label,
                                PUT_LVALUE_NOKEEP, FALSE);
                 } else {
-                    if (js_parse_assign_expr(s, in_accepted))
+                    if (js_parse_assign_expr2(s, parse_flags))
                         goto var_error;
                     set_object_name(s, name);
                     emit_op(s, (tok == TOK_CONST || tok == TOK_LET) ?
@@ -25823,7 +25881,7 @@ static __exception int js_parse_var(JSParseState *s, BOOL in_accepted, int tok,
             if ((s->token.val == '[' || s->token.val == '{')
             &&  js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
                 emit_op(s, OP_undefined);
-                if (js_parse_destructuring_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
                     return -1;
             } else {
                 return js_parse_error(s, "variable name expected");
@@ -25952,7 +26010,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
 
         if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
             if (s->token.val == '[' || s->token.val == '{') {
-                if (js_parse_destructuring_element(s, tok, 0, TRUE, -1, FALSE))
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, -1, FALSE) < 0)
                     return -1;
                 has_destructuring = TRUE;
             } else {
@@ -25978,11 +26036,11 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
         int skip_bits;
         if ((s->token.val == '[' || s->token.val == '{')
         &&  ((tok1 = js_parse_skip_parens_token(s, &skip_bits, FALSE)) == TOK_IN || tok1 == TOK_OF)) {
-            if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE))
+            if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
                 return -1;
         } else {
             int lvalue_label;
-            if (js_parse_postfix_expr(s, TRUE))
+            if (js_parse_left_hand_side_expr(s))
                 return -1;
             if (get_lvalue(s, &opcode, &scope, &var_name, &lvalue_label,
                            NULL, FALSE, TOK_FOR))
@@ -26002,7 +26060,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
         /* parse and evaluate initializer prior to evaluating the
            object (only used with "for in" with a non lexical variable
            in non strict mode */
-        if (next_token(s) || js_parse_assign_expr(s, FALSE)) {
+        if (next_token(s) || js_parse_assign_expr2(s, 0)) {
             JS_FreeAtom(ctx, var_name);
             return -1;
         }
@@ -26035,7 +26093,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
     if (next_token(s))
         return -1;
     if (is_for_of) {
-        if (js_parse_assign_expr(s, TRUE))
+        if (js_parse_assign_expr(s))
             return -1;
     } else {
         if (js_parse_expr(s))
@@ -26088,7 +26146,11 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
     if (is_for_of) {
         if (is_async) {
             /* call the next method */
-            emit_op(s, OP_for_await_of_next);
+            /* stack: iter_obj next catch_offset */
+            emit_op(s, OP_dup3);
+            emit_op(s, OP_drop);
+            emit_op(s, OP_call_method);
+            emit_u16(s, 0);
             /* get the result of the promise */
             emit_op(s, OP_await);
             /* unwrap the value and done values */
@@ -26646,7 +26708,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                     if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
                         if (s->token.val == '[' || s->token.val == '{') {
                             /* XXX: TOK_LET is not completely correct */
-                            if (js_parse_destructuring_element(s, TOK_LET, 0, TRUE, -1, TRUE))
+                            if (js_parse_destructuring_element(s, TOK_LET, 0, TRUE, -1, TRUE) < 0)
                                 goto fail;
                         } else {
                             js_parse_error(s, "identifier expected");
@@ -26712,18 +26774,37 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
             }
             emit_label(s, label_finally);
             if (s->token.val == TOK_FINALLY) {
-                int saved_eval_ret_idx;
+                int saved_eval_ret_idx = 0; /* avoid warning */
+                
                 if (next_token(s))
                     goto fail;
                 /* on the stack: ret_value gosub_ret_value */
                 push_break_entry(s->cur_func, &block_env, JS_ATOM_NULL,
                                  -1, -1, 2);
-                saved_eval_ret_idx = s->cur_func->eval_ret_idx;
-                s->cur_func->eval_ret_idx = -1;
-                /* 'finally' does not update eval_ret */
+
+                if (s->cur_func->eval_ret_idx >= 0) {
+                    /* 'finally' updates eval_ret only if not a normal
+                       termination */
+                    saved_eval_ret_idx =
+                        add_var(s->ctx, s->cur_func, JS_ATOM__ret_);
+                    if (saved_eval_ret_idx < 0)
+                        goto fail;
+                    emit_op(s, OP_get_loc);
+                    emit_u16(s, s->cur_func->eval_ret_idx);
+                    emit_op(s, OP_put_loc);
+                    emit_u16(s, saved_eval_ret_idx);
+                    set_eval_ret_undefined(s);
+                }
+                
                 if (js_parse_block(s))
                     goto fail;
-                s->cur_func->eval_ret_idx = saved_eval_ret_idx;
+
+                if (s->cur_func->eval_ret_idx >= 0) {
+                    emit_op(s, OP_get_loc);
+                    emit_u16(s, saved_eval_ret_idx);
+                    emit_op(s, OP_put_loc);
+                    emit_u16(s, s->cur_func->eval_ret_idx);
+                }
                 pop_break_entry(s->cur_func);
             }
             emit_op(s, OP_ret);
@@ -27511,19 +27592,11 @@ static int exported_names_cmp(const void *p1, const void *p2, void *opaque)
 
 static JSValue js_get_module_ns(JSContext *ctx, JSModuleDef *m);
 
-static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
-                                 void *opaque)
+static JSValue js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
+                                     void *opaque)
 {
     JSModuleDef *m = opaque;
-    JSValue val, this_val = JS_MKPTR(JS_TAG_OBJECT, p);
-    
-    val = js_get_module_ns(ctx, m);
-    if (JS_IsException(val))
-        return -1;
-    if (JS_DefinePropertyValue(ctx, this_val, atom, val,
-                               JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
-        return -1;
-    return 0;
+    return js_get_module_ns(ctx, m);
 }
 
 static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
@@ -27741,7 +27814,7 @@ static int js_create_module_bytecode_function(JSContext *ctx, JSModuleDef *m)
     return -1;
 }
 
-/* must be done before js_instantiate_module() because of cyclic references */
+/* must be done before js_link_module() because of cyclic references */
 static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
 {
     BOOL is_c_module;
@@ -27784,7 +27857,7 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     
 /* Prepare a module to be executed by resolving all the imported
    variables. */
-static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
+static int js_link_module(JSContext *ctx, JSModuleDef *m)
 {
     int i;
     JSImportEntry *mi;
@@ -27792,7 +27865,8 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
     JSVarRef **var_refs, *var_ref;
     JSObject *p;
     BOOL is_c_module;
-
+    JSValue ret_val;
+    
     if (m->instantiated)
         return 0;
     m->instantiated = TRUE;
@@ -27806,7 +27880,7 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
 
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        if (js_instantiate_module(ctx, rme->module) < 0)
+        if (js_link_module(ctx, rme->module) < 0)
             goto fail;
     }
 
@@ -27925,6 +27999,12 @@ static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
                 me->u.local.var_ref = var_ref;
             }
         }
+
+        /* initialize the global variables */
+        ret_val = JS_Call(ctx, m->func_obj, JS_TRUE, 0, NULL);
+        if (JS_IsException(ret_val))
+            goto fail;
+        JS_FreeValue(ctx, ret_val);
     }
 
 #ifdef DUMP_MODULE_RESOLVE
@@ -28324,7 +28404,7 @@ static __exception int js_parse_export(JSParseState *s)
                                            s->token.ptr, s->token.line_num,
                                            JS_PARSE_EXPORT_DEFAULT, NULL);
         } else {
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 return -1;
         }
         /* set the name of anonymous functions */
@@ -28567,7 +28647,9 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
     fd->last_opcode_pos = -1;
     fd->func_name = JS_ATOM_NULL;
     fd->var_object_idx = -1;
+    fd->arg_var_object_idx = -1;
     fd->arguments_var_idx = -1;
+    fd->arguments_arg_idx = -1;
     fd->func_var_idx = -1;
     fd->eval_ret_idx = -1;
     fd->this_var_idx = -1;
@@ -28576,13 +28658,14 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
     fd->home_object_var_idx = -1;
 
     /* XXX: should distinguish arg, var and var object and body scopes */
-    fd->scope_level = 0;  /* 0: var/arg scope, 1:body scope */
-    fd->scope_first = -1;
     fd->scopes = fd->def_scope_array;
     fd->scope_size = countof(fd->def_scope_array);
     fd->scope_count = 1;
     fd->scopes[0].first = -1;
     fd->scopes[0].parent = -1;
+    fd->scope_level = 0;  /* 0: var/arg scope */
+    fd->scope_first = -1;
+    fd->body_scope = -1;
 
     fd->filename = JS_NewAtom(ctx, filename);
     fd->line_num = line_num;
@@ -28663,10 +28746,10 @@ static void js_free_function_def(JSContext *ctx, JSFunctionDef *fd)
     }
     js_free(ctx, fd->args);
 
-    for(i = 0; i < fd->hoisted_def_count; i++) {
-        JS_FreeAtom(ctx, fd->hoisted_def[i].var_name);
+    for(i = 0; i < fd->global_var_count; i++) {
+        JS_FreeAtom(ctx, fd->global_vars[i].var_name);
     }
-    js_free(ctx, fd->hoisted_def);
+    js_free(ctx, fd->global_vars);
 
     for(i = 0; i < fd->closure_var_count; i++) {
         JSClosureVar *cv = &fd->closure_var[i];
@@ -29350,19 +29433,27 @@ static int resolve_pseudo_var(JSContext *ctx, JSFunctionDef *s,
     switch(var_name) {
     case JS_ATOM_home_object:
         /* 'home_object' pseudo variable */
-        var_idx = s->home_object_var_idx = add_var(ctx, s, var_name);
+        if (s->home_object_var_idx < 0)
+            s->home_object_var_idx = add_var(ctx, s, var_name);
+        var_idx = s->home_object_var_idx;
         break;
     case JS_ATOM_this_active_func:
         /* 'this.active_func' pseudo variable */
-        var_idx = s->this_active_func_var_idx = add_var(ctx, s, var_name);
+        if (s->this_active_func_var_idx < 0)
+            s->this_active_func_var_idx = add_var(ctx, s, var_name);
+        var_idx = s->this_active_func_var_idx;
         break;
     case JS_ATOM_new_target:
         /* 'new.target' pseudo variable */
-        var_idx = s->new_target_var_idx = add_var(ctx, s, var_name);
+        if (s->new_target_var_idx < 0)
+            s->new_target_var_idx = add_var(ctx, s, var_name);
+        var_idx = s->new_target_var_idx;
         break;
     case JS_ATOM_this:
         /* 'this' pseudo variable */
-        var_idx = s->this_var_idx = add_var_this(ctx, s);
+        if (s->this_var_idx < 0)
+            s->this_var_idx = add_var_this(ctx, s);
+        var_idx = s->this_var_idx;
         break;
     default:
         var_idx = -1;
@@ -29371,18 +29462,32 @@ static int resolve_pseudo_var(JSContext *ctx, JSFunctionDef *s,
     return var_idx;
 }
 
+/* test if 'var_name' is in the variable object on the stack. If is it
+   the case, handle it and jump to 'label_done' */
+static void var_object_test(JSContext *ctx, JSFunctionDef *s,
+                            JSAtom var_name, int op, DynBuf *bc,
+                            int *plabel_done, BOOL is_with)
+{
+    dbuf_putc(bc, get_with_scope_opcode(op));
+    dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
+    *plabel_done = new_label_fd(s, *plabel_done);
+    dbuf_put_u32(bc, *plabel_done);
+    dbuf_putc(bc, is_with);
+    update_label(s, *plabel_done, 1);
+    s->jump_size++;
+}
+    
 /* return the position of the next opcode */
 static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                              JSAtom var_name, int scope_level, int op,
                              DynBuf *bc, uint8_t *bc_buf,
-                             LabelSlot *ls, int pos_next, int arg_valid)
+                             LabelSlot *ls, int pos_next)
 {
     int idx, var_idx, is_put;
     int label_done;
-    BOOL is_func_var = FALSE;
     JSFunctionDef *fd;
     JSVarDef *vd;
-    BOOL is_pseudo_var;
+    BOOL is_pseudo_var, is_arg_scope;
 
     label_done = -1;
 
@@ -29400,12 +29505,11 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         if (vd->var_name == var_name) {
             if (op == OP_scope_put_var || op == OP_scope_make_ref) {
                 if (vd->is_const) {
-                    dbuf_putc(bc, OP_throw_var);
+                    dbuf_putc(bc, OP_throw_error);
                     dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
                     dbuf_putc(bc, JS_THROW_VAR_RO);
                     goto done;
                 }
-                is_func_var = vd->is_func_var;
             }
             var_idx = idx;
             break;
@@ -29413,33 +29517,16 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         if (vd->var_name == JS_ATOM__with_ && !is_pseudo_var) {
             dbuf_putc(bc, OP_get_loc);
             dbuf_put_u16(bc, idx);
-            dbuf_putc(bc, get_with_scope_opcode(op));
-            dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-            label_done = new_label_fd(s, label_done);
-            dbuf_put_u32(bc, label_done);
-            dbuf_putc(bc, 1);
-            update_label(s, label_done, 1);
-            s->jump_size++;
+            var_object_test(ctx, s, var_name, op, bc, &label_done, 1);
         }
         idx = vd->scope_next;
     }
+    is_arg_scope = (idx == ARG_SCOPE_END);
     if (var_idx < 0) {
-        /* XXX: scoping issues:
-           should not resolve vars from the function body during argument parse,
-           `arguments` and function-name should not be hidden by later vars.
-         */
-        var_idx = find_var(ctx, s, var_name);
-        if (var_idx >= 0) {
-            if (scope_level == 0
-            &&  (var_idx & ARGUMENT_VAR_OFFSET)
-            &&  (var_idx - ARGUMENT_VAR_OFFSET) >= arg_valid) {
-                /* referring to an uninitialized argument */
-                dbuf_putc(bc, OP_throw_var);
-                dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-                dbuf_putc(bc, JS_THROW_VAR_UNINITIALIZED);
-            }
-            if (!(var_idx & ARGUMENT_VAR_OFFSET))
-                is_func_var = s->vars[var_idx].is_func_var;
+        /* argument scope: variables are not visible but pseudo
+           variables are visible */
+        if (!is_arg_scope) {
+            var_idx = find_var(ctx, s, var_name);
         }
 
         if (var_idx < 0 && is_pseudo_var)
@@ -29448,21 +29535,31 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         if (var_idx < 0 && var_name == JS_ATOM_arguments &&
             s->has_arguments_binding) {
             /* 'arguments' pseudo variable */
-            var_idx = add_arguments_var(ctx, s, var_name);
+            var_idx = add_arguments_var(ctx, s);
         }
         if (var_idx < 0 && s->is_func_expr && var_name == s->func_name) {
             /* add a new variable with the function name */
             var_idx = add_func_var(ctx, s, var_name);
-            is_func_var = TRUE;
         }
     }
     if (var_idx >= 0) {
+        if ((op == OP_scope_put_var || op == OP_scope_make_ref) &&
+            !(var_idx & ARGUMENT_VAR_OFFSET) &&
+            s->vars[var_idx].is_const) {
+            /* only happens when assigning a function expression name
+               in strict mode */
+            dbuf_putc(bc, OP_throw_error);
+            dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
+            dbuf_putc(bc, JS_THROW_VAR_RO);
+            goto done;
+        }
         /* OP_scope_put_var_init is only used to initialize a
            lexical variable, so it is never used in a with or var object. It
            can be used with a closure (module global variable case). */
         switch (op) {
         case OP_scope_make_ref:
-            if (is_func_var) {
+            if (!(var_idx & ARGUMENT_VAR_OFFSET) &&
+                s->vars[var_idx].var_kind == JS_VAR_FUNCTION_NAME) {
                 /* Create a dummy object reference for the func_var */
                 dbuf_putc(bc, OP_object);
                 dbuf_putc(bc, OP_get_loc);
@@ -29510,7 +29607,6 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
             if (var_idx & ARGUMENT_VAR_OFFSET) {
                 dbuf_putc(bc, OP_get_arg + is_put);
                 dbuf_put_u16(bc, var_idx - ARGUMENT_VAR_OFFSET);
-                /* XXX: should test if argument reference needs TDZ check */
             } else {
                 if (is_put) {
                     if (s->vars[var_idx].is_lexical) {
@@ -29543,41 +29639,32 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         goto done;
     }
     /* check eval object */
-    if (s->var_object_idx >= 0 && !is_pseudo_var) {
+    if (!is_arg_scope && s->var_object_idx >= 0 && !is_pseudo_var) {
         dbuf_putc(bc, OP_get_loc);
         dbuf_put_u16(bc, s->var_object_idx);
-        dbuf_putc(bc, get_with_scope_opcode(op));
-        dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-        label_done = new_label_fd(s, label_done);
-        dbuf_put_u32(bc, label_done);
-        dbuf_putc(bc, 0);
-        update_label(s, label_done, 1);
-        s->jump_size++;
+        var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
+    }
+    /* check eval object in argument scope */
+    if (s->arg_var_object_idx >= 0 && !is_pseudo_var) {
+        dbuf_putc(bc, OP_get_loc);
+        dbuf_put_u16(bc, s->arg_var_object_idx);
+        var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
     }
+
     /* check parent scopes */
     for (fd = s; fd->parent;) {
         scope_level = fd->parent_scope_level;
         fd = fd->parent;
-        if (scope_level == 0) {
-            /* function is defined as part of the argument parsing: hide vars
-               from the function body.
-               XXX: variables created from argument destructuring might need
-               to be visible, should refine this method.
-             */
-            var_idx = find_arg(ctx, fd, var_name);
-            goto check_idx;
-        }
         for (idx = fd->scopes[scope_level].first; idx >= 0;) {
             vd = &fd->vars[idx];
             if (vd->var_name == var_name) {
                 if (op == OP_scope_put_var || op == OP_scope_make_ref) {
                     if (vd->is_const) {
-                        dbuf_putc(bc, OP_throw_var);
+                        dbuf_putc(bc, OP_throw_error);
                         dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
                         dbuf_putc(bc, JS_THROW_VAR_RO);
                         goto done;
                     }
-                    is_func_var = vd->is_func_var;
                 }
                 var_idx = idx;
                 break;
@@ -29587,26 +29674,19 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                 if (idx >= 0) {
                     dbuf_putc(bc, OP_get_var_ref);
                     dbuf_put_u16(bc, idx);
-                    dbuf_putc(bc, get_with_scope_opcode(op));
-                    dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-                    label_done = new_label_fd(s, label_done);
-                    dbuf_put_u32(bc, label_done);
-                    dbuf_putc(bc, 1);
-                    update_label(s, label_done, 1);
-                    s->jump_size++;
+                    var_object_test(ctx, s, var_name, op, bc, &label_done, 1);
                 }
             }
             idx = vd->scope_next;
         }
+        is_arg_scope = (idx == ARG_SCOPE_END);
         if (var_idx >= 0)
             break;
-
-        var_idx = find_var(ctx, fd, var_name);
-    check_idx:
-        if (var_idx >= 0) {
-            if (!(var_idx & ARGUMENT_VAR_OFFSET))
-                is_func_var = fd->vars[var_idx].is_func_var;
-            break;
+        
+        if (!is_arg_scope) {
+            var_idx = find_var(ctx, fd, var_name);
+            if (var_idx >= 0)
+                break;
         }
         if (is_pseudo_var) {
             var_idx = resolve_pseudo_var(ctx, fd, var_name);
@@ -29614,33 +29694,39 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                 break;
         }
         if (var_name == JS_ATOM_arguments && fd->has_arguments_binding) {
-            var_idx = add_arguments_var(ctx, fd, var_name);
+            var_idx = add_arguments_var(ctx, fd);
             break;
         }
         if (fd->is_func_expr && fd->func_name == var_name) {
             /* add a new variable with the function name */
             var_idx = add_func_var(ctx, fd, var_name);
-            is_func_var = TRUE;
             break;
         }
 
         /* check eval object */
-        if (fd->var_object_idx >= 0 && !is_pseudo_var) {
-            fd->vars[fd->var_object_idx].is_captured = 1;
+        if (!is_arg_scope && fd->var_object_idx >= 0 && !is_pseudo_var) {
+            vd = &fd->vars[fd->var_object_idx];
+            vd->is_captured = 1;
             idx = get_closure_var(ctx, s, fd, FALSE,
-                                  fd->var_object_idx, JS_ATOM__var_,
+                                  fd->var_object_idx, vd->var_name,
                                   FALSE, FALSE, JS_VAR_NORMAL);
             dbuf_putc(bc, OP_get_var_ref);
             dbuf_put_u16(bc, idx);
-            dbuf_putc(bc, get_with_scope_opcode(op));
-            dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-            label_done = new_label_fd(s, label_done);
-            dbuf_put_u32(bc, label_done);
-            dbuf_putc(bc, 0);
-            update_label(s, label_done, 1);
-            s->jump_size++;
+            var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
         }
 
+        /* check eval object in argument scope */
+        if (fd->arg_var_object_idx >= 0 && !is_pseudo_var) {
+            vd = &fd->vars[fd->arg_var_object_idx];
+            vd->is_captured = 1;
+            idx = get_closure_var(ctx, s, fd, FALSE,
+                                  fd->arg_var_object_idx, vd->var_name,
+                                  FALSE, FALSE, JS_VAR_NORMAL);
+            dbuf_putc(bc, OP_get_var_ref);
+            dbuf_put_u16(bc, idx);
+            var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
+        }
+        
         if (fd->is_eval)
             break; /* it it necessarily the top level function */
     }
@@ -29665,6 +29751,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                 }
                 goto has_idx;
             } else if ((cv->var_name == JS_ATOM__var_ ||
+                        cv->var_name == JS_ATOM__arg_var_ ||
                         cv->var_name == JS_ATOM__with_) && !is_pseudo_var) {
                 int is_with = (cv->var_name == JS_ATOM__with_);
                 if (fd != s) {
@@ -29678,13 +29765,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                 }
                 dbuf_putc(bc, OP_get_var_ref);
                 dbuf_put_u16(bc, idx);
-                dbuf_putc(bc, get_with_scope_opcode(op));
-                dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-                label_done = new_label_fd(s, label_done);
-                dbuf_put_u32(bc, label_done);
-                dbuf_putc(bc, is_with);
-                update_label(s, label_done, 1);
-                s->jump_size++;
+                var_object_test(ctx, s, var_name, op, bc, &label_done, is_with);
             }
         }
     }
@@ -29709,14 +29790,14 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         has_idx:
             if ((op == OP_scope_put_var || op == OP_scope_make_ref) &&
                 s->closure_var[idx].is_const) {
-                dbuf_putc(bc, OP_throw_var);
+                dbuf_putc(bc, OP_throw_error);
                 dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
                 dbuf_putc(bc, JS_THROW_VAR_RO);
                 goto done;
             }
             switch (op) {
             case OP_scope_make_ref:
-                if (is_func_var) {
+                if (s->closure_var[idx].var_kind == JS_VAR_FUNCTION_NAME) {
                     /* Create a dummy object reference for the func_var */
                     dbuf_putc(bc, OP_object);
                     dbuf_putc(bc, OP_get_var_ref);
@@ -29956,7 +30037,7 @@ static int resolve_scope_private_field(JSContext *ctx, JSFunctionDef *s,
             break;
         case JS_VAR_PRIVATE_SETTER:
             /* XXX: add clearer error message */
-            dbuf_putc(bc, OP_throw_var);
+            dbuf_putc(bc, OP_throw_error);
             dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
             dbuf_putc(bc, JS_THROW_VAR_RO);
             break;
@@ -29973,7 +30054,7 @@ static int resolve_scope_private_field(JSContext *ctx, JSFunctionDef *s,
         case JS_VAR_PRIVATE_METHOD:
         case JS_VAR_PRIVATE_GETTER:
             /* XXX: add clearer error message */
-            dbuf_putc(bc, OP_throw_var);
+            dbuf_putc(bc, OP_throw_error);
             dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
             dbuf_putc(bc, JS_THROW_VAR_RO);
             break;
@@ -30025,17 +30106,33 @@ static void mark_eval_captured_variables(JSContext *ctx, JSFunctionDef *s,
     }
 }
 
+/* XXX: should handle the argument scope generically */
+static BOOL is_var_in_arg_scope(const JSVarDef *vd)
+{
+    return (vd->var_name == JS_ATOM_home_object ||
+            vd->var_name == JS_ATOM_this_active_func ||
+            vd->var_name == JS_ATOM_new_target ||
+            vd->var_name == JS_ATOM_this ||
+            vd->var_name == JS_ATOM__arg_var_ ||
+            vd->var_kind == JS_VAR_FUNCTION_NAME);
+}
+
 static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
 {
     JSFunctionDef *fd;
     JSVarDef *vd;
     int i, scope_level, scope_idx;
-    BOOL has_arguments_binding, has_this_binding;
+    BOOL has_arguments_binding, has_this_binding, is_arg_scope;
 
     /* in non strict mode, variables are created in the caller's
        environment object */
     if (!s->is_eval && !(s->js_mode & JS_MODE_STRICT)) {
         s->var_object_idx = add_var(ctx, s, JS_ATOM__var_);
+        if (s->has_parameter_expressions) {
+            /* an additional variable object is needed for the
+               argument scope */
+            s->arg_var_object_idx = add_var(ctx, s, JS_ATOM__arg_var_);
+        }
     }
 
     /* eval can potentially use 'arguments' so we must define it */
@@ -30051,8 +30148,14 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
             s->home_object_var_idx = add_var(ctx, s, JS_ATOM_home_object);
     }
     has_arguments_binding = s->has_arguments_binding;
-    if (has_arguments_binding)
-        add_arguments_var(ctx, s, JS_ATOM_arguments);
+    if (has_arguments_binding) {
+        add_arguments_var(ctx, s);
+        /* also add an arguments binding in the argument scope to
+           raise an error if a direct eval in the argument scope tries
+           to redefine it */
+        if (s->has_parameter_expressions && !(s->js_mode & JS_MODE_STRICT))
+            add_arguments_arg(ctx, s);
+    }
     if (s->is_func_expr && s->func_name != JS_ATOM_NULL)
         add_func_var(ctx, s, s->func_name);
 
@@ -30069,7 +30172,6 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
         fd = fd->parent;
         if (!fd)
             break;
-        scope_idx = fd->scopes[scope_level].first;
         /* add 'this' if it was not previously added */
         if (!has_this_binding && fd->has_this_binding) {
             if (fd->this_var_idx < 0)
@@ -30084,7 +30186,7 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
         }
         /* add 'arguments' if it was not previously added */
         if (!has_arguments_binding && fd->has_arguments_binding) {
-            add_arguments_var(ctx, fd, JS_ATOM_arguments);
+            add_arguments_var(ctx, fd);
             has_arguments_binding = TRUE;
         }
         /* add function name */
@@ -30092,6 +30194,7 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
             add_func_var(ctx, fd, fd->func_name);
 
         /* add lexical variables */
+        scope_idx = fd->scopes[scope_level].first;
         while (scope_idx >= 0) {
             vd = &fd->vars[scope_idx];
             vd->is_captured = 1;
@@ -30099,24 +30202,37 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
                             vd->var_name, vd->is_const, vd->is_lexical, vd->var_kind);
             scope_idx = vd->scope_next;
         }
-        /* add unscoped variables */
-        for(i = 0; i < fd->arg_count; i++) {
-            vd = &fd->args[i];
-            if (vd->var_name != JS_ATOM_NULL) {
-                get_closure_var(ctx, s, fd,
-                                TRUE, i, vd->var_name, FALSE, FALSE,
-                                JS_VAR_NORMAL);
+        is_arg_scope = (scope_idx == ARG_SCOPE_END);
+        if (!is_arg_scope) {
+            /* add unscoped variables */
+            for(i = 0; i < fd->arg_count; i++) {
+                vd = &fd->args[i];
+                if (vd->var_name != JS_ATOM_NULL) {
+                    get_closure_var(ctx, s, fd,
+                                    TRUE, i, vd->var_name, FALSE, FALSE,
+                                    JS_VAR_NORMAL);
+                }
             }
-        }
-        for(i = 0; i < fd->var_count; i++) {
-            vd = &fd->vars[i];
-            /* do not close top level last result */
-            if (vd->scope_level == 0 &&
-                vd->var_name != JS_ATOM__ret_ &&
-                vd->var_name != JS_ATOM_NULL) {
-                get_closure_var(ctx, s, fd,
-                                FALSE, i, vd->var_name, FALSE, FALSE,
-                                JS_VAR_NORMAL);
+            for(i = 0; i < fd->var_count; i++) {
+                vd = &fd->vars[i];
+                /* do not close top level last result */
+                if (vd->scope_level == 0 &&
+                    vd->var_name != JS_ATOM__ret_ &&
+                    vd->var_name != JS_ATOM_NULL) {
+                    get_closure_var(ctx, s, fd,
+                                    FALSE, i, vd->var_name, FALSE, FALSE,
+                                    JS_VAR_NORMAL);
+                }
+            }
+        } else {
+            for(i = 0; i < fd->var_count; i++) {
+                vd = &fd->vars[i];
+                /* do not close top level last result */
+                if (vd->scope_level == 0 && is_var_in_arg_scope(vd)) {
+                    get_closure_var(ctx, s, fd,
+                                    FALSE, i, vd->var_name, FALSE, FALSE,
+                                    JS_VAR_NORMAL);
+                }
             }
         }
         if (fd->is_eval) {
@@ -30134,6 +30250,18 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
     }
 }
 
+static void set_closure_from_var(JSContext *ctx, JSClosureVar *cv,
+                                 JSVarDef *vd, int var_idx)
+{
+    cv->is_local = TRUE;
+    cv->is_arg = FALSE;
+    cv->is_const = vd->is_const;
+    cv->is_lexical = vd->is_lexical;
+    cv->var_kind = vd->var_kind;
+    cv->var_idx = var_idx;
+    cv->var_name = JS_DupAtom(ctx, vd->var_name);
+}
+
 /* for direct eval compilation: add references to the variables of the
    calling function */
 static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
@@ -30141,7 +30269,8 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
 {
     int i, count;
     JSVarDef *vd;
-
+    BOOL is_arg_scope;
+    
     count = b->arg_count + b->var_count + b->closure_var_count;
     s->closure_var = NULL;
     s->closure_var_count = 0;
@@ -30156,41 +30285,41 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
         vd = &b->vardefs[b->arg_count + i];
         if (vd->scope_level > 0) {
             JSClosureVar *cv = &s->closure_var[s->closure_var_count++];
-            cv->is_local = TRUE;
-            cv->is_arg = FALSE;
-            cv->is_const = vd->is_const;
-            cv->is_lexical = vd->is_lexical;
-            cv->var_kind = vd->var_kind;
-            cv->var_idx = i;
-            cv->var_name = JS_DupAtom(ctx, vd->var_name);
+            set_closure_from_var(ctx, cv, vd, i);
         }
         i = vd->scope_next;
     }
-    /* Add argument variables */
-    for(i = 0; i < b->arg_count; i++) {
-        JSClosureVar *cv = &s->closure_var[s->closure_var_count++];
-        vd = &b->vardefs[i];
-        cv->is_local = TRUE;
-        cv->is_arg = TRUE;
-        cv->is_const = FALSE;
-        cv->is_lexical = FALSE;
-        cv->var_kind = JS_VAR_NORMAL;
-        cv->var_idx = i;
-        cv->var_name = JS_DupAtom(ctx, vd->var_name);
-    }
-    /* Add local non lexical variables */
-    for(i = 0; i < b->var_count; i++) {
-        vd = &b->vardefs[b->arg_count + i];
-        if (vd->scope_level == 0 && vd->var_name != JS_ATOM__ret_) {
+    is_arg_scope = (i == ARG_SCOPE_END);
+    if (!is_arg_scope) {
+        /* Add argument variables */
+        for(i = 0; i < b->arg_count; i++) {
             JSClosureVar *cv = &s->closure_var[s->closure_var_count++];
+            vd = &b->vardefs[i];
             cv->is_local = TRUE;
-            cv->is_arg = FALSE;
+            cv->is_arg = TRUE;
             cv->is_const = FALSE;
             cv->is_lexical = FALSE;
             cv->var_kind = JS_VAR_NORMAL;
             cv->var_idx = i;
             cv->var_name = JS_DupAtom(ctx, vd->var_name);
         }
+        /* Add local non lexical variables */
+        for(i = 0; i < b->var_count; i++) {
+            vd = &b->vardefs[b->arg_count + i];
+            if (vd->scope_level == 0 && vd->var_name != JS_ATOM__ret_) {
+                JSClosureVar *cv = &s->closure_var[s->closure_var_count++];
+                set_closure_from_var(ctx, cv, vd, i);
+            }
+        }
+    } else {
+        /* only add pseudo variables */
+        for(i = 0; i < b->var_count; i++) {
+            vd = &b->vardefs[b->arg_count + i];
+            if (vd->scope_level == 0 && is_var_in_arg_scope(vd)) {
+                JSClosureVar *cv = &s->closure_var[s->closure_var_count++];
+                set_closure_from_var(ctx, cv, vd, i);
+            }
+        }
     }
     for(i = 0; i < b->closure_var_count; i++) {
         JSClosureVar *cv0 = &b->closure_var[i];
@@ -30348,59 +30477,93 @@ static BOOL code_match(CodeContext *s, int pos, ...)
 
 static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, DynBuf *bc)
 {
-    int i, idx, var_idx;
+    int i, idx, label_next = -1;
+
+    /* add the hoisted functions in arguments and local variables */
+    for(i = 0; i < s->arg_count; i++) {
+        JSVarDef *vd = &s->args[i];
+        if (vd->func_pool_idx >= 0) {
+            dbuf_putc(bc, OP_fclosure);
+            dbuf_put_u32(bc, vd->func_pool_idx);
+            dbuf_putc(bc, OP_put_arg);
+            dbuf_put_u16(bc, i);
+        }
+    }
+    for(i = 0; i < s->var_count; i++) {
+        JSVarDef *vd = &s->vars[i];
+        if (vd->scope_level == 0 && vd->func_pool_idx >= 0) {
+            dbuf_putc(bc, OP_fclosure);
+            dbuf_put_u32(bc, vd->func_pool_idx);
+            dbuf_putc(bc, OP_put_loc);
+            dbuf_put_u16(bc, i);
+        }
+    }
 
-    /* add the hoisted functions and variables */
-    for(i = 0; i < s->hoisted_def_count; i++) {
-        JSHoistedDef *hf = &s->hoisted_def[i];
+    /* the module global variables must be initialized before
+       evaluating the module so that the exported functions are
+       visible if there are cyclic module references */
+    if (s->module) {
+        label_next = new_label_fd(s, -1);
+        
+        /* if 'this' is true, initialize the global variables and return */
+        dbuf_putc(bc, OP_push_this);
+        dbuf_putc(bc, OP_if_false);
+        dbuf_put_u32(bc, label_next);
+        update_label(s, label_next, 1);
+        s->jump_size++;
+    }
+    
+    /* add the global variables (only happens if s->is_global_var is
+       true) */
+    for(i = 0; i < s->global_var_count; i++) {
+        JSGlobalVar *hf = &s->global_vars[i];
         int has_closure = 0;
         BOOL force_init = hf->force_init;
-        if (s->is_global_var && hf->var_name != JS_ATOM_NULL) {
-            /* we are in an eval, so the closure contains all the
-               enclosing variables */
-            /* If the outer function has a variable environment,
-               create a property for the variable there */
-            for(idx = 0; idx < s->closure_var_count; idx++) {
-                JSClosureVar *cv = &s->closure_var[idx];
-                if (cv->var_name == hf->var_name) {
-                    has_closure = 2;
-                    force_init = FALSE;
-                    break;
-                }
-                if (cv->var_name == JS_ATOM__var_) {
-                    dbuf_putc(bc, OP_get_var_ref);
-                    dbuf_put_u16(bc, idx);
-                    has_closure = 1;
-                    force_init = TRUE;
-                    break;
-                }
+        /* we are in an eval, so the closure contains all the
+           enclosing variables */
+        /* If the outer function has a variable environment,
+           create a property for the variable there */
+        for(idx = 0; idx < s->closure_var_count; idx++) {
+            JSClosureVar *cv = &s->closure_var[idx];
+            if (cv->var_name == hf->var_name) {
+                has_closure = 2;
+                force_init = FALSE;
+                break;
             }
-            if (!has_closure) {
-                int flags;
-
-                flags = 0;
-                if (s->eval_type != JS_EVAL_TYPE_GLOBAL)
-                    flags |= JS_PROP_CONFIGURABLE;
-                if (hf->cpool_idx >= 0 && !hf->is_lexical) {
-                    /* global function definitions need a specific handling */
-                    dbuf_putc(bc, OP_fclosure);
-                    dbuf_put_u32(bc, hf->cpool_idx);
-
-                    dbuf_putc(bc, OP_define_func);
-                    dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
-                    dbuf_putc(bc, flags);
-
-                    goto done_hoisted_def;
-                } else {
-                    if (hf->is_lexical) {
-                        flags |= DEFINE_GLOBAL_LEX_VAR;
-                        if (!hf->is_const)
-                            flags |= JS_PROP_WRITABLE;
-                    }
-                    dbuf_putc(bc, OP_define_var);
-                    dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
-                    dbuf_putc(bc, flags);
+            if (cv->var_name == JS_ATOM__var_ ||
+                cv->var_name == JS_ATOM__arg_var_) {
+                dbuf_putc(bc, OP_get_var_ref);
+                dbuf_put_u16(bc, idx);
+                has_closure = 1;
+                force_init = TRUE;
+                break;
+            }
+        }
+        if (!has_closure) {
+            int flags;
+            
+            flags = 0;
+            if (s->eval_type != JS_EVAL_TYPE_GLOBAL)
+                flags |= JS_PROP_CONFIGURABLE;
+            if (hf->cpool_idx >= 0 && !hf->is_lexical) {
+                /* global function definitions need a specific handling */
+                dbuf_putc(bc, OP_fclosure);
+                dbuf_put_u32(bc, hf->cpool_idx);
+                
+                dbuf_putc(bc, OP_define_func);
+                dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
+                dbuf_putc(bc, flags);
+                
+                goto done_global_var;
+            } else {
+                if (hf->is_lexical) {
+                    flags |= DEFINE_GLOBAL_LEX_VAR;
+                    if (!hf->is_const)
+                        flags |= JS_PROP_WRITABLE;
                 }
+                dbuf_putc(bc, OP_define_var);
+                dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
+                dbuf_putc(bc, flags);
             }
         }
         if (hf->cpool_idx >= 0 || force_init) {
@@ -30415,37 +30578,35 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
             } else {
                 dbuf_putc(bc, OP_undefined);
             }
-            if (s->is_global_var) {
-                if (has_closure == 2) {
-                    dbuf_putc(bc, OP_put_var_ref);
-                    dbuf_put_u16(bc, idx);
-                } else if (has_closure == 1) {
-                    dbuf_putc(bc, OP_define_field);
-                    dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
-                    dbuf_putc(bc, OP_drop);
-                } else {
-                    /* XXX: Check if variable is writable and enumerable */
-                    dbuf_putc(bc, OP_put_var);
-                    dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
-                }
+            if (has_closure == 2) {
+                dbuf_putc(bc, OP_put_var_ref);
+                dbuf_put_u16(bc, idx);
+            } else if (has_closure == 1) {
+                dbuf_putc(bc, OP_define_field);
+                dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
+                dbuf_putc(bc, OP_drop);
             } else {
-                var_idx = hf->var_idx;
-                if (var_idx & ARGUMENT_VAR_OFFSET) {
-                    dbuf_putc(bc, OP_put_arg);
-                    dbuf_put_u16(bc, var_idx - ARGUMENT_VAR_OFFSET);
-                } else {
-                    dbuf_putc(bc, OP_put_loc);
-                    dbuf_put_u16(bc, var_idx);
-                }
+                /* XXX: Check if variable is writable and enumerable */
+                dbuf_putc(bc, OP_put_var);
+                dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
             }
         }
-    done_hoisted_def:
+    done_global_var:
         JS_FreeAtom(ctx, hf->var_name);
     }
-    js_free(ctx, s->hoisted_def);
-    s->hoisted_def = NULL;
-    s->hoisted_def_count = 0;
-    s->hoisted_def_size = 0;
+
+    if (s->module) {
+        dbuf_putc(bc, OP_return_undef);
+        
+        dbuf_putc(bc, OP_label);
+        dbuf_put_u32(bc, label_next);
+        s->label_slots[label_next].pos2 = bc->size;
+    }
+
+    js_free(ctx, s->global_vars);
+    s->global_vars = NULL;
+    s->global_var_count = 0;
+    s->global_var_size = 0;
 }
 
 static int skip_dead_code(JSFunctionDef *s, const uint8_t *bc_buf, int bc_len,
@@ -30525,7 +30686,7 @@ static int get_label_pos(JSFunctionDef *s, int label)
    variables when necessary */
 static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
 {
-    int pos, pos_next, bc_len, op, len, i, idx, arg_valid, line_num;
+    int pos, pos_next, bc_len, op, len, i, idx, line_num;
     uint8_t *bc_buf;
     JSAtom var_name;
     DynBuf bc_out;
@@ -30538,47 +30699,43 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
 
     /* first pass for runtime checks (must be done before the
        variables are created) */
-    if (s->is_global_var) {
-        for(i = 0; i < s->hoisted_def_count; i++) {
-            JSHoistedDef *hf = &s->hoisted_def[i];
-            int flags;
-
-            if (hf->var_name != JS_ATOM_NULL) {
-                /* check if global variable (XXX: simplify) */
-                for(idx = 0; idx < s->closure_var_count; idx++) {
-                    JSClosureVar *cv = &s->closure_var[idx];
-                    if (cv->var_name == hf->var_name) {
-                        if (s->eval_type == JS_EVAL_TYPE_DIRECT &&
-                            cv->is_lexical) {
-                            /* Check if a lexical variable is
-                               redefined as 'var'. XXX: Could abort
-                               compilation here, but for consistency
-                               with the other checks, we delay the
-                               error generation. */
-                            dbuf_putc(&bc_out, OP_throw_var);
-                            dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
-                            dbuf_putc(&bc_out, JS_THROW_VAR_REDECL);
-                        }
-                        goto next;
-                    }
-                    if (cv->var_name == JS_ATOM__var_)
-                        goto next;
+    for(i = 0; i < s->global_var_count; i++) {
+        JSGlobalVar *hf = &s->global_vars[i];
+        int flags;
+        
+        /* check if global variable (XXX: simplify) */
+        for(idx = 0; idx < s->closure_var_count; idx++) {
+            JSClosureVar *cv = &s->closure_var[idx];
+            if (cv->var_name == hf->var_name) {
+                if (s->eval_type == JS_EVAL_TYPE_DIRECT &&
+                    cv->is_lexical) {
+                    /* Check if a lexical variable is
+                       redefined as 'var'. XXX: Could abort
+                       compilation here, but for consistency
+                       with the other checks, we delay the
+                       error generation. */
+                    dbuf_putc(&bc_out, OP_throw_error);
+                    dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
+                    dbuf_putc(&bc_out, JS_THROW_VAR_REDECL);
                 }
-
-                dbuf_putc(&bc_out, OP_check_define_var);
-                dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
-                flags = 0;
-                if (hf->is_lexical)
-                    flags |= DEFINE_GLOBAL_LEX_VAR;
-                if (hf->cpool_idx >= 0)
-                    flags |= DEFINE_GLOBAL_FUNC_VAR;
-                dbuf_putc(&bc_out, flags);
+                goto next;
             }
-        next: ;
+            if (cv->var_name == JS_ATOM__var_ ||
+                cv->var_name == JS_ATOM__arg_var_)
+                goto next;
         }
+        
+        dbuf_putc(&bc_out, OP_check_define_var);
+        dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
+        flags = 0;
+        if (hf->is_lexical)
+            flags |= DEFINE_GLOBAL_LEX_VAR;
+        if (hf->cpool_idx >= 0)
+            flags |= DEFINE_GLOBAL_FUNC_VAR;
+        dbuf_putc(&bc_out, flags);
+    next: ;
     }
 
-    arg_valid = 0;
     line_num = 0; /* avoid warning */
     for (pos = 0; pos < bc_len; pos = pos_next) {
         op = bc_buf[pos];
@@ -30590,9 +30747,6 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
             s->line_number_size++;
             goto no_change;
 
-        case OP_set_arg_valid_upto:
-            arg_valid = get_u16(bc_buf + pos + 1);
-            break;
         case OP_eval: /* convert scope index to adjusted variable index */
             {
                 int call_argc = get_u16(bc_buf + pos + 1);
@@ -30618,7 +30772,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
             var_name = get_u32(bc_buf + pos + 1);
             scope = get_u16(bc_buf + pos + 5);
             pos_next = resolve_scope_var(ctx, s, var_name, scope, op, &bc_out,
-                                         NULL, NULL, pos_next, arg_valid);
+                                         NULL, NULL, pos_next);
             JS_FreeAtom(ctx, var_name);
             break;
         case OP_scope_make_ref:
@@ -30631,7 +30785,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                 ls = &s->label_slots[label];
                 ls->ref_count--;  /* always remove label reference */
                 pos_next = resolve_scope_var(ctx, s, var_name, scope, op, &bc_out,
-                                             bc_buf, ls, pos_next, arg_valid);
+                                             bc_buf, ls, pos_next);
                 JS_FreeAtom(ctx, var_name);
             }
             break;
@@ -30712,7 +30866,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         case OP_return:
         case OP_return_undef:
         case OP_throw:
-        case OP_throw_var:
+        case OP_throw_error:
         case OP_ret:
             if (OPTIMIZE) {
                 /* remove dead code */
@@ -30746,25 +30900,27 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
             {
                 int scope_idx, scope = get_u16(bc_buf + pos + 1);
 
-                if (scope == 1) {
+                if (scope == s->body_scope) {
                     instantiate_hoisted_definitions(ctx, s, &bc_out);
                 }
 
                 for(scope_idx = s->scopes[scope].first; scope_idx >= 0;) {
                     JSVarDef *vd = &s->vars[scope_idx];
                     if (vd->scope_level == scope) {
-                        if (vd->var_kind == JS_VAR_FUNCTION_DECL ||
-                            vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) {
-                            /* Initialize lexical variable upon entering scope */
-                            dbuf_putc(&bc_out, OP_fclosure);
-                            dbuf_put_u32(&bc_out, vd->func_pool_or_scope_idx);
-                            dbuf_putc(&bc_out, OP_put_loc);
-                            dbuf_put_u16(&bc_out, scope_idx);
-                        } else {
-                            /* XXX: should check if variable can be used
-                               before initialization */
-                            dbuf_putc(&bc_out, OP_set_loc_uninitialized);
-                            dbuf_put_u16(&bc_out, scope_idx);
+                        if (scope_idx != s->arguments_arg_idx) {
+                            if (vd->var_kind == JS_VAR_FUNCTION_DECL ||
+                                vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) {
+                                /* Initialize lexical variable upon entering scope */
+                                dbuf_putc(&bc_out, OP_fclosure);
+                                dbuf_put_u32(&bc_out, vd->func_pool_idx);
+                                dbuf_putc(&bc_out, OP_put_loc);
+                                dbuf_put_u16(&bc_out, scope_idx);
+                            } else {
+                                /* XXX: should check if variable can be used
+                                   before initialization */
+                                dbuf_putc(&bc_out, OP_set_loc_uninitialized);
+                                dbuf_put_u16(&bc_out, scope_idx);
+                            }
                         }
                         scope_idx = vd->scope_next;
                     } else {
@@ -31167,6 +31323,8 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
             dbuf_putc(&bc_out, OP_special_object);
             dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_MAPPED_ARGUMENTS);
         }
+        if (s->arguments_arg_idx >= 0)
+            put_short_code(&bc_out, OP_set_loc, s->arguments_arg_idx);
         put_short_code(&bc_out, OP_put_loc, s->arguments_var_idx);
     }
     /* initialize a reference to the current function if needed */
@@ -31181,6 +31339,11 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
         dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
         put_short_code(&bc_out, OP_put_loc, s->var_object_idx);
     }
+    if (s->arg_var_object_idx >= 0) {
+        dbuf_putc(&bc_out, OP_special_object);
+        dbuf_putc(&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
+        put_short_code(&bc_out, OP_put_loc, s->arg_var_object_idx);
+    }
 
     for (pos = 0; pos < bc_len; pos = pos_next) {
         int val;
@@ -31248,7 +31411,7 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
         case OP_return_undef:
         case OP_return_async:
         case OP_throw:
-        case OP_throw_var:
+        case OP_throw_error:
             pos_next = skip_dead_code(s, bc_buf, bc_len, pos_next, &line_num);
             goto no_change;
 
@@ -31969,56 +32132,91 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
 /* compute the maximum stack size needed by the function */
 
 typedef struct StackSizeState {
+    int bc_len;
     int stack_len_max;
     uint16_t *stack_level_tab;
+    int *pc_stack;
+    int pc_stack_len;
+    int pc_stack_size;
 } StackSizeState;
 
-static __exception int compute_stack_size_rec(JSContext *ctx,
-                                              JSFunctionDef *fd,
-                                              StackSizeState *s,
-                                              int pos, int op, int stack_len)
+/* 'op' is only used for error indication */
+static __exception int ss_check(JSContext *ctx, StackSizeState *s,
+                                int pos, int op, int stack_len)
 {
-    int bc_len, diff, n_pop, pos_next;
-    const JSOpCode *oi;
-    const uint8_t *bc_buf;
-
+    if ((unsigned)pos >= s->bc_len) {
+        JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
+        return -1;
+    }
     if (stack_len > s->stack_len_max) {
         s->stack_len_max = stack_len;
-        if (s->stack_len_max > JS_STACK_SIZE_MAX)
-            goto stack_overflow;
+        if (s->stack_len_max > JS_STACK_SIZE_MAX) {
+            JS_ThrowInternalError(ctx, "stack overflow (op=%d, pc=%d)", op, pos);
+            return -1;
+        }
     }
-    bc_buf = fd->byte_code.buf;
-    bc_len = fd->byte_code.size;
-    for(;;) {
-        if ((unsigned)pos >= bc_len)
-            goto buf_overflow;
-#if 0
-        printf("%5d: %d\n", pos, stack_len);
-#endif
-        if (s->stack_level_tab[pos] != 0xffff) {
-            /* already explored: check that the stack size is consistent */
-            if (s->stack_level_tab[pos] != stack_len) {
-                JS_ThrowInternalError(ctx, "unconsistent stack size: %d %d (pc=%d)",
-                                      s->stack_level_tab[pos], stack_len, pos);
-                return -1;
-            } else {
-                return 0;
-            }
+    if (s->stack_level_tab[pos] != 0xffff) {
+        /* already explored: check that the stack size is consistent */
+        if (s->stack_level_tab[pos] != stack_len) {
+            JS_ThrowInternalError(ctx, "unconsistent stack size: %d %d (pc=%d)",
+                                  s->stack_level_tab[pos], stack_len, pos);
+            return -1;
         } else {
-            s->stack_level_tab[pos] = stack_len;
+            return 0;
         }
+    }
+
+    /* mark as explored and store the stack size */
+    s->stack_level_tab[pos] = stack_len;
+
+    /* queue the new PC to explore */
+    if (js_resize_array(ctx, (void **)&s->pc_stack, sizeof(s->pc_stack[0]),
+                        &s->pc_stack_size, s->pc_stack_len + 1))
+        return -1;
+    s->pc_stack[s->pc_stack_len++] = pos;
+    return 0;
+}
+
+static __exception int compute_stack_size(JSContext *ctx,
+                                          JSFunctionDef *fd,
+                                          int *pstack_size)
+{
+    StackSizeState s_s, *s = &s_s;
+    int i, diff, n_pop, pos_next, stack_len, pos, op;
+    const JSOpCode *oi;
+    const uint8_t *bc_buf;
+
+    bc_buf = fd->byte_code.buf;
+    s->bc_len = fd->byte_code.size;
+    /* bc_len > 0 */
+    s->stack_level_tab = js_malloc(ctx, sizeof(s->stack_level_tab[0]) *
+                                   s->bc_len);
+    if (!s->stack_level_tab)
+        return -1;
+    for(i = 0; i < s->bc_len; i++)
+        s->stack_level_tab[i] = 0xffff;
+    s->stack_len_max = 0;
+    s->pc_stack = NULL;
+    s->pc_stack_len = 0;
+    s->pc_stack_size = 0;
 
+    /* breadth-first graph exploration */
+    if (ss_check(ctx, s, 0, OP_invalid, 0))
+        goto fail;
+
+    while (s->pc_stack_len > 0) {
+        pos = s->pc_stack[--s->pc_stack_len];
+        stack_len = s->stack_level_tab[pos];
         op = bc_buf[pos];
         if (op == 0 || op >= OP_COUNT) {
             JS_ThrowInternalError(ctx, "invalid opcode (op=%d, pc=%d)", op, pos);
-            return -1;
+            goto fail;
         }
         oi = &short_opcode_info(op);
         pos_next = pos + oi->size;
-        if (pos_next > bc_len) {
-        buf_overflow:
+        if (pos_next > s->bc_len) {
             JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
-            return -1;
+            goto fail;
         }
         n_pop = oi->n_pop;
         /* call pops a variable number of arguments */
@@ -32034,13 +32232,15 @@ static __exception int compute_stack_size_rec(JSContext *ctx,
 
         if (stack_len < n_pop) {
             JS_ThrowInternalError(ctx, "stack underflow (op=%d, pc=%d)", op, pos);
-            return -1;
+            goto fail;
         }
         stack_len += oi->n_push - n_pop;
         if (stack_len > s->stack_len_max) {
             s->stack_len_max = stack_len;
-            if (s->stack_len_max > JS_STACK_SIZE_MAX)
-                goto stack_overflow;
+            if (s->stack_len_max > JS_STACK_SIZE_MAX) {
+                JS_ThrowInternalError(ctx, "stack overflow (op=%d, pc=%d)", op, pos);
+                goto fail;
+            }
         }
         switch(op) {
         case OP_tail_call:
@@ -32049,9 +32249,9 @@ static __exception int compute_stack_size_rec(JSContext *ctx,
         case OP_return_undef:
         case OP_return_async:
         case OP_throw:
-        case OP_throw_var:
+        case OP_throw_error:
         case OP_ret:
-            goto done;
+            goto done_insn;
         case OP_goto:
             diff = get_u32(bc_buf + pos + 1);
             pos_next = pos + 1 + diff;
@@ -32068,73 +32268,57 @@ static __exception int compute_stack_size_rec(JSContext *ctx,
         case OP_if_true8:
         case OP_if_false8:
             diff = (int8_t)bc_buf[pos + 1];
-            if (compute_stack_size_rec(ctx, fd, s, pos + 1 + diff, op, stack_len))
-                return -1;
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len))
+                goto fail;
             break;
 #endif
         case OP_if_true:
         case OP_if_false:
         case OP_catch:
             diff = get_u32(bc_buf + pos + 1);
-            if (compute_stack_size_rec(ctx, fd, s, pos + 1 + diff, op, stack_len))
-                return -1;
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len))
+                goto fail;
             break;
         case OP_gosub:
             diff = get_u32(bc_buf + pos + 1);
-            if (compute_stack_size_rec(ctx, fd, s, pos + 1 + diff, op, stack_len + 1))
-                return -1;
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len + 1))
+                goto fail;
             break;
         case OP_with_get_var:
         case OP_with_delete_var:
             diff = get_u32(bc_buf + pos + 5);
-            if (compute_stack_size_rec(ctx, fd, s, pos + 5 + diff, op, stack_len + 1))
-                return -1;
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 1))
+                goto fail;
             break;
         case OP_with_make_ref:
         case OP_with_get_ref:
         case OP_with_get_ref_undef:
             diff = get_u32(bc_buf + pos + 5);
-            if (compute_stack_size_rec(ctx, fd, s, pos + 5 + diff, op, stack_len + 2))
-                return -1;
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 2))
+                goto fail;
             break;
         case OP_with_put_var:
             diff = get_u32(bc_buf + pos + 5);
-            if (compute_stack_size_rec(ctx, fd, s, pos + 5 + diff, op, stack_len - 1))
-                return -1;
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len - 1))
+                goto fail;
             break;
 
         default:
             break;
         }
-        pos = pos_next;
+        if (ss_check(ctx, s, pos_next, op, stack_len))
+            goto fail;
+    done_insn: ;
     }
- done:
-    return 0;
-
- stack_overflow:
-    JS_ThrowInternalError(ctx, "stack overflow (op=%d, pc=%d)", op, pos);
-    return -1;
-}
-
-static __exception int compute_stack_size(JSContext *ctx,
-                                          JSFunctionDef *fd,
-                                          int *pstack_size)
-{
-    StackSizeState s_s, *s = &s_s;
-    int bc_len, i, ret;
-
-    bc_len = fd->byte_code.size;
-    /* bc_len > 0 */
-    s->stack_level_tab = js_malloc(ctx, sizeof(s->stack_level_tab[0]) * bc_len);
-    if (!s->stack_level_tab)
-        return -1;
-    for(i = 0; i < bc_len; i++)
-        s->stack_level_tab[i] = 0xffff;
-    s->stack_len_max = 0;
-    ret = compute_stack_size_rec(ctx, fd, s, 0, OP_invalid, 0);
     js_free(ctx, s->stack_level_tab);
+    js_free(ctx, s->pc_stack);
     *pstack_size = s->stack_len_max;
-    return ret;
+    return 0;
+ fail:
+    js_free(ctx, s->stack_level_tab);
+    js_free(ctx, s->pc_stack);
+    *pstack_size = 0;
+    return -1;
 }
 
 static int add_module_variables(JSContext *ctx, JSFunctionDef *fd)
@@ -32142,14 +32326,14 @@ static int add_module_variables(JSContext *ctx, JSFunctionDef *fd)
     int i, idx;
     JSModuleDef *m = fd->module;
     JSExportEntry *me;
-    JSHoistedDef *hf;
+    JSGlobalVar *hf;
 
     /* The imported global variables were added as closure variables
        in js_parse_import(). We add here the module global
        variables. */
 
-    for(i = 0; i < fd->hoisted_def_count; i++) {
-        hf = &fd->hoisted_def[i];
+    for(i = 0; i < fd->global_var_count; i++) {
+        hf = &fd->global_vars[i];
         if (add_closure_var(ctx, fd, TRUE, FALSE, i, hf->var_name, hf->is_const,
                             hf->is_lexical, FALSE) < 0)
             return -1;
@@ -32187,6 +32371,10 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     for (scope = 0; scope < fd->scope_count; scope++) {
         fd->scopes[scope].first = -1;
     }
+    if (fd->has_parameter_expressions) {
+        /* special end of variable list marker for the argument scope */
+        fd->scopes[ARG_SCOPE_INDEX].first = ARG_SCOPE_END;
+    }
     for (idx = 0; idx < fd->var_count; idx++) {
         JSVarDef *vd = &fd->vars[idx];
         vd->scope_next = fd->scopes[vd->scope_level].first;
@@ -32194,12 +32382,12 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     }
     for (scope = 2; scope < fd->scope_count; scope++) {
         JSVarScope *sd = &fd->scopes[scope];
-        if (sd->first == -1)
+        if (sd->first < 0)
             sd->first = fd->scopes[sd->parent].first;
     }
     for (idx = 0; idx < fd->var_count; idx++) {
         JSVarDef *vd = &fd->vars[idx];
-        if (vd->scope_next == -1 && vd->scope_level > 1) {
+        if (vd->scope_next < 0 && vd->scope_level > 1) {
             scope = fd->scopes[vd->scope_level].parent;
             vd->scope_next = fd->scopes[scope].first;
         }
@@ -32571,7 +32759,8 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
                 /* Check if argument name duplicates a destructuring parameter */
                 /* XXX: should have a flag for such variables */
                 for (i = 0; i < fd->var_count; i++) {
-                    if (fd->vars[i].var_name == name)
+                    if (fd->vars[i].var_name == name &&
+                        fd->vars[i].scope_level == 0)
                         goto duplicate;
                 }
             }
@@ -32680,8 +32869,8 @@ static __exception int js_parse_function_decl2(JSParseState *s,
 
     if (fd->is_eval && fd->eval_type == JS_EVAL_TYPE_MODULE &&
         (func_type == JS_PARSE_FUNC_STATEMENT || func_type == JS_PARSE_FUNC_VAR)) {
-        JSHoistedDef *hf;
-        hf = find_hoisted_def(fd, func_name);
+        JSGlobalVar *hf;
+        hf = find_global_var(fd, func_name);
         /* XXX: should check scope chain */
         if (hf && hf->scope_level == fd->scope_level) {
             js_parse_error(s, "invalid redefinition of global identifier in module code");
@@ -32691,21 +32880,23 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     }
 
     if (func_type == JS_PARSE_FUNC_VAR) {
-        /* Create lexical name here so function closure contains it */
         if (!(fd->js_mode & JS_MODE_STRICT)
+        && func_kind == JS_FUNC_NORMAL
         &&  find_lexical_decl(ctx, fd, func_name, fd->scope_first, FALSE) < 0
         &&  !((func_idx = find_var(ctx, fd, func_name)) >= 0 && (func_idx & ARGUMENT_VAR_OFFSET))
         &&  !(func_name == JS_ATOM_arguments && fd->has_arguments_binding)) {
             create_func_var = TRUE;
         }
+        /* Create the lexical name here so that the function closure
+           contains it */
         if (fd->is_eval &&
             (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
              fd->eval_type == JS_EVAL_TYPE_MODULE) &&
-            fd->scope_level == 1) {
+            fd->scope_level == fd->body_scope) {
             /* avoid creating a lexical variable in the global
                scope. XXX: check annex B */
-            JSHoistedDef *hf;
-            hf = find_hoisted_def(fd, func_name);
+            JSGlobalVar *hf;
+            hf = find_global_var(fd, func_name);
             /* XXX: should check scope chain */
             if (hf && hf->scope_level == fd->scope_level) {
                 js_parse_error(s, "invalid redefinition of global identifier");
@@ -32780,6 +32971,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     
     /* parse arguments */
     fd->has_simple_parameter_list = TRUE;
+    fd->has_parameter_expressions = FALSE;
     has_opt_arg = FALSE;
     if (func_type == JS_PARSE_FUNC_ARROW && s->token.val == TOK_IDENT) {
         JSAtom name;
@@ -32792,13 +32984,30 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             goto fail;
         fd->defined_arg_count = 1;
     } else {
-        if (js_parse_expect(s, '('))
-            goto fail;
+        if (s->token.val == '(') {
+            int skip_bits;
+            /* if there is an '=' inside the parameter list, we
+               consider there is a parameter expression inside */
+            js_parse_skip_parens_token(s, &skip_bits, FALSE);
+            if (skip_bits & SKIP_HAS_ASSIGNMENT)
+                fd->has_parameter_expressions = TRUE;
+            if (next_token(s))
+                goto fail;
+        } else {
+            if (js_parse_expect(s, '('))
+                goto fail;
+        }
 
+        if (fd->has_parameter_expressions) {
+            fd->scope_level = -1; /* force no parent scope */
+            if (push_scope(s) < 0)
+                return -1;
+        }
+        
         while (s->token.val != ')') {
             JSAtom name;
             BOOL rest = FALSE;
-            int idx;
+            int idx, has_initializer;
 
             if (s->token.val == TOK_ELLIPSIS) {
                 fd->has_simple_parameter_list = FALSE;
@@ -32817,8 +33026,13 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     emit_op(s, OP_get_arg);
                     emit_u16(s, idx);
                 }
-                if (js_parse_destructuring_element(s, TOK_VAR, 1, TRUE, -1, TRUE))
+                has_initializer = js_parse_destructuring_element(s, fd->has_parameter_expressions ? TOK_LET : TOK_VAR, 1, TRUE, -1, TRUE);
+                if (has_initializer < 0)
                     goto fail;
+                if (has_initializer)
+                    has_opt_arg = TRUE;
+                if (!has_opt_arg)
+                    fd->defined_arg_count++;
             } else if (s->token.val == TOK_IDENT) {
                 if (s->token.u.ident.is_reserved) {
                     js_parse_error_reserved_identifier(s);
@@ -32829,6 +33043,11 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     js_parse_error_reserved_identifier(s);
                     goto fail;
                 }
+                if (fd->has_parameter_expressions) {
+                    if (define_var(s, fd, name, JS_VAR_DEF_LET) < 0)
+                        goto fail;
+                }
+                /* XXX: could avoid allocating an argument if rest is true */
                 idx = add_arg(ctx, fd, name);
                 if (idx < 0)
                     goto fail;
@@ -32837,70 +33056,55 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                 if (rest) {
                     emit_op(s, OP_rest);
                     emit_u16(s, idx);
+                    if (fd->has_parameter_expressions) {
+                        emit_op(s, OP_dup);
+                        emit_op(s, OP_scope_put_var_init);
+                        emit_atom(s, name);
+                        emit_u16(s, fd->scope_level);
+                    }
                     emit_op(s, OP_put_arg);
                     emit_u16(s, idx);
                     fd->has_simple_parameter_list = FALSE;
                     has_opt_arg = TRUE;
                 } else if (s->token.val == '=') {
+                    int label;
+                    
                     fd->has_simple_parameter_list = FALSE;
                     has_opt_arg = TRUE;
 
                     if (next_token(s))
                         goto fail;
 
-                    /* optimize `x = void 0` default value: no code needed */
-                    if (s->token.val == TOK_VOID) {
-                        JSParsePos pos;
-                        js_parse_get_pos(s, &pos);
-                        if (next_token(s))
-                            goto fail;
-                        if (s->token.val == TOK_NUMBER) {
-                            if (next_token(s))
-                                goto fail;
-                            if (s->token.val == ',') {
-                                if (next_token(s))
-                                    goto fail;
-                                continue;
-                            }
-                            if (s->token.val == ')') {
-                                continue;
-                            }
-                        }
-                        if (js_parse_seek_token(s, &pos))
-                            goto fail;
+                    label = new_label(s);
+                    emit_op(s, OP_get_arg);
+                    emit_u16(s, idx);
+                    emit_op(s, OP_dup);
+                    emit_op(s, OP_undefined);
+                    emit_op(s, OP_strict_eq);
+                    emit_goto(s, OP_if_false, label);
+                    emit_op(s, OP_drop);
+                    if (js_parse_assign_expr(s))
+                        goto fail;
+                    set_object_name(s, name);
+                    emit_op(s, OP_dup);
+                    emit_op(s, OP_put_arg);
+                    emit_u16(s, idx);
+                    emit_label(s, label);
+                    emit_op(s, OP_scope_put_var_init);
+                    emit_atom(s, name);
+                    emit_u16(s, fd->scope_level);
+                } else {
+                    if (!has_opt_arg) {
+                        fd->defined_arg_count++;
                     }
-#if 0
-                    /* XXX: not correct for eval code */
-                    /* Check for a default value of `undefined`
-                       to omit default argument processing */
-                    if (s->token.val == TOK_IDENT &&
-                        s->token.u.ident.atom == JS_ATOM_undefined &&
-                        fd->parent == NULL &&
-                        ((tok = peek_token(s, FALSE)) == ',' || tok == ')')) {
-                        if (next_token(s))  /* ignore undefined token */
-                            goto fail;
-                    } else
-#endif
-                    {
-                        int label = new_label(s);
-                        if (idx > 0) {
-                            emit_op(s, OP_set_arg_valid_upto);
-                            emit_u16(s, idx);
-                        }
+                    if (fd->has_parameter_expressions) {
+                        /* copy the argument to the argument scope */
                         emit_op(s, OP_get_arg);
                         emit_u16(s, idx);
-                        emit_op(s, OP_undefined);
-                        emit_op(s, OP_strict_eq);
-                        emit_goto(s, OP_if_false, label);
-                        if (js_parse_assign_expr(s, TRUE))
-                            goto fail;
-                        set_object_name(s, name);
-                        emit_op(s, OP_put_arg);
-                        emit_u16(s, idx);
-                        emit_label(s, label);
+                        emit_op(s, OP_scope_put_var_init);
+                        emit_atom(s, name);
+                        emit_u16(s, fd->scope_level);
                     }
-                } else if (!has_opt_arg) {
-                    fd->defined_arg_count++;
                 }
             } else {
                 js_parse_error(s, "missing formal parameter");
@@ -32922,6 +33126,41 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         }
     }
 
+    if (fd->has_parameter_expressions) {
+        int idx;
+
+        /* Copy the variables in the argument scope to the variable
+           scope (see FunctionDeclarationInstantiation() in spec). The
+           normal arguments are already present, so no need to copy
+           them. */
+        idx = fd->scopes[fd->scope_level].first;
+        while (idx >= 0) {
+            JSVarDef *vd = &fd->vars[idx];
+            if (vd->scope_level != fd->scope_level)
+                break;
+            if (find_var(ctx, fd, vd->var_name) < 0) {
+                if (add_var(ctx, fd, vd->var_name) < 0)
+                    goto fail;
+                vd = &fd->vars[idx]; /* fd->vars may have been reallocated */
+                emit_op(s, OP_scope_get_var);
+                emit_atom(s, vd->var_name);
+                emit_u16(s, fd->scope_level);
+                emit_op(s, OP_scope_put_var);
+                emit_atom(s, vd->var_name);
+                emit_u16(s, 0);
+            }
+            idx = vd->scope_next;
+        }
+        
+        /* the argument scope has no parent, hence we don't use pop_scope(s) */
+        emit_op(s, OP_leave_scope);
+        emit_u16(s, fd->scope_level);
+
+        /* set the variable scope as the current scope */
+        fd->scope_level = 0;
+        fd->scope_first = fd->scopes[fd->scope_level].first;
+    }
+    
     if (next_token(s))
         goto fail;
 
@@ -32933,7 +33172,8 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     /* in generators, yield expression is forbidden during the parsing
        of the arguments */
     fd->in_function_body = TRUE;
-    push_scope(s);  /* enter body scope: fd->scope_level = 1 */
+    push_scope(s);  /* enter body scope */
+    fd->body_scope = fd->scope_level;
 
     if (s->token.val == TOK_ARROW) {
         if (next_token(s))
@@ -32943,7 +33183,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             if (js_parse_function_check_names(s, fd, func_name))
                 goto fail;
 
-            if (js_parse_assign_expr(s, TRUE))
+            if (js_parse_assign_expr(s))
                 goto fail;
 
             if (func_kind != JS_FUNC_NORMAL)
@@ -33025,10 +33265,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             emit_u32(s, idx);
             if (create_func_var) {
                 if (s->cur_func->is_global_var) {
-                    JSHoistedDef *hf;
+                    JSGlobalVar *hf;
                     /* the global variable must be defined at the start of the
                        function */
-                    hf = add_hoisted_def(ctx, s->cur_func, -1, func_name, -1, FALSE);
+                    hf = add_global_var(ctx, s->cur_func, func_name);
                     if (!hf)
                         goto fail;
                     /* it is considered as defined at the top level
@@ -33058,7 +33298,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             }
             if (lexical_func_idx >= 0) {
                 /* lexical variable will be initialized upon entering scope */
-                s->cur_func->vars[lexical_func_idx].func_pool_or_scope_idx = idx;
+                s->cur_func->vars[lexical_func_idx].func_pool_idx = idx;
                 emit_op(s, OP_drop);
             } else {
                 /* store function object into its lexical name */
@@ -33074,17 +33314,23 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                 if (var_idx < 0)
                     goto fail;
                 /* the variable will be assigned at the top of the function */
-                if (!add_hoisted_def(ctx, s->cur_func, idx, JS_ATOM_NULL, var_idx, FALSE))
-                    goto fail;
+                if (var_idx & ARGUMENT_VAR_OFFSET) {
+                    s->cur_func->args[var_idx - ARGUMENT_VAR_OFFSET].func_pool_idx = idx;
+                } else {
+                    s->cur_func->vars[var_idx].func_pool_idx = idx;
+                }
             } else {
                 JSAtom func_var_name;
+                JSGlobalVar *hf;
                 if (func_name == JS_ATOM_NULL)
                     func_var_name = JS_ATOM__default_; /* export default */
                 else
                     func_var_name = func_name;
                 /* the variable will be assigned at the top of the function */
-                if (!add_hoisted_def(ctx, s->cur_func, idx, func_var_name, -1, FALSE))
+                hf = add_global_var(ctx, s->cur_func, func_var_name);
+                if (!hf)
                     goto fail;
+                hf->cpool_idx = idx;
                 if (export_flag != JS_PARSE_EXPORT_NONE) {
                     if (!add_export_entry(s, s->cur_func->module, func_var_name,
                                           export_flag == JS_PARSE_EXPORT_NAMED ? func_var_name : JS_ATOM_default, JS_EXPORT_TYPE_LOCAL))
@@ -33186,7 +33432,7 @@ static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
         JS_FreeValue(ctx, fun_obj);
         if (js_create_module_function(ctx, m) < 0)
             goto fail;
-        if (js_instantiate_module(ctx, m) < 0)
+        if (js_link_module(ctx, m) < 0)
             goto fail;
         ret_val = js_evaluate_module(ctx, m);
         if (JS_IsException(ret_val)) {
@@ -33308,7 +33554,8 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
     s->allow_html_comments = !s->is_module;
 
     push_scope(s); /* body scope */
-
+    fd->body_scope = fd->scope_level;
+    
     err = js_parse_program(s);
     if (err) {
     fail:
@@ -33371,19 +33618,27 @@ static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
 
 }
 
-JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
-                const char *filename, int eval_flags)
+JSValue JS_EvalThis(JSContext *ctx, JSValueConst this_obj,
+                    const char *input, size_t input_len,
+                    const char *filename, int eval_flags)
 {
     int eval_type = eval_flags & JS_EVAL_TYPE_MASK;
     JSValue ret;
 
     assert(eval_type == JS_EVAL_TYPE_GLOBAL ||
            eval_type == JS_EVAL_TYPE_MODULE);
-    ret = JS_EvalInternal(ctx, ctx->global_obj, input, input_len, filename,
+    ret = JS_EvalInternal(ctx, this_obj, input, input_len, filename,
                           eval_flags, -1);
     return ret;
 }
 
+JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
+                const char *filename, int eval_flags)
+{
+    return JS_EvalThis(ctx, ctx->global_obj, input, input_len, filename,
+                       eval_flags);
+}
+
 int JS_ResolveModule(JSContext *ctx, JSValueConst obj)
 {
     if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
@@ -33980,7 +34235,6 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
             bc_put_leb128(s, vd->scope_next + 1);
             flags = idx = 0;
             bc_set_flags(&flags, &idx, vd->var_kind, 4);
-            bc_set_flags(&flags, &idx, vd->is_func_var, 1);
             bc_set_flags(&flags, &idx, vd->is_const, 1);
             bc_set_flags(&flags, &idx, vd->is_lexical, 1);
             bc_set_flags(&flags, &idx, vd->is_captured, 1);
@@ -34971,7 +35225,6 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
                 goto fail;
             idx = 0;
             vd->var_kind = bc_get_flags(v8, &idx, 4);
-            vd->is_func_var = bc_get_flags(v8, &idx, 1);
             vd->is_const = bc_get_flags(v8, &idx, 1);
             vd->is_lexical = bc_get_flags(v8, &idx, 1);
             vd->is_captured = bc_get_flags(v8, &idx, 1);
@@ -35628,16 +35881,39 @@ static JSAtom find_atom(JSContext *ctx, const char *name)
     return atom;
 }
 
-static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
-                                          JSAtom atom, void *opaque)
+static JSValue JS_InstantiateFunctionListItem2(JSContext *ctx, JSObject *p,
+                                               JSAtom atom, void *opaque)
 {
     const JSCFunctionListEntry *e = opaque;
-    JSValueConst obj = JS_MKPTR(JS_TAG_OBJECT, p);
+    JSValue val;
+
+    switch(e->def_type) {
+    case JS_DEF_CFUNC:
+        val = JS_NewCFunction2(ctx, e->u.func.cfunc.generic,
+                               e->name, e->u.func.length, e->u.func.cproto, e->magic);
+        break;
+    case JS_DEF_PROP_STRING:
+        val = JS_NewAtomString(ctx, e->u.str);
+        break;
+    case JS_DEF_OBJECT:
+        val = JS_NewObject(ctx);
+        JS_SetPropertyFunctionList(ctx, val, e->u.prop_list.tab, e->u.prop_list.len);
+        break;
+    default:
+        abort();
+    }
+    return val;
+}
+
+static int JS_InstantiateFunctionListItem(JSContext *ctx, JSValueConst obj,
+                                          JSAtom atom,
+                                          const JSCFunctionListEntry *e)
+{
     JSValue val;
     int prop_flags = e->prop_flags;
 
     switch(e->def_type) {
-    case JS_DEF_ALIAS:
+    case JS_DEF_ALIAS: /* using autoinit for aliases is not safe */
         {
             JSAtom atom1 = find_atom(ctx, e->u.alias.name);
             switch (e->u.alias.base) {
@@ -35654,12 +35930,16 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
                 abort();
             }
             JS_FreeAtom(ctx, atom1);
-            goto setval;
+            if (atom == JS_ATOM_Symbol_toPrimitive) {
+                /* Symbol.toPrimitive functions are not writable */
+                prop_flags = JS_PROP_CONFIGURABLE;
+            } else if (atom == JS_ATOM_Symbol_hasInstance) {
+                /* Function.prototype[Symbol.hasInstance] is not writable nor configurable */
+                prop_flags = 0;
+            }
         }
+        break;
     case JS_DEF_CFUNC:
-        val = JS_NewCFunction2(ctx, e->u.func.cfunc.generic,
-                               e->name, e->u.func.length, e->u.func.cproto, e->magic);
-    setval:
         if (atom == JS_ATOM_Symbol_toPrimitive) {
             /* Symbol.toPrimitive functions are not writable */
             prop_flags = JS_PROP_CONFIGURABLE;
@@ -35667,8 +35947,10 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
             /* Function.prototype[Symbol.hasInstance] is not writable nor configurable */
             prop_flags = 0;
         }
-        break;
-    case JS_DEF_CGETSET:
+        JS_DefineAutoInitProperty(ctx, obj, atom, JS_AUTOINIT_ID_PROP,
+                                  (void *)e, prop_flags);
+        return 0;
+    case JS_DEF_CGETSET: /* XXX: use autoinit again ? */
     case JS_DEF_CGETSET_MAGIC:
         {
             JSValue getter, setter;
@@ -35692,9 +35974,6 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
             return 0;
         }
         break;
-    case JS_DEF_PROP_STRING:
-        val = JS_NewAtomString(ctx, e->u.str);
-        break;
     case JS_DEF_PROP_INT32:
         val = JS_NewInt32(ctx, e->u.i32);
         break;
@@ -35707,10 +35986,11 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
     case JS_DEF_PROP_UNDEFINED:
         val = JS_UNDEFINED;
         break;
+    case JS_DEF_PROP_STRING:
     case JS_DEF_OBJECT:
-        val = JS_NewObject(ctx);
-        JS_SetPropertyFunctionList(ctx, val, e->u.prop_list.tab, e->u.prop_list.len);
-        break;
+        JS_DefineAutoInitProperty(ctx, obj, atom, JS_AUTOINIT_ID_PROP,
+                                  (void *)e, prop_flags);
+        return 0;
     default:
         abort();
     }
@@ -35721,36 +36001,12 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSObject *p,
 void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
                                 const JSCFunctionListEntry *tab, int len)
 {
-    int i, prop_flags;
+    int i;
 
     for (i = 0; i < len; i++) {
         const JSCFunctionListEntry *e = &tab[i];
         JSAtom atom = find_atom(ctx, e->name);
-
-        switch (e->def_type) {
-        case JS_DEF_CFUNC:
-        case JS_DEF_CGETSET:
-        case JS_DEF_CGETSET_MAGIC:
-        case JS_DEF_PROP_STRING:
-        case JS_DEF_ALIAS:
-        case JS_DEF_OBJECT:
-            prop_flags = JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE | (e->prop_flags & JS_PROP_ENUMERABLE);
-            JS_DefineAutoInitProperty(ctx, obj, atom,
-                                      JS_AUTOINIT_ID_PROP,
-                                      (void *)e, prop_flags);
-            break;
-        case JS_DEF_PROP_INT32:
-        case JS_DEF_PROP_INT64:
-        case JS_DEF_PROP_DOUBLE:
-        case JS_DEF_PROP_UNDEFINED:
-            {
-                JSObject *p = JS_VALUE_GET_OBJ(obj);
-                JS_InstantiateFunctionListItem(ctx, p, atom, (void *)e);
-            }
-            break;
-        default:
-            abort();
-        }
+        JS_InstantiateFunctionListItem(ctx, obj, atom, e);
         JS_FreeAtom(ctx, atom);
     }
 }
@@ -37262,6 +37518,8 @@ static JSValue *build_arg_list(JSContext *ctx, uint32_t *plen,
     return tab;
 }
 
+/* magic value: 0 = normal apply, 1 = apply for constructor, 2 =
+   Reflect.apply */
 static JSValue js_function_apply(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv, int magic)
 {
@@ -37273,14 +37531,14 @@ static JSValue js_function_apply(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     this_arg = argv[0];
     array_arg = argv[1];
-    if (JS_VALUE_GET_TAG(array_arg) == JS_TAG_UNDEFINED ||
-        JS_VALUE_GET_TAG(array_arg) == JS_TAG_NULL) {
+    if ((JS_VALUE_GET_TAG(array_arg) == JS_TAG_UNDEFINED ||
+         JS_VALUE_GET_TAG(array_arg) == JS_TAG_NULL) && magic != 2) {
         return JS_Call(ctx, this_val, this_arg, 0, NULL);
     }
     tab = build_arg_list(ctx, &len, array_arg);
     if (!tab)
         return JS_EXCEPTION;
-    if (magic) {
+    if (magic & 1) {
         ret = JS_CallConstructor2(ctx, this_val, this_arg, len, (JSValueConst *)tab);
     } else {
         ret = JS_Call(ctx, this_val, this_arg, len, (JSValueConst *)tab);
@@ -37650,7 +37908,7 @@ static JSValue js_array_constructor(JSContext *ctx, JSValueConst new_target,
         return obj;
     if (argc == 1 && JS_IsNumber(argv[0])) {
         uint32_t len;
-        if (JS_ToArrayLengthFree(ctx, &len, JS_DupValue(ctx, argv[0])))
+        if (JS_ToArrayLengthFree(ctx, &len, JS_DupValue(ctx, argv[0]), TRUE))
             goto fail;
         if (JS_SetProperty(ctx, obj, JS_ATOM_length, JS_NewUint32(ctx, len)) < 0)
             goto fail;
@@ -39659,46 +39917,6 @@ static int js_string_get_own_property(JSContext *ctx,
     return FALSE;
 }
 
-static uint32_t js_string_obj_get_length(JSContext *ctx,
-                                         JSValueConst obj)
-{
-    JSObject *p;
-    JSString *p1;
-    uint32_t len = 0;
-
-    /* This is a class exotic method: obj class_id is JS_CLASS_STRING */
-    p = JS_VALUE_GET_OBJ(obj);
-    if (JS_VALUE_GET_TAG(p->u.object_data) == JS_TAG_STRING) {
-        p1 = JS_VALUE_GET_STRING(p->u.object_data);
-        len = p1->len;
-    }
-    return len;
-}
-
-static int js_string_get_own_property_names(JSContext *ctx,
-                                            JSPropertyEnum **ptab,
-                                            uint32_t *plen,
-                                            JSValueConst obj)
-{
-    JSPropertyEnum *tab;
-    uint32_t len, i;
-
-    len = js_string_obj_get_length(ctx, obj);
-    tab = NULL;
-    if (len > 0) {
-        /* do not allocate 0 bytes */
-        tab = js_malloc(ctx, sizeof(JSPropertyEnum) * len);
-        if (!tab)
-            return -1;
-        for(i = 0; i < len; i++) {
-            tab[i].atom = __JS_AtomFromUInt32(i);
-        }
-    }
-    *ptab = tab;
-    *plen = len;
-    return 0;
-}
-
 static int js_string_define_own_property(JSContext *ctx,
                                          JSValueConst this_obj,
                                          JSAtom prop, JSValueConst val,
@@ -39755,7 +39973,6 @@ static int js_string_delete_property(JSContext *ctx,
 
 static const JSClassExoticMethods js_string_exotic_methods = {
     .get_own_property = js_string_get_own_property,
-    .get_own_property_names = js_string_get_own_property_names,
     .define_own_property = js_string_define_own_property,
     .delete_property = js_string_delete_property,
 };
@@ -40359,15 +40576,17 @@ static JSValue js_string___GetSubstitution(JSContext *ctx, JSValueConst this_val
             string_buffer_concat(b, sp, position + matched_len, sp->len);
         } else if (c >= '0' && c <= '9') {
             k = c - '0';
-            c1 = string_get(rp, j);
-            if (c1 >= '0' && c1 <= '9') {
-                /* This behavior is specified in ES6 and refined in ECMA 2019 */
-                /* ECMA 2019 does not have the extra test, but
-                   Test262 S15.5.4.11_A3_T1..3 require this behavior */
-                k1 = k * 10 + c1 - '0';
-                if (k1 >= 1 && k1 < captures_len) {
-                    k = k1;
-                    j++;
+            if (j < len) {
+                c1 = string_get(rp, j);
+                if (c1 >= '0' && c1 <= '9') {
+                    /* This behavior is specified in ES6 and refined in ECMA 2019 */
+                    /* ECMA 2019 does not have the extra test, but
+                       Test262 S15.5.4.11_A3_T1..3 require this behavior */
+                    k1 = k * 10 + c1 - '0';
+                    if (k1 >= 1 && k1 < captures_len) {
+                        k = k1;
+                        j++;
+                    }
                 }
             }
             if (k >= 1 && k < captures_len) {
@@ -42805,7 +43024,8 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
         tab = JS_NewArray(ctx);
         if (JS_IsException(tab))
             goto exception;
-        if (JS_SetPropertyInt64(ctx, tab, 0, JS_DupValue(ctx, matched)) < 0)
+        if (JS_DefinePropertyValueInt64(ctx, tab, 0, JS_DupValue(ctx, matched),
+                                        JS_PROP_C_W_E | JS_PROP_THROW) < 0)
             goto exception;
         for(n = 1; n < nCaptures; n++) {
             JSValue capN;
@@ -42817,7 +43037,8 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
                 if (JS_IsException(capN))
                     goto exception;
             }
-            if (JS_SetPropertyInt64(ctx, tab, n, capN) < 0)
+            if (JS_DefinePropertyValueInt64(ctx, tab, n, capN,
+                                            JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                 goto exception;
         }
         JS_FreeValue(ctx, namedCaptures);
@@ -42825,12 +43046,12 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(namedCaptures))
             goto exception;
         if (functionalReplace) {
-            if (JS_SetPropertyInt64(ctx, tab, n++, JS_NewInt32(ctx, position)) < 0)
+            if (JS_DefinePropertyValueInt64(ctx, tab, n++, JS_NewInt32(ctx, position), JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                 goto exception;
-            if (JS_SetPropertyInt64(ctx, tab, n++, JS_DupValue(ctx, str)) < 0)
+            if (JS_DefinePropertyValueInt64(ctx, tab, n++, JS_DupValue(ctx, str), JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                 goto exception;
             if (!JS_IsUndefined(namedCaptures)) {
-                if (JS_SetPropertyInt64(ctx, tab, n++, JS_DupValue(ctx, namedCaptures)) < 0)
+                if (JS_DefinePropertyValueInt64(ctx, tab, n++, JS_DupValue(ctx, namedCaptures), JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                     goto exception;
             }
             args[0] = JS_UNDEFINED;
@@ -42917,8 +43138,10 @@ static JSValue js_regexp_Symbol_search(JSContext *ctx, JSValueConst this_val,
     if (js_same_value(ctx, currentLastIndex, previousLastIndex)) {
         JS_FreeValue(ctx, previousLastIndex);
     } else {
-        if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, previousLastIndex) < 0)
+        if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, previousLastIndex) < 0) {
+            previousLastIndex = JS_UNDEFINED;
             goto exception;
+        }
     }
     JS_FreeValue(ctx, str);
     JS_FreeValue(ctx, currentLastIndex);
@@ -43023,7 +43246,8 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
                 sub = js_sub_string(ctx, strp, p, q);
                 if (JS_IsException(sub))
                     goto exception;
-                if (JS_SetPropertyInt64(ctx, A, lengthA++, sub) < 0)
+                if (JS_DefinePropertyValueInt64(ctx, A, lengthA++, sub,
+                                                JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                     goto exception;
                 if (lengthA == lim)
                     goto done;
@@ -43034,7 +43258,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
                     sub = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, z, i));
                     if (JS_IsException(sub))
                         goto exception;
-                    if (JS_SetPropertyInt64(ctx, A, lengthA++, sub) < 0)
+                    if (JS_DefinePropertyValueInt64(ctx, A, lengthA++, sub, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                         goto exception;
                     if (lengthA == lim)
                         goto done;
@@ -43049,7 +43273,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     sub = js_sub_string(ctx, strp, p, size);
     if (JS_IsException(sub))
         goto exception;
-    if (JS_SetPropertyInt64(ctx, A, lengthA++, sub) < 0)
+    if (JS_DefinePropertyValueInt64(ctx, A, lengthA++, sub, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
         goto exception;
     goto done;
 exception:
@@ -43829,7 +44053,7 @@ void JS_AddIntrinsicJSON(JSContext *ctx)
 static JSValue js_reflect_apply(JSContext *ctx, JSValueConst this_val,
                                 int argc, JSValueConst *argv)
 {
-    return js_function_apply(ctx, argv[0], max_int(0, argc - 1), argv + 1, 0);
+    return js_function_apply(ctx, argv[0], max_int(0, argc - 1), argv + 1, 2);
 }
 
 static JSValue js_reflect_construct(JSContext *ctx, JSValueConst this_val,
@@ -46772,26 +46996,15 @@ static JSValue js_promise_then_finally_func(JSContext *ctx, JSValueConst this_va
 {
     JSValueConst ctor = func_data[0];
     JSValueConst onFinally = func_data[1];
-    JSValue res, promise, resolving_funcs[2], ret, then_func;
+    JSValue res, promise, ret, then_func;
 
     res = JS_Call(ctx, onFinally, JS_UNDEFINED, 0, NULL);
     if (JS_IsException(res))
         return res;
-    promise = js_new_promise_capability(ctx, resolving_funcs, ctor);
-    if (JS_IsException(promise)) {
-        JS_FreeValue(ctx, res);
-        return JS_EXCEPTION;
-    }
-    ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
-                  1, (JSValueConst*)&res);
+    promise = js_promise_resolve(ctx, ctor, 1, (JSValueConst *)&res, 0);
     JS_FreeValue(ctx, res);
-    JS_FreeValue(ctx, resolving_funcs[0]);
-    JS_FreeValue(ctx, resolving_funcs[1]);
-    if (JS_IsException(ret)) {
-        JS_FreeValue(ctx, promise);
-        return ret;
-    }
-    JS_FreeValue(ctx, ret);
+    if (JS_IsException(promise))
+        return promise;
     if (magic == 0) {
         then_func = JS_NewCFunctionData(ctx, js_promise_finally_value_thunk, 0,
                                         0, 1, argv);
@@ -47503,7 +47716,7 @@ static JSValue JS_SetThisTimeValue(JSContext *ctx, JSValueConst this_val, double
         JSObject *p = JS_VALUE_GET_OBJ(this_val);
         if (p->class_id == JS_CLASS_DATE) {
             JS_FreeValue(ctx, p->u.object_data);
-            p->u.object_data = __JS_NewFloat64(ctx, v);
+            p->u.object_data = JS_NewFloat64(ctx, v);
             return JS_DupValue(ctx, p->u.object_data);
         }
     }
@@ -47547,7 +47760,7 @@ static char const month_names[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
 static char const day_names[] = "SunMonTueWedThuFriSat";
 
 static __exception int get_date_fields(JSContext *ctx, JSValueConst obj,
-                                       int64_t fields[9], int is_local, int force)
+                                       double fields[9], int is_local, int force)
 {
     double dval;
     int64_t d, days, wd, y, i, md, h, m, s, ms, tz = 0;
@@ -47606,12 +47819,18 @@ static double time_clip(double t) {
         return NAN;
 }
 
-static double set_date_fields(int64_t fields[], int is_local) {
-    int64_t days, y, m, md, h, d, i;
-
-    i = fields[1];
-    m = math_mod(i, 12);
-    y = fields[0] + (i - m) / 12;
+/* The spec mandates the use of 'double' and it fixes the order
+   of the operations */
+static double set_date_fields(double fields[], int is_local) {
+    int64_t y;
+    double days, d, h, m1;
+    int i, m, md;
+    
+    m1 = fields[1];
+    m = fmod(m1, 12);
+    if (m < 0)
+        m += 12;
+    y = (int64_t)(fields[0] + floor(m1 / 12));
     days = days_from_year(y);
 
     for(i = 0; i < m; i++) {
@@ -47621,7 +47840,8 @@ static double set_date_fields(int64_t fields[], int is_local) {
         days += md;
     }
     days += fields[2] - 1;
-    h = ((fields[3] * 60 + fields[4]) * 60 + fields[5]) * 1000 + fields[6];
+    h = fields[3] * 3600000 + fields[4] * 60000 + 
+        fields[5] * 1000 + fields[6];
     d = days * 86400000 + h;
     if (is_local)
         d += getTimezoneOffset(d) * 60000;
@@ -47632,7 +47852,7 @@ static JSValue get_date_field(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
 {
     // get_date_field(obj, n, is_local)
-    int64_t fields[9];
+    double fields[9];
     int res, n, is_local;
 
     is_local = magic & 0x0F;
@@ -47646,14 +47866,14 @@ static JSValue get_date_field(JSContext *ctx, JSValueConst this_val,
     if (magic & 0x100) {    // getYear
         fields[0] -= 1900;
     }
-    return JS_NewInt64(ctx, fields[n]);
+    return JS_NewFloat64(ctx, fields[n]);
 }
 
 static JSValue set_date_field(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
 {
     // _field(obj, first_field, end_field, args, is_local)
-    int64_t fields[9];
+    double fields[9];
     int res, first_field, end_field, is_local, i, n;
     double d, a;
 
@@ -47695,7 +47915,7 @@ static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
 {
     // _string(obj, fmt, part)
     char buf[64];
-    int64_t fields[9];
+    double fields[9];
     int res, fmt, part, pos;
     int y, mon, d, h, m, s, ms, wd, tz;
 
@@ -47843,7 +48063,7 @@ static JSValue js_date_constructor(JSContext *ctx, JSValueConst new_target,
         }
         val = time_clip(val);
     } else {
-        int64_t fields[] = { 0, 0, 1, 0, 0, 0, 0 };
+        double fields[] = { 0, 0, 1, 0, 0, 0, 0 };
         if (n > 7)
             n = 7;
         for(i = 0; i < n; i++) {
@@ -47862,12 +48082,12 @@ static JSValue js_date_constructor(JSContext *ctx, JSValueConst new_target,
     JSValueConst args[3];
     args[0] = new_target;
     args[1] = ctx->class_proto[JS_CLASS_DATE];
-    args[2] = __JS_NewFloat64(ctx, val);
+    args[2] = JS_NewFloat64(ctx, val);
     rv = js___date_create(ctx, JS_UNDEFINED, 3, args);
 #else
     rv = js_create_from_ctor(ctx, new_target, JS_CLASS_DATE);
     if (!JS_IsException(rv))
-        JS_SetObjectData(ctx, rv, __JS_NewFloat64(ctx, val));
+        JS_SetObjectData(ctx, rv, JS_NewFloat64(ctx, val));
 #endif
     if (!JS_IsException(rv) && JS_IsUndefined(new_target)) {
         /* invoked as a function, return (new Date()).toString(); */
@@ -47883,7 +48103,7 @@ static JSValue js_Date_UTC(JSContext *ctx, JSValueConst this_val,
                            int argc, JSValueConst *argv)
 {
     // UTC(y, mon, d, h, m, s, ms)
-    int64_t fields[] = { 0, 0, 1, 0, 0, 0, 0 };
+    double fields[] = { 0, 0, 1, 0, 0, 0, 0 };
     int i, n;
     double a;
 
@@ -47901,7 +48121,7 @@ static JSValue js_Date_UTC(JSContext *ctx, JSValueConst this_val,
         if (i == 0 && fields[0] >= 0 && fields[0] < 100)
             fields[0] += 1900;
     }
-    return __JS_NewFloat64(ctx, set_date_fields(fields, 0));
+    return JS_NewFloat64(ctx, set_date_fields(fields, 0));
 }
 
 static void string_skip_spaces(JSString *sp, int *pp) {
@@ -48011,6 +48231,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
     // parse(s)
     JSValue s, rv;
     int64_t fields[] = { 0, 1, 1, 0, 0, 0, 0 };
+    double fields1[7];
     int64_t tz, hh, mm;
     double d;
     int p, i, c, sgn;
@@ -48123,8 +48344,10 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
             }
         }
     }
-    d = set_date_fields(fields, is_local) - tz * 60000;
-    rv = __JS_NewFloat64(ctx, d);
+    for(i = 0; i < 7; i++)
+        fields1[i] = fields[i];
+    d = set_date_fields(fields1, is_local) - tz * 60000;
+    rv = JS_NewFloat64(ctx, d);
 
 done:
     JS_FreeValue(ctx, s);
@@ -48194,7 +48417,7 @@ static JSValue js_date_getTime(JSContext *ctx, JSValueConst this_val,
 
     if (JS_ThisTimeValue(ctx, &v, this_val))
         return JS_EXCEPTION;
-    return __JS_NewFloat64(ctx, v);
+    return JS_NewFloat64(ctx, v);
 }
 
 static JSValue js_date_setTime(JSContext *ctx, JSValueConst this_val,
@@ -48223,7 +48446,7 @@ static JSValue js_date_setYear(JSContext *ctx, JSValueConst this_val,
         if (y >= 0 && y < 100)
             y += 1900;
     }
-    args[0] = __JS_NewFloat64(ctx, y);
+    args[0] = JS_NewFloat64(ctx, y);
     return set_date_field(ctx, this_val, 1, args, 0x011);
 }
 
@@ -48714,9 +48937,11 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
 }
 
 static JSValue js_bigint_constructor(JSContext *ctx,
-                                     JSValueConst this_val,
+                                     JSValueConst new_target,
                                      int argc, JSValueConst *argv)
 {
+    if (!JS_IsUndefined(new_target))
+        return JS_ThrowTypeError(ctx, "not a constructor");
     return JS_ToBigIntCtorFree(ctx, JS_DupValue(ctx, argv[0]));
 }
 
@@ -48962,7 +49187,7 @@ static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
 void JS_AddIntrinsicBigInt(JSContext *ctx)
 {
     JSRuntime *rt = ctx->rt;
-    JSValue obj1;
+    JSValueConst obj1;
 
     rt->bigint_ops.to_string = js_bigint_to_string;
     rt->bigint_ops.from_string = js_string_to_bigint;
@@ -48974,9 +49199,8 @@ void JS_AddIntrinsicBigInt(JSContext *ctx)
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
                                js_bigint_proto_funcs,
                                countof(js_bigint_proto_funcs));
-    obj1 = JS_NewCFunction(ctx, js_bigint_constructor, "BigInt", 1);
-    JS_NewGlobalCConstructor2(ctx, obj1, "BigInt",
-                              ctx->class_proto[JS_CLASS_BIG_INT]);
+    obj1 = JS_NewGlobalCConstructor(ctx, "BigInt", js_bigint_constructor, 1,
+                                    ctx->class_proto[JS_CLASS_BIG_INT]);
     JS_SetPropertyFunctionList(ctx, obj1, js_bigint_funcs,
                                countof(js_bigint_funcs));
 }
@@ -49194,10 +49418,12 @@ static const JSCFunctionListEntry js_bigfloat_proto_funcs[] = {
 };
 
 static JSValue js_bigfloat_constructor(JSContext *ctx,
-                                       JSValueConst this_val,
+                                       JSValueConst new_target,
                                        int argc, JSValueConst *argv)
 {
     JSValue val;
+    if (!JS_IsUndefined(new_target))
+        return JS_ThrowTypeError(ctx, "not a constructor");
     if (argc == 0) {
         bf_t *r;
         val = JS_NewBigFloat(ctx);
@@ -49858,8 +50084,7 @@ static const JSCFunctionListEntry js_float_env_proto_funcs[] = {
 void JS_AddIntrinsicBigFloat(JSContext *ctx)
 {
     JSRuntime *rt = ctx->rt;
-    JSValue obj1;
-    JSValueConst obj2;
+    JSValueConst obj1;
     
     rt->bigfloat_ops.to_string = js_bigfloat_to_string;
     rt->bigfloat_ops.from_string = js_string_to_bigfloat;
@@ -49873,9 +50098,8 @@ void JS_AddIntrinsicBigFloat(JSContext *ctx)
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT],
                                js_bigfloat_proto_funcs,
                                countof(js_bigfloat_proto_funcs));
-    obj1 = JS_NewCFunction(ctx, js_bigfloat_constructor, "BigFloat", 1);
-    JS_NewGlobalCConstructor2(ctx, obj1, "BigFloat",
-                              ctx->class_proto[JS_CLASS_BIG_FLOAT]);
+    obj1 = JS_NewGlobalCConstructor(ctx, "BigFloat", js_bigfloat_constructor, 1,
+                                    ctx->class_proto[JS_CLASS_BIG_FLOAT]);
     JS_SetPropertyFunctionList(ctx, obj1, js_bigfloat_funcs,
                                countof(js_bigfloat_funcs));
 
@@ -49883,10 +50107,10 @@ void JS_AddIntrinsicBigFloat(JSContext *ctx)
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FLOAT_ENV],
                                js_float_env_proto_funcs,
                                countof(js_float_env_proto_funcs));
-    obj2 = JS_NewGlobalCConstructorOnly(ctx, "BigFloatEnv",
+    obj1 = JS_NewGlobalCConstructorOnly(ctx, "BigFloatEnv",
                                         js_float_env_constructor, 1,
                                         ctx->class_proto[JS_CLASS_FLOAT_ENV]);
-    JS_SetPropertyFunctionList(ctx, obj2, js_float_env_funcs,
+    JS_SetPropertyFunctionList(ctx, obj1, js_float_env_funcs,
                                countof(js_float_env_funcs));
 }
 
@@ -49989,10 +50213,12 @@ static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
 }
 
 static JSValue js_bigdecimal_constructor(JSContext *ctx,
-                                         JSValueConst this_val,
+                                         JSValueConst new_target,
                                          int argc, JSValueConst *argv)
 {
     JSValue val;
+    if (!JS_IsUndefined(new_target))
+        return JS_ThrowTypeError(ctx, "not a constructor");
     if (argc == 0) {
         bfdec_t *r;
         val = JS_NewBigDecimal(ctx);
@@ -50348,7 +50574,7 @@ static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
 void JS_AddIntrinsicBigDecimal(JSContext *ctx)
 {
     JSRuntime *rt = ctx->rt;
-    JSValue obj1;
+    JSValueConst obj1;
 
     rt->bigdecimal_ops.to_string = js_bigdecimal_to_string;
     rt->bigdecimal_ops.from_string = js_string_to_bigdecimal;
@@ -50360,9 +50586,9 @@ void JS_AddIntrinsicBigDecimal(JSContext *ctx)
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL],
                                js_bigdecimal_proto_funcs,
                                countof(js_bigdecimal_proto_funcs));
-    obj1 = JS_NewCFunction(ctx, js_bigdecimal_constructor, "BigDecimal", 1);
-    JS_NewGlobalCConstructor2(ctx, obj1, "BigDecimal",
-                              ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
+    obj1 = JS_NewGlobalCConstructor(ctx, "BigDecimal",
+                                    js_bigdecimal_constructor, 1,
+                                    ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
     JS_SetPropertyFunctionList(ctx, obj1, js_bigdecimal_funcs,
                                countof(js_bigdecimal_funcs));
 }
@@ -50818,8 +51044,7 @@ static JSValue js_array_buffer_get_byteLength(JSContext *ctx,
     JSArrayBuffer *abuf = JS_GetOpaque2(ctx, this_val, class_id);
     if (!abuf)
         return JS_EXCEPTION;
-    if (abuf->detached)
-        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    /* return 0 if detached */
     return JS_NewUint32(ctx, abuf->byte_length);
 }
 
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index bb84829b96..92457a2f50 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -776,7 +776,10 @@ JS_BOOL JS_DetectModule(const char *input, size_t input_len);
 /* 'input' must be zero terminated i.e. input[input_len] = '\0'. */
 JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
                 const char *filename, int eval_flags);
-JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);
+/* same as JS_Eval() but with an explicit 'this_obj' parameter */
+JSValue JS_EvalThis(JSContext *ctx, JSValueConst this_obj,
+                    const char *input, size_t input_len,
+                    const char *filename, int eval_flags);
 JSValue JS_GetGlobalObject(JSContext *ctx);
 int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj);
 int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
@@ -885,7 +888,9 @@ uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
 #define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */
 JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                       int flags);
-
+/* instantiate and evaluate a bytecode function. Only used when
+   reading a script or module with JS_ReadObject() */
+JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);
 /* load the dependencies of the module 'obj'. Useful when JS_ReadObject()
    returns a module. */
 int JS_ResolveModule(JSContext *ctx, JSValueConst obj);

From cba3455bab1117fff09e693711f574a4047bd15e Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 16 Jan 2021 15:08:31 +0300
Subject: [PATCH 078/185] argc capture fix

---
 quickjspp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f6f9cb0706..3dad897a72 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1274,6 +1274,7 @@ struct js_traits<std::function<R(Args...)>>
         else 
         {
             return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }](Args&& ... args)->R {
+                const int argc = sizeof...(Args);
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));

From 3be1175d276f3abb6e421a866a01707905e78ca5 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 16 Jan 2021 15:15:10 +0300
Subject: [PATCH 079/185] gcc-8 constexpr workaround

---
 quickjspp.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 3dad897a72..f67065482f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1079,7 +1079,11 @@ class Context
             template <auto FGet, auto FSet = nullptr>
             class_registrar& property(const char * name)
             {
-                if /*constexpr*/ (FSet == nullptr)
+#if defined(__GNUC__) && __GNUC__ <= 8 // gcc-8 workaround
+                if(FSet == nullptr)
+#else
+                if constexpr (FSet == nullptr)
+#endif
                     prototype.add_getter<FGet>(name);
                 else
                     prototype.add_getter_setter<FGet, FSet>(name);

From c57f5026d96a74857ef8ce6b19262423524979b4 Mon Sep 17 00:00:00 2001
From: William <wflohry@wflohry.com>
Date: Sun, 7 Feb 2021 14:36:14 -0600
Subject: [PATCH 080/185] Basic support for std::variant

---
 quickjs/quickjs.c |  11 +++++
 quickjs/quickjs.h |   1 +
 quickjspp.hpp     | 103 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 115 insertions(+)

diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index a39ff8f66c..e09ba90bc4 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -53798,3 +53798,14 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
     JS_AddIntrinsicAtomics(ctx);
 #endif
 }
+
+JSClassID JS_GetClassID(JSValue v)
+{
+    JSObject *p;
+
+    if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
+        return 0;
+    p = JS_VALUE_GET_OBJ(v);
+    assert(p != 0);
+    return p->class_id;
+}
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 92457a2f50..bfe130708c 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -493,6 +493,7 @@ typedef struct JSClassDef {
 } JSClassDef;
 
 JSClassID JS_NewClassID(JSClassID *pclass_id);
+JSClassID JS_GetClassID(JSValueConst v);
 int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);
 int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
 
diff --git a/quickjspp.hpp b/quickjspp.hpp
index f67065482f..9abe1057c8 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -13,6 +13,7 @@
 #include <tuple>
 #include <functional>
 #include <stdexcept>
+#include <variant>
 
 namespace qjs {
 
@@ -222,6 +223,108 @@ struct js_traits<const char *>
     }
 };
 
+/** Conversion from const std::variant */
+template <typename ... Ts>
+struct js_traits<std::variant<Ts...>>
+{
+    static JSValue wrap(JSContext * ctx, const std::variant<Ts...> &value) noexcept
+    {
+        return std::visit([](auto && value){
+            using T = std::decay_t<decltype(value)>;
+            return js_traits<T>::wrap(value);
+        }, value);
+    }
+
+
+    /* Useful type traits */
+    template<typename T> struct is_shared_ptr : std::false_type {};
+    template<typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+    template <typename T> struct is_string { static constexpr bool value = std::is_same_v<T, const char*> || std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view>; };
+    template <typename T> struct is_boolean { static constexpr bool value = std::is_same_v<std::decay_t<T>, bool>; };
+    template <typename T> struct is_double { static constexpr bool value = std::is_same_v<std::decay_t<T>, double>;};
+
+    /** Attempt to match common types (integral, floating-point, string, etc.) */
+    template <template <typename R> typename Trait, typename U, typename ... Us>
+    static std::optional<std::variant<Ts...>> unwrapImpl(JSContext * ctx, JSValueConst v)
+    {
+        if constexpr (Trait<U>::value){
+            return js_traits<U>::unwrap(ctx, v);
+        }
+        if constexpr ((sizeof ... (Us)) > 0){
+            return unwrapImpl<Trait, Us...>(ctx, v);
+        }
+        return std::nullopt;
+    }
+
+    /** Attempt to match class ID with type */
+    template <typename U, typename ... Us>
+    static std::optional<std::variant<Ts...>> unwrapObj(JSContext * ctx, JSValueConst v)
+    {
+        if constexpr (is_shared_ptr<U>::value){
+            if (JS_GetClassID(v) == js_traits<U>::QJSClassId){
+                return js_traits<U>::unwrap(ctx, v);
+            }
+        }
+        if constexpr ((sizeof ... (Us)) > 0){
+            return unwrapObj<Us...>(ctx, v);
+        }
+        return std::nullopt;
+    }
+
+    /** Attempt to cast to types satisfying traits, ordered in terms of priority */
+    template <template <typename T> typename Trait, template <typename T> typename ... Traits>
+    static std::variant<Ts...> unwrapPriority(JSContext * ctx, JSValueConst v)
+    {
+        if (auto result = unwrapImpl<Trait, Ts...>(ctx, v)){
+            return *result;
+        }
+        if constexpr ((sizeof ... (Traits)) > 0){
+            return unwrapPriority<Traits...>(ctx, v);
+        }
+        throw exception{};
+    }
+
+
+    static std::variant<Ts...> unwrap(JSContext * ctx, JSValueConst v)
+    {
+        switch (JS_VALUE_GET_TAG(v))
+        {
+        case JS_TAG_STRING:
+            return unwrapPriority<is_string>(ctx, v);
+
+        case JS_TAG_FUNCTION_BYTECODE:
+            return unwrapPriority<std::is_function>(ctx, v);
+        case JS_TAG_OBJECT:
+            if (auto result = unwrapObj<Ts...>(ctx, v)){
+                return *result;
+            }
+            break;
+
+        case JS_TAG_INT: [[fallthrough]];
+        case JS_TAG_BIG_INT:
+            return unwrapPriority<std::is_integral, std::is_floating_point>(ctx, v);
+        case JS_TAG_BOOL:
+            return unwrapPriority<is_boolean, std::is_integral, std::is_floating_point>(ctx, v);
+
+        case JS_TAG_BIG_DECIMAL:[[fallthrough]];
+        case JS_TAG_BIG_FLOAT:[[fallthrough]];
+        case JS_TAG_FLOAT64:
+            return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
+
+        case JS_TAG_SYMBOL: [[fallthrough]];
+        case JS_TAG_MODULE: [[fallthrough]];
+        case JS_TAG_NULL: [[fallthrough]];
+        case JS_TAG_UNDEFINED: [[fallthrough]];
+        case JS_TAG_UNINITIALIZED: [[fallthrough]];
+        case JS_TAG_CATCH_OFFSET: [[fallthrough]];
+        case JS_TAG_EXCEPTION: [[fallthrough]];
+        default:
+            break;
+        }
+
+        throw exception{};
+    }
+};
 
 namespace detail {
 

From 5466285d3b76eb329c1337a7ef7f26640d00e1f3 Mon Sep 17 00:00:00 2001
From: William <wflohry@wflohry.com>
Date: Sun, 7 Feb 2021 17:22:27 -0600
Subject: [PATCH 081/185] Better handling of vector types within
 std::variant<Ts...>

---
 quickjspp.hpp | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 72 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 9abe1057c8..55a941c57f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -242,6 +242,10 @@ struct js_traits<std::variant<Ts...>>
     template <typename T> struct is_string { static constexpr bool value = std::is_same_v<T, const char*> || std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view>; };
     template <typename T> struct is_boolean { static constexpr bool value = std::is_same_v<std::decay_t<T>, bool>; };
     template <typename T> struct is_double { static constexpr bool value = std::is_same_v<std::decay_t<T>, double>;};
+    template <typename T> struct is_vector : std::false_type {};
+    template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
+    template <typename T> struct is_variant : std::false_type {};
+    template <typename ... Us> struct is_variant<std::variant<Us...>> : std::true_type {};
 
     /** Attempt to match common types (integral, floating-point, string, etc.) */
     template <template <typename R> typename Trait, typename U, typename ... Us>
@@ -284,10 +288,74 @@ struct js_traits<std::variant<Ts...>>
         throw exception{};
     }
 
+    template <typename T>
+    static bool isCompatible(JSContext * ctx, JSValueConst v){
+        const char * type_name = typeid(T).name();
+        switch (v.tag)
+        {
+        case JS_TAG_STRING:
+            return is_string<T>::value;
+
+        case JS_TAG_FUNCTION_BYTECODE:
+            return std::is_function<T>::value;
+        case JS_TAG_OBJECT:
+            if (JS_IsArray(ctx, v) == 1){
+                return is_vector<T>::value;
+            }
+            if constexpr (is_shared_ptr<T>::value){
+                if (JS_GetClassID(v) == js_traits<T>::QJSClassId){
+                    return true;
+                }
+            }
+            return false;
+
+        case JS_TAG_INT: [[fallthrough]];
+        case JS_TAG_BIG_INT:
+            return std::is_integral_v<T> || std::is_floating_point_v<T>;
+        case JS_TAG_BOOL:
+            return is_boolean<T>::value || std::is_integral_v<T> || std::is_floating_point_v<T>;
+
+        case JS_TAG_BIG_DECIMAL:[[fallthrough]];
+        case JS_TAG_BIG_FLOAT:[[fallthrough]];
+        case JS_TAG_FLOAT64:
+            return is_double<T>::value || std::is_floating_point_v<T>;
+
+        case JS_TAG_SYMBOL: [[fallthrough]];
+        case JS_TAG_MODULE: [[fallthrough]];
+        case JS_TAG_NULL: [[fallthrough]];
+        case JS_TAG_UNDEFINED: [[fallthrough]];
+        case JS_TAG_UNINITIALIZED: [[fallthrough]];
+        case JS_TAG_CATCH_OFFSET: [[fallthrough]];
+        case JS_TAG_EXCEPTION: [[fallthrough]];
+        default:
+            break;
+        }
+        return false;
+    }
+
+    template <typename U, typename ... Us>
+    static std::variant<Ts...> unwrapArray(JSContext * ctx, JSValueConst jsarr)
+    {
+        const auto length_ = JS_GetPropertyStr(ctx, jsarr, "length");
+        if (length_.tag != 0) throw exception{};
+        const auto length = length_.u.int32;
+        auto firstElement = JS_GetPropertyUint32(ctx, jsarr, 0);
+        if constexpr (is_vector<U>::value){
+            if (isCompatible<std::decay_t<typename U::value_type>>(ctx, firstElement)){
+                return U{js_traits<U>::unwrap(ctx, jsarr)};
+            }
+        }
+        if constexpr ((sizeof ... (Us)) > 0){
+            return unwrapArray<Us...>(ctx, jsarr);
+        }
+        throw exception{};
+    }
+
 
     static std::variant<Ts...> unwrap(JSContext * ctx, JSValueConst v)
     {
-        switch (JS_VALUE_GET_TAG(v))
+        const auto tag = JS_VALUE_GET_TAG(v);
+        switch (tag)
         {
         case JS_TAG_STRING:
             return unwrapPriority<is_string>(ctx, v);
@@ -295,6 +363,9 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_FUNCTION_BYTECODE:
             return unwrapPriority<std::is_function>(ctx, v);
         case JS_TAG_OBJECT:
+            if (JS_IsArray(ctx, v) == 1){
+                return unwrapArray<Ts...>(ctx, v);
+            }
             if (auto result = unwrapObj<Ts...>(ctx, v)){
                 return *result;
             }

From a3beaf0a06665b7dde52187c86512bb947c06333 Mon Sep 17 00:00:00 2001
From: William <wflohry@wflohry.com>
Date: Sun, 7 Feb 2021 17:27:18 -0600
Subject: [PATCH 082/185] Updating to use proper macros for property
 acquisition.

---
 quickjspp.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 55a941c57f..a74cbe3a9a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -291,7 +291,7 @@ struct js_traits<std::variant<Ts...>>
     template <typename T>
     static bool isCompatible(JSContext * ctx, JSValueConst v){
         const char * type_name = typeid(T).name();
-        switch (v.tag)
+        switch (JS_VALUE_GET_TAG(v))
         {
         case JS_TAG_STRING:
             return is_string<T>::value;
@@ -337,8 +337,8 @@ struct js_traits<std::variant<Ts...>>
     static std::variant<Ts...> unwrapArray(JSContext * ctx, JSValueConst jsarr)
     {
         const auto length_ = JS_GetPropertyStr(ctx, jsarr, "length");
-        if (length_.tag != 0) throw exception{};
-        const auto length = length_.u.int32;
+        if (JS_VALUE_GET_TAG(length_) != 0) throw exception{};
+        const auto length = JS_VALUE_GET_INT(length_);
         auto firstElement = JS_GetPropertyUint32(ctx, jsarr, 0);
         if constexpr (is_vector<U>::value){
             if (isCompatible<std::decay_t<typename U::value_type>>(ctx, firstElement)){

From f8ab67cd79d0fc8577830216c0e0a5afc544aa21 Mon Sep 17 00:00:00 2001
From: William <wflohry@wflohry.com>
Date: Sun, 7 Feb 2021 20:36:59 -0600
Subject: [PATCH 083/185] Pair support

---
 quickjspp.hpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index a74cbe3a9a..30e1a1c401 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -223,6 +223,7 @@ struct js_traits<const char *>
     }
 };
 
+
 /** Conversion from const std::variant */
 template <typename ... Ts>
 struct js_traits<std::variant<Ts...>>
@@ -1525,6 +1526,35 @@ struct js_traits<std::vector<T>>
     }
 };
 
+
+template <typename U, typename V>
+struct js_traits<std::pair<U, V>>
+{
+    static JSValue wrap(JSContext * ctx, const std::pair<U, V> &obj) noexcept
+    {
+       auto jsarray = Value{ctx, JS_NewArray(ctx)};
+        jsarray[uint32_t(0)] = obj.first;
+        jsarray[uint32_t(1)] = obj.second;
+        return jsarray.release();
+    }
+
+    static std::pair<U, V> unwrap(JSContext * ctx, JSValueConst jsarr)
+    {
+        int e = JS_IsArray(ctx, jsarr);
+        if(e == 0)
+            JS_ThrowTypeError(ctx, "js_traits<std::vector<T>>::unwrap expects array");
+        if(e <= 0)
+            throw exception{};
+        Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
+        std::pair<U, V> arr;
+        const auto len = static_cast<uint32_t>(jsarray["length"]);
+        if (len != 2) throw exception{};
+        arr.first = static_cast<U>(jsarray[uint32_t(0)]);
+        arr.second = static_cast<V>(jsarray[uint32_t(1)]);
+        return arr;
+    }
+};
+
 namespace detail {
 template <typename Key>
 property_proxy<Key>::operator Value() const

From 4624ab05f4655ae1b14467badcf7455ce8aff1ed Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 8 Feb 2021 21:55:33 +0300
Subject: [PATCH 084/185] add basic std::variant test

---
 test/CMakeLists.txt |  2 +-
 test/variant.cpp    | 87 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+), 1 deletion(-)
 create mode 100644 test/variant.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 71edfc2131..63c2aa3840 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point
+        value class exception example multicontext conversions point variant
         )
 make_test(${test})
 endforeach()
diff --git a/test/variant.cpp b/test/variant.cpp
new file mode 100644
index 0000000000..640f3075c0
--- /dev/null
+++ b/test/variant.cpp
@@ -0,0 +1,87 @@
+#include "quickjspp.hpp"
+#include <variant>
+#include <iostream>
+
+struct A {};
+
+struct B {};
+
+using var = std::variant<bool, int, double, std::string, std::vector<int>, std::shared_ptr<A>, std::shared_ptr<B>>;
+
+
+auto f(var v1, const var& /*v2*/) -> var
+{
+    return std::visit([](auto&& v) -> var {
+        using T = std::decay_t<decltype(v)>;
+        if constexpr (std::is_same_v<T, std::shared_ptr<A>>)
+            return std::make_shared<B>();
+        else if constexpr (std::is_same_v<T, std::shared_ptr<B>>)
+            return std::make_shared<A>();
+        else if constexpr (std::is_same_v<T, std::vector<int>>)
+        {
+            v.push_back(0);
+            return v;
+        } else
+            return v + v;
+    }, v1);
+}
+
+void assert_(bool condition)
+{
+    assert(condition);
+}
+
+static void qjs_glue(qjs::Context::Module& m)
+{
+    m.class_<::A>("A")
+            .constructor<>()
+        // implicit: .constructor<::A const &>()
+            ;
+
+    m.class_<::B>("B")
+            .constructor<>()
+        // implicit: .constructor<::B const &>()
+            ;
+    m.function<&::assert_>("assert"); // (bool)
+    m.function<&::f>("f"); // (::var, ::var const &)
+
+} // qjs_glue
+
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    try
+    {
+        // export classes as a module
+        auto& module = context.addModule("MyModule");
+        qjs_glue(module);
+        // import module
+        context.eval("import * as my from 'MyModule'; globalThis.my = my;", "<import>", JS_EVAL_TYPE_MODULE);
+        // evaluate js code
+        context.eval("let x = 1;"
+                     "my.assert(my.f(x, x) === 2);"
+                     "x = 'aaa';"
+                     "my.assert(my.f(x, x) === 'aaaaaa');"
+                     "x = 3.14;"
+                     "my.assert(my.f(x, x) === 6.28);"
+                     "x = [3,2,1];"
+                     "my.assert(JSON.stringify(my.f(x, x)) === '[3,2,1,0]');"
+                     "x = new my.A();"
+                     "my.assert(my.f(x, x) instanceof my.B);"
+                     "x = new my.B();"
+                     "my.assert(my.f(x, x) instanceof my.A);"
+        );
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+
+}
\ No newline at end of file

From 8384fce1e40bd884496819bf4b8c7b322ef78cd6 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 8 Feb 2021 21:56:12 +0300
Subject: [PATCH 085/185] fix missing argument from variant wrapping

---
 quickjspp.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 30e1a1c401..bec313b66d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -230,9 +230,9 @@ struct js_traits<std::variant<Ts...>>
 {
     static JSValue wrap(JSContext * ctx, const std::variant<Ts...> &value) noexcept
     {
-        return std::visit([](auto && value){
+        return std::visit([ctx](auto && value){
             using T = std::decay_t<decltype(value)>;
-            return js_traits<T>::wrap(value);
+            return js_traits<T>::wrap(ctx, value);
         }, value);
     }
 

From 1972871eea58b7a8c3da36f388980ba532a840d0 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 20 Feb 2021 17:38:14 +0300
Subject: [PATCH 086/185] fix variant in case of JS_NAN_BOXING

---
 quickjspp.hpp | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index bec313b66d..9b32bbd89c 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -291,7 +291,7 @@ struct js_traits<std::variant<Ts...>>
 
     template <typename T>
     static bool isCompatible(JSContext * ctx, JSValueConst v){
-        const char * type_name = typeid(T).name();
+        //const char * type_name = typeid(T).name();
         switch (JS_VALUE_GET_TAG(v))
         {
         case JS_TAG_STRING:
@@ -337,11 +337,11 @@ struct js_traits<std::variant<Ts...>>
     template <typename U, typename ... Us>
     static std::variant<Ts...> unwrapArray(JSContext * ctx, JSValueConst jsarr)
     {
-        const auto length_ = JS_GetPropertyStr(ctx, jsarr, "length");
-        if (JS_VALUE_GET_TAG(length_) != 0) throw exception{};
-        const auto length = JS_VALUE_GET_INT(length_);
-        auto firstElement = JS_GetPropertyUint32(ctx, jsarr, 0);
+        //const auto length_ = JS_GetPropertyStr(ctx, jsarr, "length");
+        //if (JS_VALUE_GET_TAG(length_) != 0) throw exception{};
+        //const auto length = JS_VALUE_GET_INT(length_);
         if constexpr (is_vector<U>::value){
+            auto firstElement = JS_GetPropertyUint32(ctx, jsarr, 0);
             if (isCompatible<std::decay_t<typename U::value_type>>(ctx, firstElement)){
                 return U{js_traits<U>::unwrap(ctx, jsarr)};
             }
@@ -378,20 +378,30 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_BOOL:
             return unwrapPriority<is_boolean, std::is_integral, std::is_floating_point>(ctx, v);
 
-        case JS_TAG_BIG_DECIMAL:[[fallthrough]];
-        case JS_TAG_BIG_FLOAT:[[fallthrough]];
-        case JS_TAG_FLOAT64:
-            return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
-
         case JS_TAG_SYMBOL: [[fallthrough]];
         case JS_TAG_MODULE: [[fallthrough]];
         case JS_TAG_NULL: [[fallthrough]];
         case JS_TAG_UNDEFINED: [[fallthrough]];
         case JS_TAG_UNINITIALIZED: [[fallthrough]];
-        case JS_TAG_CATCH_OFFSET: [[fallthrough]];
-        case JS_TAG_EXCEPTION: [[fallthrough]];
-        default:
+        case JS_TAG_CATCH_OFFSET:
+        {
+#ifdef __cpp_rtti
+            const char * type = typeid(std::variant<Ts...>).name();
+#else
+            const char * type = "variant<...>";
+#endif
+            JS_ThrowTypeError(ctx, "Expected type %s, got tag %d", type, tag);
+        } [[fallthrough]];
+        case JS_TAG_EXCEPTION:
+            throw exception{};
             break;
+
+        case JS_TAG_BIG_DECIMAL: [[fallthrough]];
+        case JS_TAG_BIG_FLOAT: [[fallthrough]];
+
+        case JS_TAG_FLOAT64: [[fallthrough]];
+        default: // more than JS_TAG_FLOAT64 (nan boxing)
+            return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
         }
 
         throw exception{};

From 19bf3768ebb286e15098f6a8106faf2b618b157f Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 14:30:17 +0300
Subject: [PATCH 087/185] fix to_bool

---
 quickjspp.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 9b32bbd89c..d2ba8f50d2 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -99,7 +99,8 @@ struct js_traits<bool>
 {
     static bool unwrap(JSContext * ctx, JSValueConst v) noexcept
     {
-        return JS_ToBool(ctx, v);
+        // TODO: is this behaviour correct?
+        return JS_ToBool(ctx, v) > 0;
     }
 
     static JSValue wrap(JSContext * ctx, bool i) noexcept

From 36d3d1a48a914151fa2a58fc6ccc5dc30618d32d Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 14:35:24 +0300
Subject: [PATCH 088/185] JS_NAN_BOXING fix pt.2

---
 quickjspp.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d2ba8f50d2..1375f9ac67 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -320,6 +320,7 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_BIG_DECIMAL:[[fallthrough]];
         case JS_TAG_BIG_FLOAT:[[fallthrough]];
         case JS_TAG_FLOAT64:
+        default: // >JS_TAG_FLOAT64 (JS_NAN_BOXING)
             return is_double<T>::value || std::is_floating_point_v<T>;
 
         case JS_TAG_SYMBOL: [[fallthrough]];
@@ -328,8 +329,7 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_UNDEFINED: [[fallthrough]];
         case JS_TAG_UNINITIALIZED: [[fallthrough]];
         case JS_TAG_CATCH_OFFSET: [[fallthrough]];
-        case JS_TAG_EXCEPTION: [[fallthrough]];
-        default:
+        case JS_TAG_EXCEPTION:
             break;
         }
         return false;

From e80c2a1a0699f135819622303f5751a1f2e0fdad Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 14:39:01 +0300
Subject: [PATCH 089/185] small pair<> fixes

---
 quickjspp.hpp | 41 ++++++++++++++++++++++++++++++-----------
 1 file changed, 30 insertions(+), 11 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1375f9ac67..bd2cc6d4e7 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -15,6 +15,14 @@
 #include <stdexcept>
 #include <variant>
 
+
+#if defined(__cpp_rtti)
+#define QJSPP_TYPENAME(...) (typeid(__VA_ARGS__).name())
+#else
+#define QJSPP_TYPENAME(...) #__VA_ARGS__
+#endif
+
+
 namespace qjs {
 
 
@@ -1541,28 +1549,39 @@ struct js_traits<std::vector<T>>
 template <typename U, typename V>
 struct js_traits<std::pair<U, V>>
 {
-    static JSValue wrap(JSContext * ctx, const std::pair<U, V> &obj) noexcept
+    static JSValue wrap(JSContext * ctx, std::pair<U, V> obj) noexcept
     {
-       auto jsarray = Value{ctx, JS_NewArray(ctx)};
-        jsarray[uint32_t(0)] = obj.first;
-        jsarray[uint32_t(1)] = obj.second;
-        return jsarray.release();
+        try
+        {
+            auto jsarray = Value{ctx, JS_NewArray(ctx)};
+            jsarray[uint32_t(0)] = std::move(obj.first);
+            jsarray[uint32_t(1)] = std::move(obj.second);
+            return jsarray.release();
+        }
+        catch(exception)
+        {
+            return JS_EXCEPTION;
+        }
     }
 
     static std::pair<U, V> unwrap(JSContext * ctx, JSValueConst jsarr)
     {
         int e = JS_IsArray(ctx, jsarr);
         if(e == 0)
-            JS_ThrowTypeError(ctx, "js_traits<std::vector<T>>::unwrap expects array");
+            JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expects array", QJSPP_TYPENAME(std::pair<U, V>));
         if(e <= 0)
             throw exception{};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
-        std::pair<U, V> arr;
         const auto len = static_cast<uint32_t>(jsarray["length"]);
-        if (len != 2) throw exception{};
-        arr.first = static_cast<U>(jsarray[uint32_t(0)]);
-        arr.second = static_cast<V>(jsarray[uint32_t(1)]);
-        return arr;
+        if (len != 2)
+        {
+            JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expected array of length 2, got length %d", QJSPP_TYPENAME(std::pair<U, V>), len);
+            throw exception{};
+        }
+        return std::pair<U, V>{
+                static_cast<U>(jsarray[uint32_t(0)]),
+                static_cast<V>(jsarray[uint32_t(1)])
+        };
     }
 };
 

From 9b19a08cca00e82662d20f98e097cd1e20d8eb82 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 14:57:50 +0300
Subject: [PATCH 090/185] variant fixes and tests

---
 quickjspp.hpp    | 99 +++++++++++++++++++++++++++++-------------------
 test/variant.cpp | 19 +++++++++-
 2 files changed, 76 insertions(+), 42 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index bd2cc6d4e7..a533d840d6 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -237,12 +237,12 @@ struct js_traits<const char *>
 template <typename ... Ts>
 struct js_traits<std::variant<Ts...>>
 {
-    static JSValue wrap(JSContext * ctx, const std::variant<Ts...> &value) noexcept
+    static JSValue wrap(JSContext * ctx, std::variant<Ts...> value) noexcept
     {
         return std::visit([ctx](auto && value){
             using T = std::decay_t<decltype(value)>;
             return js_traits<T>::wrap(ctx, value);
-        }, value);
+        }, std::move(value));
     }
 
 
@@ -254,6 +254,8 @@ struct js_traits<std::variant<Ts...>>
     template <typename T> struct is_double { static constexpr bool value = std::is_same_v<std::decay_t<T>, double>;};
     template <typename T> struct is_vector : std::false_type {};
     template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
+    template <typename T> struct is_pair : std::false_type {};
+    template <typename U, typename V> struct is_pair<std::pair<U, V>> : std::true_type {};
     template <typename T> struct is_variant : std::false_type {};
     template <typename ... Us> struct is_variant<std::variant<Us...>> : std::true_type {};
 
@@ -272,15 +274,59 @@ struct js_traits<std::variant<Ts...>>
 
     /** Attempt to match class ID with type */
     template <typename U, typename ... Us>
-    static std::optional<std::variant<Ts...>> unwrapObj(JSContext * ctx, JSValueConst v)
+    static std::optional<std::variant<Ts...>> unwrapObj(JSContext * ctx, JSValueConst v, JSClassID class_id)
     {
         if constexpr (is_shared_ptr<U>::value){
-            if (JS_GetClassID(v) == js_traits<U>::QJSClassId){
+            if (class_id == js_traits<U>::QJSClassId){
                 return js_traits<U>::unwrap(ctx, v);
             }
         }
-        if constexpr ((sizeof ... (Us)) > 0){
-            return unwrapObj<Us...>(ctx, v);
+
+        // try to unwrap embedded variant (variant<variant<...>>), might be slow
+        if constexpr (is_variant<U>::value)
+        {
+            try
+            {
+                return js_traits<U>::unwrap(ctx, v);
+            }
+            catch(exception) { JS_FreeValue(ctx, JS_GetException(ctx)); } // ignore, clear exception
+        }
+
+        if constexpr (is_vector<U>::value)
+        {
+            if(JS_IsArray(ctx, v) == 1)
+            {
+                auto firstElement = JS_GetPropertyUint32(ctx, v, 0);
+                bool ok = isCompatible<std::decay_t<typename U::value_type>>(ctx, firstElement);
+                JS_FreeValue(ctx, firstElement);
+                if(ok)
+                {
+                    return U{js_traits<U>::unwrap(ctx, v)};
+                }
+            }
+        }
+
+        if constexpr (is_pair<U>::value)
+        {
+            if(JS_IsArray(ctx, v) == 1)
+            {
+                // todo: check length?
+                auto firstElement = JS_GetPropertyUint32(ctx, v, 0);
+                auto secondElement = JS_GetPropertyUint32(ctx, v, 1);
+                bool ok = isCompatible<std::decay_t<typename U::first_type>>(ctx, firstElement)
+                   && isCompatible<std::decay_t<typename U::second_type>>(ctx, secondElement);
+                JS_FreeValue(ctx, firstElement);
+                JS_FreeValue(ctx, secondElement);
+                if(ok)
+                {
+                    return U{js_traits<U>::unwrap(ctx, v)};
+                }
+            }
+        }
+
+        if constexpr ((sizeof ... (Us)) > 0)
+        {
+            return unwrapObj<Us...>(ctx, v, class_id);
         }
         return std::nullopt;
     }
@@ -295,11 +341,12 @@ struct js_traits<std::variant<Ts...>>
         if constexpr ((sizeof ... (Traits)) > 0){
             return unwrapPriority<Traits...>(ctx, v);
         }
+        JS_ThrowTypeError(ctx, "Expected type %s", QJSPP_TYPENAME(std::variant<Ts...>));
         throw exception{};
     }
 
     template <typename T>
-    static bool isCompatible(JSContext * ctx, JSValueConst v){
+    static bool isCompatible(JSContext * ctx, JSValueConst v) noexcept {
         //const char * type_name = typeid(T).name();
         switch (JS_VALUE_GET_TAG(v))
         {
@@ -310,7 +357,7 @@ struct js_traits<std::variant<Ts...>>
             return std::is_function<T>::value;
         case JS_TAG_OBJECT:
             if (JS_IsArray(ctx, v) == 1){
-                return is_vector<T>::value;
+                return is_vector<T>::value || is_pair<T>::value;
             }
             if constexpr (is_shared_ptr<T>::value){
                 if (JS_GetClassID(v) == js_traits<T>::QJSClassId){
@@ -343,25 +390,6 @@ struct js_traits<std::variant<Ts...>>
         return false;
     }
 
-    template <typename U, typename ... Us>
-    static std::variant<Ts...> unwrapArray(JSContext * ctx, JSValueConst jsarr)
-    {
-        //const auto length_ = JS_GetPropertyStr(ctx, jsarr, "length");
-        //if (JS_VALUE_GET_TAG(length_) != 0) throw exception{};
-        //const auto length = JS_VALUE_GET_INT(length_);
-        if constexpr (is_vector<U>::value){
-            auto firstElement = JS_GetPropertyUint32(ctx, jsarr, 0);
-            if (isCompatible<std::decay_t<typename U::value_type>>(ctx, firstElement)){
-                return U{js_traits<U>::unwrap(ctx, jsarr)};
-            }
-        }
-        if constexpr ((sizeof ... (Us)) > 0){
-            return unwrapArray<Us...>(ctx, jsarr);
-        }
-        throw exception{};
-    }
-
-
     static std::variant<Ts...> unwrap(JSContext * ctx, JSValueConst v)
     {
         const auto tag = JS_VALUE_GET_TAG(v);
@@ -373,12 +401,10 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_FUNCTION_BYTECODE:
             return unwrapPriority<std::is_function>(ctx, v);
         case JS_TAG_OBJECT:
-            if (JS_IsArray(ctx, v) == 1){
-                return unwrapArray<Ts...>(ctx, v);
-            }
-            if (auto result = unwrapObj<Ts...>(ctx, v)){
+            if (auto result = unwrapObj<Ts...>(ctx, v, JS_GetClassID(v))){
                 return *result;
             }
+            JS_ThrowTypeError(ctx, "Expected type %s, got object with classid %d", QJSPP_TYPENAME(std::variant<Ts...>), JS_GetClassID(v));
             break;
 
         case JS_TAG_INT: [[fallthrough]];
@@ -393,16 +419,9 @@ struct js_traits<std::variant<Ts...>>
         case JS_TAG_UNDEFINED: [[fallthrough]];
         case JS_TAG_UNINITIALIZED: [[fallthrough]];
         case JS_TAG_CATCH_OFFSET:
-        {
-#ifdef __cpp_rtti
-            const char * type = typeid(std::variant<Ts...>).name();
-#else
-            const char * type = "variant<...>";
-#endif
-            JS_ThrowTypeError(ctx, "Expected type %s, got tag %d", type, tag);
-        } [[fallthrough]];
+            JS_ThrowTypeError(ctx, "Expected type %s, got tag %d", QJSPP_TYPENAME(std::variant<Ts...>), tag);
+            [[fallthrough]];
         case JS_TAG_EXCEPTION:
-            throw exception{};
             break;
 
         case JS_TAG_BIG_DECIMAL: [[fallthrough]];
diff --git a/test/variant.cpp b/test/variant.cpp
index 640f3075c0..d33eb15ea2 100644
--- a/test/variant.cpp
+++ b/test/variant.cpp
@@ -26,9 +26,21 @@ auto f(var v1, const var& /*v2*/) -> var
     }, v1);
 }
 
+using var2 = std::variant<var, std::vector<std::pair<var, var>>>;
+
+
+auto f2(var2 v2) -> var
+{
+    if(auto *v = std::get_if<var>(&v2))
+        return *v;
+    if(auto *vec = std::get_if<std::vector<std::pair<var, var>>>(&v2))
+        return (*vec)[0].first;
+    std::abort();
+}
+
 void assert_(bool condition)
 {
-    assert(condition);
+    if(!condition) throw qjs::exception{};
 }
 
 static void qjs_glue(qjs::Context::Module& m)
@@ -44,7 +56,7 @@ static void qjs_glue(qjs::Context::Module& m)
             ;
     m.function<&::assert_>("assert"); // (bool)
     m.function<&::f>("f"); // (::var, ::var const &)
-
+    m.function<&::f2>("f2");
 } // qjs_glue
 
 
@@ -73,6 +85,9 @@ int main()
                      "my.assert(my.f(x, x) instanceof my.B);"
                      "x = new my.B();"
                      "my.assert(my.f(x, x) instanceof my.A);"
+                     "my.assert(my.f2(x) instanceof my.B);"
+                     "my.assert(my.f2([[x,x]]) instanceof my.B);"
+                     "my.assert(my.f2([[my.f(x,x),x]]) instanceof my.A);"
         );
     }
     catch(qjs::exception)

From b9c4cc0dc468e91634e0803873c7312aebcb531c Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 15:11:18 +0300
Subject: [PATCH 091/185] auto-reformat quickjspp.hpp

---
 quickjspp.hpp | 277 ++++++++++++++++++++++++++++----------------------
 1 file changed, 158 insertions(+), 119 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index a533d840d6..179520229d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -43,6 +43,7 @@ struct js_traits
      * @throws exception in case of conversion error
      */
     static R unwrap(JSContext * ctx, JSValueConst v);
+
     /** Create JSValue from an object of type R and JSContext.
      * This function is intentionally not implemented. User should implement this function for their own type.
      * @return Returns JSValue which should be freed by the caller or JS_EXCEPTION in case of error.
@@ -160,18 +161,17 @@ class js_string : public std::string_view
 
     friend struct js_traits<std::string_view>;
 
-    js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx)
-    {}
+    js_string(JSContext * ctx, const char * ptr, std::size_t len) : Base(ptr, len), ctx(ctx) {}
 
 public:
 
     template <typename... Args>
-    js_string(Args&& ... args) : Base(std::forward<Args>(args)...), ctx(nullptr)
-    {}
+    js_string(Args&& ... args) : Base(std::forward<Args>(args)...), ctx(nullptr) {}
 
     js_string(const js_string& other) = delete;
 
-    operator const char * () const {
+    operator const char *() const
+    {
         return this->data();
     }
 
@@ -226,6 +226,7 @@ struct js_traits<const char *>
     {
         return JS_NewString(ctx, str);
     }
+
     static detail::js_string unwrap(JSContext * ctx, JSValueConst v)
     {
         return js_traits<std::string_view>::unwrap(ctx, v);
@@ -239,7 +240,7 @@ struct js_traits<std::variant<Ts...>>
 {
     static JSValue wrap(JSContext * ctx, std::variant<Ts...> value) noexcept
     {
-        return std::visit([ctx](auto && value){
+        return std::visit([ctx](auto&& value) {
             using T = std::decay_t<decltype(value)>;
             return js_traits<T>::wrap(ctx, value);
         }, std::move(value));
@@ -247,11 +248,15 @@ struct js_traits<std::variant<Ts...>>
 
 
     /* Useful type traits */
-    template<typename T> struct is_shared_ptr : std::false_type {};
-    template<typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
-    template <typename T> struct is_string { static constexpr bool value = std::is_same_v<T, const char*> || std::is_same_v<std::decay_t<T>, std::string> || std::is_same_v<std::decay_t<T>, std::string_view>; };
+    template <typename T> struct is_shared_ptr : std::false_type {};
+    template <typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+    template <typename T> struct is_string
+    {
+        static constexpr bool value = std::is_same_v<T, const char *> || std::is_same_v<std::decay_t<T>, std::string> ||
+                                      std::is_same_v<std::decay_t<T>, std::string_view>;
+    };
     template <typename T> struct is_boolean { static constexpr bool value = std::is_same_v<std::decay_t<T>, bool>; };
-    template <typename T> struct is_double { static constexpr bool value = std::is_same_v<std::decay_t<T>, double>;};
+    template <typename T> struct is_double { static constexpr bool value = std::is_same_v<std::decay_t<T>, double>; };
     template <typename T> struct is_vector : std::false_type {};
     template <typename T> struct is_vector<std::vector<T>> : std::true_type {};
     template <typename T> struct is_pair : std::false_type {};
@@ -263,10 +268,12 @@ struct js_traits<std::variant<Ts...>>
     template <template <typename R> typename Trait, typename U, typename ... Us>
     static std::optional<std::variant<Ts...>> unwrapImpl(JSContext * ctx, JSValueConst v)
     {
-        if constexpr (Trait<U>::value){
+        if constexpr (Trait<U>::value)
+        {
             return js_traits<U>::unwrap(ctx, v);
         }
-        if constexpr ((sizeof ... (Us)) > 0){
+        if constexpr ((sizeof ... (Us)) > 0)
+        {
             return unwrapImpl<Trait, Us...>(ctx, v);
         }
         return std::nullopt;
@@ -276,8 +283,10 @@ struct js_traits<std::variant<Ts...>>
     template <typename U, typename ... Us>
     static std::optional<std::variant<Ts...>> unwrapObj(JSContext * ctx, JSValueConst v, JSClassID class_id)
     {
-        if constexpr (is_shared_ptr<U>::value){
-            if (class_id == js_traits<U>::QJSClassId){
+        if constexpr (is_shared_ptr<U>::value)
+        {
+            if(class_id == js_traits<U>::QJSClassId)
+            {
                 return js_traits<U>::unwrap(ctx, v);
             }
         }
@@ -289,7 +298,8 @@ struct js_traits<std::variant<Ts...>>
             {
                 return js_traits<U>::unwrap(ctx, v);
             }
-            catch(exception) { JS_FreeValue(ctx, JS_GetException(ctx)); } // ignore, clear exception
+            catch(exception)
+            { JS_FreeValue(ctx, JS_GetException(ctx)); } // ignore, clear exception
         }
 
         if constexpr (is_vector<U>::value)
@@ -314,7 +324,7 @@ struct js_traits<std::variant<Ts...>>
                 auto firstElement = JS_GetPropertyUint32(ctx, v, 0);
                 auto secondElement = JS_GetPropertyUint32(ctx, v, 1);
                 bool ok = isCompatible<std::decay_t<typename U::first_type>>(ctx, firstElement)
-                   && isCompatible<std::decay_t<typename U::second_type>>(ctx, secondElement);
+                          && isCompatible<std::decay_t<typename U::second_type>>(ctx, secondElement);
                 JS_FreeValue(ctx, firstElement);
                 JS_FreeValue(ctx, secondElement);
                 if(ok)
@@ -335,10 +345,12 @@ struct js_traits<std::variant<Ts...>>
     template <template <typename T> typename Trait, template <typename T> typename ... Traits>
     static std::variant<Ts...> unwrapPriority(JSContext * ctx, JSValueConst v)
     {
-        if (auto result = unwrapImpl<Trait, Ts...>(ctx, v)){
+        if(auto result = unwrapImpl<Trait, Ts...>(ctx, v))
+        {
             return *result;
         }
-        if constexpr ((sizeof ... (Traits)) > 0){
+        if constexpr ((sizeof ... (Traits)) > 0)
+        {
             return unwrapPriority<Traits...>(ctx, v);
         }
         JS_ThrowTypeError(ctx, "Expected type %s", QJSPP_TYPENAME(std::variant<Ts...>));
@@ -346,46 +358,55 @@ struct js_traits<std::variant<Ts...>>
     }
 
     template <typename T>
-    static bool isCompatible(JSContext * ctx, JSValueConst v) noexcept {
+    static bool isCompatible(JSContext * ctx, JSValueConst v) noexcept
+    {
         //const char * type_name = typeid(T).name();
-        switch (JS_VALUE_GET_TAG(v))
+        switch(JS_VALUE_GET_TAG(v))
         {
-        case JS_TAG_STRING:
-            return is_string<T>::value;
-
-        case JS_TAG_FUNCTION_BYTECODE:
-            return std::is_function<T>::value;
-        case JS_TAG_OBJECT:
-            if (JS_IsArray(ctx, v) == 1){
-                return is_vector<T>::value || is_pair<T>::value;
-            }
-            if constexpr (is_shared_ptr<T>::value){
-                if (JS_GetClassID(v) == js_traits<T>::QJSClassId){
-                    return true;
+            case JS_TAG_STRING:
+                return is_string<T>::value;
+
+            case JS_TAG_FUNCTION_BYTECODE:
+                return std::is_function<T>::value;
+            case JS_TAG_OBJECT:
+                if(JS_IsArray(ctx, v) == 1)
+                    return is_vector<T>::value || is_pair<T>::value;
+                if constexpr (is_shared_ptr<T>::value)
+                {
+                    if(JS_GetClassID(v) == js_traits<T>::QJSClassId)
+                        return true;
                 }
-            }
-            return false;
-
-        case JS_TAG_INT: [[fallthrough]];
-        case JS_TAG_BIG_INT:
-            return std::is_integral_v<T> || std::is_floating_point_v<T>;
-        case JS_TAG_BOOL:
-            return is_boolean<T>::value || std::is_integral_v<T> || std::is_floating_point_v<T>;
-
-        case JS_TAG_BIG_DECIMAL:[[fallthrough]];
-        case JS_TAG_BIG_FLOAT:[[fallthrough]];
-        case JS_TAG_FLOAT64:
-        default: // >JS_TAG_FLOAT64 (JS_NAN_BOXING)
-            return is_double<T>::value || std::is_floating_point_v<T>;
-
-        case JS_TAG_SYMBOL: [[fallthrough]];
-        case JS_TAG_MODULE: [[fallthrough]];
-        case JS_TAG_NULL: [[fallthrough]];
-        case JS_TAG_UNDEFINED: [[fallthrough]];
-        case JS_TAG_UNINITIALIZED: [[fallthrough]];
-        case JS_TAG_CATCH_OFFSET: [[fallthrough]];
-        case JS_TAG_EXCEPTION:
-            break;
+                return false;
+
+            case JS_TAG_INT:
+                [[fallthrough]];
+            case JS_TAG_BIG_INT:
+                return std::is_integral_v<T> || std::is_floating_point_v<T>;
+            case JS_TAG_BOOL:
+                return is_boolean<T>::value || std::is_integral_v<T> || std::is_floating_point_v<T>;
+
+            case JS_TAG_BIG_DECIMAL:
+                [[fallthrough]];
+            case JS_TAG_BIG_FLOAT:
+                [[fallthrough]];
+            case JS_TAG_FLOAT64:
+            default: // >JS_TAG_FLOAT64 (JS_NAN_BOXING)
+                return is_double<T>::value || std::is_floating_point_v<T>;
+
+            case JS_TAG_SYMBOL:
+                [[fallthrough]];
+            case JS_TAG_MODULE:
+                [[fallthrough]];
+            case JS_TAG_NULL:
+                [[fallthrough]];
+            case JS_TAG_UNDEFINED:
+                [[fallthrough]];
+            case JS_TAG_UNINITIALIZED:
+                [[fallthrough]];
+            case JS_TAG_CATCH_OFFSET:
+                [[fallthrough]];
+            case JS_TAG_EXCEPTION:
+                break;
         }
         return false;
     }
@@ -393,43 +414,54 @@ struct js_traits<std::variant<Ts...>>
     static std::variant<Ts...> unwrap(JSContext * ctx, JSValueConst v)
     {
         const auto tag = JS_VALUE_GET_TAG(v);
-        switch (tag)
+        switch(tag)
         {
-        case JS_TAG_STRING:
-            return unwrapPriority<is_string>(ctx, v);
-
-        case JS_TAG_FUNCTION_BYTECODE:
-            return unwrapPriority<std::is_function>(ctx, v);
-        case JS_TAG_OBJECT:
-            if (auto result = unwrapObj<Ts...>(ctx, v, JS_GetClassID(v))){
-                return *result;
-            }
-            JS_ThrowTypeError(ctx, "Expected type %s, got object with classid %d", QJSPP_TYPENAME(std::variant<Ts...>), JS_GetClassID(v));
-            break;
-
-        case JS_TAG_INT: [[fallthrough]];
-        case JS_TAG_BIG_INT:
-            return unwrapPriority<std::is_integral, std::is_floating_point>(ctx, v);
-        case JS_TAG_BOOL:
-            return unwrapPriority<is_boolean, std::is_integral, std::is_floating_point>(ctx, v);
-
-        case JS_TAG_SYMBOL: [[fallthrough]];
-        case JS_TAG_MODULE: [[fallthrough]];
-        case JS_TAG_NULL: [[fallthrough]];
-        case JS_TAG_UNDEFINED: [[fallthrough]];
-        case JS_TAG_UNINITIALIZED: [[fallthrough]];
-        case JS_TAG_CATCH_OFFSET:
-            JS_ThrowTypeError(ctx, "Expected type %s, got tag %d", QJSPP_TYPENAME(std::variant<Ts...>), tag);
-            [[fallthrough]];
-        case JS_TAG_EXCEPTION:
-            break;
-
-        case JS_TAG_BIG_DECIMAL: [[fallthrough]];
-        case JS_TAG_BIG_FLOAT: [[fallthrough]];
-
-        case JS_TAG_FLOAT64: [[fallthrough]];
-        default: // more than JS_TAG_FLOAT64 (nan boxing)
-            return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
+            case JS_TAG_STRING:
+                return unwrapPriority<is_string>(ctx, v);
+
+            case JS_TAG_FUNCTION_BYTECODE:
+                return unwrapPriority<std::is_function>(ctx, v);
+            case JS_TAG_OBJECT:
+                if(auto result = unwrapObj<Ts...>(ctx, v, JS_GetClassID(v)))
+                {
+                    return *result;
+                }
+                JS_ThrowTypeError(ctx, "Expected type %s, got object with classid %d",
+                                  QJSPP_TYPENAME(std::variant<Ts...>), JS_GetClassID(v));
+                break;
+
+            case JS_TAG_INT:
+                [[fallthrough]];
+            case JS_TAG_BIG_INT:
+                return unwrapPriority<std::is_integral, std::is_floating_point>(ctx, v);
+            case JS_TAG_BOOL:
+                return unwrapPriority<is_boolean, std::is_integral, std::is_floating_point>(ctx, v);
+
+            case JS_TAG_SYMBOL:
+                [[fallthrough]];
+            case JS_TAG_MODULE:
+                [[fallthrough]];
+            case JS_TAG_NULL:
+                [[fallthrough]];
+            case JS_TAG_UNDEFINED:
+                [[fallthrough]];
+            case JS_TAG_UNINITIALIZED:
+                [[fallthrough]];
+            case JS_TAG_CATCH_OFFSET:
+                JS_ThrowTypeError(ctx, "Expected type %s, got tag %d", QJSPP_TYPENAME(std::variant<Ts...>), tag);
+                [[fallthrough]];
+            case JS_TAG_EXCEPTION:
+                break;
+
+            case JS_TAG_BIG_DECIMAL:
+                [[fallthrough]];
+            case JS_TAG_BIG_FLOAT:
+                [[fallthrough]];
+
+            case JS_TAG_FLOAT64:
+                [[fallthrough]];
+            default: // more than JS_TAG_FLOAT64 (nan boxing)
+                return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
         }
 
         throw exception{};
@@ -446,7 +478,8 @@ T unwrap_free(JSContext * ctx, JSValue val)
     {
         JS_FreeValue(ctx, val);
         return js_traits<T>::unwrap(ctx, val);
-    } else
+    }
+    else
     {
         try
         {
@@ -495,7 +528,8 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
         {
             std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
             return JS_NULL;
-        } else
+        }
+        else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
@@ -521,7 +555,8 @@ JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, J
             std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
                                                                  unwrap_args<Args...>(ctx, argv)));
             return JS_NULL;
-        } else
+        }
+        else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
@@ -644,14 +679,14 @@ struct js_traits<ctor_wrapper<T, Args...>>
             }
 
             auto proto = JS_GetPropertyStr(ctx, this_value, "prototype");
-            if (JS_IsException(proto))
+            if(JS_IsException(proto))
                 return proto;
             auto jsobj = JS_NewObjectProtoClass(ctx, proto, js_traits<std::shared_ptr<T>>::QJSClassId);
             JS_FreeValue(ctx, proto);
-            if (JS_IsException(jsobj))
+            if(JS_IsException(jsobj))
                 return jsobj;
 
-            std::shared_ptr<T> ptr =  std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
+            std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
             JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
             return jsobj;
 
@@ -761,7 +796,7 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
             return jsobj;
 
         // shared_ptr with empty deleter since we don't own T*
-        auto pptr = new std::shared_ptr<T>(ptr, [](T *){});
+        auto pptr = new std::shared_ptr<T>(ptr, [](T *) {});
         JS_SetOpaque(jsobj, pptr);
         return jsobj;
     }
@@ -862,6 +897,7 @@ template <typename Key>
 struct js_property_traits
 {
     static void set_property(JSContext * ctx, JSValue this_obj, Key key, JSValue value);
+
     static JSValue get_property(JSContext * ctx, JSValue this_obj, Key key);
 };
 
@@ -989,28 +1025,28 @@ class Value
         v = rhs.v;
     }
 
-    Value& operator=(Value rhs)
+    Value& operator =(Value rhs)
     {
         std::swap(ctx, rhs.ctx);
         std::swap(v, rhs.v);
         return *this;
     }
 
-    bool operator==(JSValueConst other) const
+    bool operator ==(JSValueConst other) const
     {
         return JS_VALUE_GET_TAG(v) == JS_VALUE_GET_TAG(other) && JS_VALUE_GET_PTR(v) == JS_VALUE_GET_PTR(other);
     }
 
-    bool operator!=(JSValueConst other) const { return !((*this) == other); }
+    bool operator !=(JSValueConst other) const { return !((*this) == other); }
 
 
     /** Returns true if 2 values are the same (equality for arithmetic types or point to the same object) */
-    bool operator==(const Value& rhs) const
+    bool operator ==(const Value& rhs) const
     {
         return ctx == rhs.ctx && (*this == rhs.v);
     }
 
-    bool operator!=(const Value& rhs) const { return !((*this) == rhs); }
+    bool operator !=(const Value& rhs) const { return !((*this) == rhs); }
 
 
     ~Value()
@@ -1038,7 +1074,7 @@ class Value
     }
 
     /** Implicit conversion to JSValue (rvalue only). Example: JSValue v = std::move(value); */
-    operator JSValue() && { return release(); }
+    operator JSValue()&& { return release(); }
 
 
     /** Access JS properties. Returns proxy type which is implicitly convertible to qjs::Value */
@@ -1076,9 +1112,9 @@ class Value
         using fgetter = fwrapper<FGet, true>;
         using fsetter = fwrapper<FSet, true>;
         int ret = JS_DefinePropertyGetSet(ctx, v, prop,
-                                      js_traits<fgetter>::wrap(ctx, fgetter{name}),
-                                      js_traits<fsetter>::wrap(ctx, fsetter{name}),
-                                      JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE
+                                          js_traits<fgetter>::wrap(ctx, fgetter{name}),
+                                          js_traits<fsetter>::wrap(ctx, fsetter{name}),
+                                          JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE
         );
         JS_FreeAtom(ctx, prop);
         if(ret < 0)
@@ -1118,13 +1154,14 @@ class Value
         }
     }
 
-    std::string toJSON(const Value& replacer = Value{nullptr, JS_UNDEFINED}, const Value& space = Value{nullptr, JS_UNDEFINED})
+    std::string
+    toJSON(const Value& replacer = Value{nullptr, JS_UNDEFINED}, const Value& space = Value{nullptr, JS_UNDEFINED})
     {
         assert(ctx);
         assert(!replacer.ctx || ctx == replacer.ctx);
         assert(!space.ctx || ctx == space.ctx);
         JSValue json = JS_JSONStringify(ctx, v, replacer.v, space.v);
-        return (std::string)Value{ctx, json};
+        return (std::string) Value{ctx, json};
     }
 
 };
@@ -1359,8 +1396,7 @@ class Context
     }
 
 public:
-    Context(Runtime& rt) : Context(rt.rt)
-    {}
+    Context(Runtime& rt) : Context(rt.rt) {}
 
     Context(JSRuntime * rt)
     {
@@ -1435,7 +1471,8 @@ class Context
 
     Value fromJSON(std::string_view buffer, const char * filename = "<fromJSON>")
     {
-        assert(buffer.data()[buffer.size()] == '\0' && "fromJSON buffer is not null-terminated"); // JS_ParseJSON requirement
+        assert(buffer.data()[buffer.size()] == '\0' &&
+               "fromJSON buffer is not null-terminated"); // JS_ParseJSON requirement
         JSValue v = JS_ParseJSON(ctx, buffer.data(), buffer.size(), filename);
         return Value{ctx, v};
     }
@@ -1478,7 +1515,7 @@ struct js_traits<std::function<R(Args...)>>
         const int argc = sizeof...(Args);
         if constexpr(argc == 0)
         {
-            return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }]()->R {
+            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}]() -> R {
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, 0, nullptr);
                 if(JS_IsException(result))
                 {
@@ -1487,14 +1524,15 @@ struct js_traits<std::function<R(Args...)>>
                 }
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
-        } 
-        else 
+        }
+        else
         {
-            return[jsfun_obj = Value{ ctx, JS_DupValue(ctx, fun_obj) }](Args&& ... args)->R {
+            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
                 const int argc = sizeof...(Args);
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
-                JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc, const_cast<JSValueConst*>(argv));
+                JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, argc,
+                                         const_cast<JSValueConst *>(argv));
                 for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
                 if(JS_IsException(result))
                 {
@@ -1592,9 +1630,10 @@ struct js_traits<std::pair<U, V>>
             throw exception{};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
         const auto len = static_cast<uint32_t>(jsarray["length"]);
-        if (len != 2)
+        if(len != 2)
         {
-            JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expected array of length 2, got length %d", QJSPP_TYPENAME(std::pair<U, V>), len);
+            JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expected array of length 2, got length %d",
+                              QJSPP_TYPENAME(std::pair<U, V>), len);
             throw exception{};
         }
         return std::pair<U, V>{

From aa205130e5096b9b54c68d196a6d5049de7ca921 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 2 Mar 2021 19:05:25 +0300
Subject: [PATCH 092/185] js_traits for std::optional

---
 quickjspp.hpp | 43 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 37 insertions(+), 6 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 179520229d..a5954d2e2b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -14,6 +14,7 @@
 #include <functional>
 #include <stdexcept>
 #include <variant>
+#include <optional>
 
 
 #if defined(__cpp_rtti)
@@ -294,12 +295,8 @@ struct js_traits<std::variant<Ts...>>
         // try to unwrap embedded variant (variant<variant<...>>), might be slow
         if constexpr (is_variant<U>::value)
         {
-            try
-            {
-                return js_traits<U>::unwrap(ctx, v);
-            }
-            catch(exception)
-            { JS_FreeValue(ctx, JS_GetException(ctx)); } // ignore, clear exception
+            if(auto opt = js_traits<std::optional<U>>::unwrap(ctx, v))
+                return *opt;
         }
 
         if constexpr (is_vector<U>::value)
@@ -1643,6 +1640,40 @@ struct js_traits<std::pair<U, V>>
     }
 };
 
+/** Conversions for std::optional.
+ * Unlike other types does not throw on unwrap but returns nullopt.
+ * Converts std::nullopt to null.
+ */
+template <typename T>
+struct js_traits<std::optional<T>>
+{
+    /** Wraps T or null. */
+    static JSValue wrap(JSContext * ctx, std::optional<T> obj) noexcept
+    {
+        if(obj)
+            return js_traits<std::decay_t<T>>::wrap(ctx, *obj);
+        return JS_NULL;
+    }
+
+    /** If conversion to T fails returns std::nullopt. */
+    static auto unwrap(JSContext * ctx, JSValueConst v) noexcept -> std::optional<decltype(js_traits<std::decay_t<T>>::unwrap(ctx, v))>
+    {
+        try
+        {
+            if(JS_IsNull(v))
+                return std::nullopt;
+            return js_traits<std::decay_t<T>>::unwrap(ctx, v);
+        }
+        catch(exception)
+        {
+            // ignore and clear exception
+            JS_FreeValue(ctx, JS_GetException(ctx));
+        }
+        return std::nullopt;
+    }
+};
+
+
 namespace detail {
 template <typename Key>
 property_proxy<Key>::operator Value() const

From d4227e2ed98c8e7124eb0f653e7a008c44f54a8a Mon Sep 17 00:00:00 2001
From: Tindy X <49061470+tindy2013@users.noreply.github.com>
Date: Tue, 23 Mar 2021 16:29:40 +0800
Subject: [PATCH 093/185] Suppress 'missing initializer' warnings

---
 quickjspp.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index a5954d2e2b..f097ee374b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -725,7 +725,10 @@ struct js_traits<std::shared_ptr<T>>
                     [](JSRuntime * rt, JSValue obj) noexcept {
                         auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
                         delete pptr;
-                    }
+                    },
+                    nullptr,
+                    nullptr,
+                    nullptr
             };
             int e = JS_NewClass(rt, QJSClassId, &def);
             if(e < 0)
@@ -878,7 +881,8 @@ struct js_traits<detail::function>
                     if(!ptr)
                         return JS_EXCEPTION;
                     return ptr->invoker(ptr, ctx, this_val, argc, argv);
-                }
+                },
+                nullptr
         };
         int e = JS_NewClass(rt, QJSClassId, &def);
         if(e < 0)

From f3ce2451168171d03df7e7969682e7d935e291fd Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Apr 2021 10:06:54 +0300
Subject: [PATCH 094/185] add JS_GetClassID patch

---
 quickjs/patches/getclassid.patch | 31 +++++++++++++++++++++++++++++++
 quickjs/update.sh                |  2 ++
 2 files changed, 33 insertions(+)
 create mode 100644 quickjs/patches/getclassid.patch

diff --git a/quickjs/patches/getclassid.patch b/quickjs/patches/getclassid.patch
new file mode 100644
index 0000000000..991f749e8a
--- /dev/null
+++ b/quickjs/patches/getclassid.patch
@@ -0,0 +1,31 @@
+diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
+index 48aeffc62..8afc4caa1 100644
+--- a/quickjs/quickjs.c
++++ b/quickjs/quickjs.c
+@@ -54034,3 +54034,14 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
+     JS_AddIntrinsicAtomics(ctx);
+ #endif
+ }
++
++JSClassID JS_GetClassID(JSValue v)
++{
++    JSObject *p;
++
++    if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
++        return 0;
++    p = JS_VALUE_GET_OBJ(v);
++    assert(p != 0);
++    return p->class_id;
++}
+diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
+index d4a5cd311..054019147 100644
+--- a/quickjs/quickjs.h
++++ b/quickjs/quickjs.h
+@@ -497,6 +497,7 @@ typedef struct JSClassDef {
+ } JSClassDef;
+ 
+ JSClassID JS_NewClassID(JSClassID *pclass_id);
++JSClassID JS_GetClassID(JSValueConst v);
+ int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);
+ int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
+ 
diff --git a/quickjs/update.sh b/quickjs/update.sh
index cc2cbd45c6..cccd839bf9 100644
--- a/quickjs/update.sh
+++ b/quickjs/update.sh
@@ -9,5 +9,7 @@ ver="$(curl -s --compressed -L https://bellard.org/quickjs/ | grep --perl-regexp
 
 curl -s -L "https://bellard.org/quickjs/quickjs-${ver}.tar.xz" | unxz | tar --strip-components=1 -xf - -- "${@/#/quickjs-${ver}\/}"
 
+git apply --verbose -- patches/*.patch
+
 # commit (interactive)
 git commit -m "update quickjs to ${ver}" -e -- $@

From 8f220f3700e8f20225107882e2a28444a8c2fe28 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Apr 2021 10:07:27 +0300
Subject: [PATCH 095/185] update quickjs to 2021-03-27

---
 quickjs/VERSION        |   2 +-
 quickjs/libbf.c        |   2 +-
 quickjs/libbf.h        |   2 +-
 quickjs/quickjs-libc.c |  95 +++++--
 quickjs/quickjs.c      | 578 +++++++++++++++++++++++++++++------------
 quickjs/quickjs.h      |   8 +-
 6 files changed, 486 insertions(+), 201 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 78749b0c7e..22ffec1847 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2020-11-08
+2021-03-27
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index 3bf257a155..fe1628e797 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -1,7 +1,7 @@
 /*
  * Tiny arbitrary precision floating point library
  * 
- * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2021 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
index 4576bf8854..48e9d956a2 100644
--- a/quickjs/libbf.h
+++ b/quickjs/libbf.h
@@ -1,7 +1,7 @@
 /*
  * Tiny arbitrary precision floating point library
  * 
- * Copyright (c) 2017-2020 Fabrice Bellard
+ * Copyright (c) 2017-2021 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index e8b81e910c..e180dd0cd3 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -1,8 +1,8 @@
 /*
  * QuickJS C library
  * 
- * Copyright (c) 2017-2020 Fabrice Bellard
- * Copyright (c) 2017-2020 Charlie Gordon
+ * Copyright (c) 2017-2021 Fabrice Bellard
+ * Copyright (c) 2017-2021 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -1663,7 +1663,7 @@ static JSValue js_os_isatty(JSContext *ctx, JSValueConst this_val,
     int fd;
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    return JS_NewBool(ctx, isatty(fd) == 1);
+    return JS_NewBool(ctx, (isatty(fd) != 0));
 }
 
 #if defined(_WIN32)
@@ -1689,6 +1689,10 @@ static JSValue js_os_ttyGetWinSize(JSContext *ctx, JSValueConst this_val,
     return obj;
 }
 
+/* Windows 10 built-in VT100 emulation */
+#define __ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#define __ENABLE_VIRTUAL_TERMINAL_INPUT 0x0200
+
 static JSValue js_os_ttySetRaw(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
 {
@@ -1698,8 +1702,12 @@ static JSValue js_os_ttySetRaw(JSContext *ctx, JSValueConst this_val,
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     handle = (HANDLE)_get_osfhandle(fd);
-    
-    SetConsoleMode(handle, ENABLE_WINDOW_INPUT);
+    SetConsoleMode(handle, ENABLE_WINDOW_INPUT | __ENABLE_VIRTUAL_TERMINAL_INPUT);
+    _setmode(fd, _O_BINARY);
+    if (fd == 0) {
+        handle = (HANDLE)_get_osfhandle(1); /* corresponding output */
+        SetConsoleMode(handle, ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT | __ENABLE_VIRTUAL_TERMINAL_PROCESSING);
+    }
     return JS_UNDEFINED;
 }
 #else
@@ -1772,7 +1780,19 @@ static JSValue js_os_remove(JSContext *ctx, JSValueConst this_val,
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         return JS_EXCEPTION;
-    ret = js_get_errno(remove(filename));
+#if defined(_WIN32)
+    {
+        struct stat st;
+        if (stat(filename, &st) == 0 && S_ISDIR(st.st_mode)) {
+            ret = rmdir(filename);
+        } else {
+            ret = unlink(filename);
+        }
+    }
+#else
+    ret = remove(filename);
+#endif
+    ret = js_get_errno(ret);
     JS_FreeCString(ctx, filename);
     return JS_NewInt32(ctx, ret);
 }
@@ -2588,7 +2608,47 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, ret);
 }
 
-#if !defined(_WIN32)
+/* sleep(delay_ms) */
+static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    int64_t delay;
+    int ret;
+    
+    if (JS_ToInt64(ctx, &delay, argv[0]))
+        return JS_EXCEPTION;
+    if (delay < 0)
+        delay = 0;
+#if defined(_WIN32)
+    {
+        if (delay > INT32_MAX)
+            delay = INT32_MAX;
+        Sleep(delay);
+        ret = 0;
+    }
+#else
+    {
+        struct timespec ts;
+
+        ts.tv_sec = delay / 1000;
+        ts.tv_nsec = (delay % 1000) * 1000000;
+        ret = js_get_errno(nanosleep(&ts, NULL));
+    }
+#endif
+    return JS_NewInt32(ctx, ret);
+}
+
+#if defined(_WIN32)
+static char *realpath(const char *path, char *buf)
+{
+    if (!_fullpath(buf, path, PATH_MAX)) {
+        errno = ENOENT;
+        return NULL;
+    } else {
+        return buf;
+    }
+}
+#endif
 
 /* return [path, errorcode] */
 static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
@@ -2612,6 +2672,7 @@ static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
     return make_string_error(ctx, buf, err);
 }
 
+#if !defined(_WIN32)
 static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv)
 {
@@ -3031,22 +3092,6 @@ static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
     return JS_NewInt32(ctx, ret);
 }
 
-/* sleep(delay_ms) */
-static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
-                          int argc, JSValueConst *argv)
-{
-    int64_t delay;
-    struct timespec ts;
-    int ret;
-    
-    if (JS_ToInt64(ctx, &delay, argv[0]))
-        return JS_EXCEPTION;
-    ts.tv_sec = delay / 1000;
-    ts.tv_nsec = (delay % 1000) * 1000000;
-    ret = js_get_errno(nanosleep(&ts, NULL));
-    return JS_NewInt32(ctx, ret);
-}
-
 /* dup(fd) */
 static JSValue js_os_dup(JSContext *ctx, JSValueConst this_val,
                          int argc, JSValueConst *argv)
@@ -3598,9 +3643,10 @@ static const JSCFunctionListEntry js_os_funcs[] = {
 #endif
     JS_CFUNC_MAGIC_DEF("stat", 1, js_os_stat, 0 ),
     JS_CFUNC_DEF("utimes", 3, js_os_utimes ),
+    JS_CFUNC_DEF("sleep", 1, js_os_sleep ),
+    JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
 #if !defined(_WIN32)
     JS_CFUNC_MAGIC_DEF("lstat", 1, js_os_stat, 1 ),
-    JS_CFUNC_DEF("realpath", 1, js_os_realpath ),
     JS_CFUNC_DEF("symlink", 2, js_os_symlink ),
     JS_CFUNC_DEF("readlink", 1, js_os_readlink ),
     JS_CFUNC_DEF("exec", 1, js_os_exec ),
@@ -3608,7 +3654,6 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     OS_FLAG(WNOHANG),
     JS_CFUNC_DEF("pipe", 0, js_os_pipe ),
     JS_CFUNC_DEF("kill", 2, js_os_kill ),
-    JS_CFUNC_DEF("sleep", 1, js_os_sleep ),
     JS_CFUNC_DEF("dup", 1, js_os_dup ),
     JS_CFUNC_DEF("dup2", 2, js_os_dup2 ),
 #endif
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index e09ba90bc4..8afc4caa13 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -1,8 +1,8 @@
 /*
  * QuickJS Javascript Engine
  * 
- * Copyright (c) 2017-2020 Fabrice Bellard
- * Copyright (c) 2017-2020 Charlie Gordon
+ * Copyright (c) 2017-2021 Fabrice Bellard
+ * Copyright (c) 2017-2021 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -36,6 +36,8 @@
 #include <malloc/malloc.h>
 #elif defined(__linux__)
 #include <malloc.h>
+#elif defined(__FreeBSD__)
+#include <malloc_np.h>
 #endif
 
 #include "cutils.h"
@@ -265,9 +267,10 @@ struct JSRuntime {
     struct list_head string_list; /* list of JSString.link */
 #endif
     /* stack limitation */
-    const uint8_t *stack_top;
-    size_t stack_size; /* in bytes */
-
+    uintptr_t stack_size; /* in bytes, 0 if no limit */
+    uintptr_t stack_top;
+    uintptr_t stack_limit; /* lower stack limit */
+    
     JSValue current_exception;
     /* true if inside an out of memory error, to avoid recursing */
     BOOL in_out_of_memory : 8;
@@ -1569,9 +1572,9 @@ static void set_dummy_numeric_ops(JSNumericOperations *ops)
 
 #if !defined(CONFIG_STACK_CHECK)
 /* no stack limitation */
-static inline uint8_t *js_get_stack_pointer(void)
+static inline uintptr_t js_get_stack_pointer(void)
 {
-    return NULL;
+    return 0;
 }
 
 static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
@@ -1580,16 +1583,16 @@ static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
 }
 #else
 /* Note: OS and CPU dependent */
-static inline uint8_t *js_get_stack_pointer(void)
+static inline uintptr_t js_get_stack_pointer(void)
 {
-    return __builtin_frame_address(0);
+    return (uintptr_t)__builtin_frame_address(0);
 }
 
 static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
 {
-    size_t size;
-    size = rt->stack_top - js_get_stack_pointer();
-    return unlikely((size + alloca_size) > rt->stack_size);
+    uintptr_t sp;
+    sp = js_get_stack_pointer() - alloca_size;
+    return unlikely(sp < rt->stack_limit);
 }
 #endif
 
@@ -1649,8 +1652,9 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     if (init_shape_hash(rt))
         goto fail;
 
-    rt->stack_top = js_get_stack_pointer();
     rt->stack_size = JS_DEFAULT_STACK_SIZE;
+    JS_UpdateStackTop(rt);
+
     rt->current_exception = JS_NULL;
 
     return rt;
@@ -2338,9 +2342,25 @@ JSRuntime *JS_GetRuntime(JSContext *ctx)
     return ctx->rt;
 }
 
+static void update_stack_limit(JSRuntime *rt)
+{
+    if (rt->stack_size == 0) {
+        rt->stack_limit = 0; /* no limit */
+    } else {
+        rt->stack_limit = rt->stack_top - rt->stack_size;
+    }
+}
+
 void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size)
 {
     rt->stack_size = stack_size;
+    update_stack_limit(rt);
+}
+
+void JS_UpdateStackTop(JSRuntime *rt)
+{
+    rt->stack_top = js_get_stack_pointer();
+    update_stack_limit(rt);
 }
 
 static inline BOOL is_strict_mode(JSContext *ctx)
@@ -3377,6 +3397,8 @@ static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
     JSClass *cl, *new_class_array;
     struct list_head *el;
 
+    if (class_id >= (1 << 16))
+        return -1;
     if (class_id < rt->class_count &&
         rt->class_array[class_id].class_id != 0)
         return -1;
@@ -8231,6 +8253,23 @@ static int set_array_length(JSContext *ctx, JSObject *p, JSValue val,
     return TRUE;
 }
 
+/* return -1 if exception */
+static int expand_fast_array(JSContext *ctx, JSObject *p, uint32_t new_len)
+{
+    uint32_t new_size;
+    size_t slack;
+    JSValue *new_array_prop;
+    /* XXX: potential arithmetic overflow */
+    new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
+    new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
+    if (!new_array_prop)
+        return -1;
+    new_size += slack / sizeof(*new_array_prop);
+    p->u.array.u.values = new_array_prop;
+    p->u.array.u1.size = new_size;
+    return 0;
+}
+
 /* Preconditions: 'p' must be of class JS_CLASS_ARRAY, p->fast_array =
    TRUE and p->extensible = TRUE */
 static int add_fast_array_element(JSContext *ctx, JSObject *p,
@@ -8253,19 +8292,10 @@ static int add_fast_array_element(JSContext *ctx, JSObject *p,
         }
     }
     if (unlikely(new_len > p->u.array.u1.size)) {
-        uint32_t new_size;
-        size_t slack;
-        JSValue *new_array_prop;
-        /* XXX: potential arithmetic overflow */
-        new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
-        new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
-        if (!new_array_prop) {
+        if (expand_fast_array(ctx, p, new_len)) {
             JS_FreeValue(ctx, val);
             return -1;
         }
-        new_size += slack / sizeof(*new_array_prop);
-        p->u.array.u.values = new_array_prop;
-        p->u.array.u1.size = new_size;
     }
     p->u.array.u.values[new_len - 1] = val;
     p->u.array.count = new_len;
@@ -8279,22 +8309,24 @@ static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc)
     JS_FreeValue(ctx, desc->value);
 }
 
-/* generic (and slower) version of JS_SetProperty() for Reflect.set() */
+/* generic (and slower) version of JS_SetProperty() for
+ * Reflect.set(). 'obj' must be an object.  */
 static int JS_SetPropertyGeneric(JSContext *ctx,
-                                 JSObject *p, JSAtom prop,
+                                 JSValueConst obj, JSAtom prop,
                                  JSValue val, JSValueConst this_obj,
                                  int flags)
 {
     int ret;
     JSPropertyDescriptor desc;
-
-    while (p != NULL) {
+    JSValue obj1;
+    JSObject *p;
+    
+    obj1 = JS_DupValue(ctx, obj);
+    for(;;) {
+        p = JS_VALUE_GET_OBJ(obj1);
         if (p->is_exotic) {
             const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
             if (em && em->set_property) {
-                JSValue obj1;
-                /* set_property can free the prototype */
-                obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
                 ret = em->set_property(ctx, obj1, prop,
                                        val, this_obj, flags);
                 JS_FreeValue(ctx, obj1);
@@ -8304,8 +8336,11 @@ static int JS_SetPropertyGeneric(JSContext *ctx,
         }
 
         ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
-        if (ret < 0)
+        if (ret < 0) {
+            JS_FreeValue(ctx, obj1);
+            JS_FreeValue(ctx, val);
             return ret;
+        }
         if (ret) {
             if (desc.flags & JS_PROP_GETSET) {
                 JSObject *setter;
@@ -8316,27 +8351,38 @@ static int JS_SetPropertyGeneric(JSContext *ctx,
                 ret = call_setter(ctx, setter, this_obj, val, flags);
                 JS_FreeValue(ctx, desc.getter);
                 JS_FreeValue(ctx, desc.setter);
+                JS_FreeValue(ctx, obj1);
                 return ret;
             } else {
                 JS_FreeValue(ctx, desc.value);
                 if (!(desc.flags & JS_PROP_WRITABLE)) {
+                    JS_FreeValue(ctx, obj1);
                     goto read_only_error;
                 }
             }
             break;
         }
-        p = p->shape->proto;
+        /* Note: at this point 'obj1' cannot be a proxy. XXX: may have
+           to check recursion */
+        obj1 = JS_GetPrototypeFree(ctx, obj1);
+        if (JS_IsNull(obj1))
+            break;
     }
+    JS_FreeValue(ctx, obj1);
 
-    if (!JS_IsObject(this_obj))
+    if (!JS_IsObject(this_obj)) {
+        JS_FreeValue(ctx, val);
         return JS_ThrowTypeErrorOrFalse(ctx, flags, "receiver is not an object");
-
+    }
+    
     p = JS_VALUE_GET_OBJ(this_obj);
 
     /* modify the property in this_obj if it already exists */
     ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
-    if (ret < 0)
+    if (ret < 0) {
+        JS_FreeValue(ctx, val);
         return ret;
+    }
     if (ret) {
         if (desc.flags & JS_PROP_GETSET) {
             JS_FreeValue(ctx, desc.getter);
@@ -15022,10 +15068,10 @@ static JSValue js_build_rest(JSContext *ctx, int first, int argc, JSValueConst *
 
 static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
 {
-    JSObject *p, *p1;
+    JSObject *p;
     JSPropertyEnum *tab_atom;
     int i;
-    JSValue enum_obj;
+    JSValue enum_obj, obj1;
     JSForInIterator *it;
     uint32_t tag, tab_atom_count;
 
@@ -15054,20 +15100,34 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
     if (tag == JS_TAG_NULL || tag == JS_TAG_UNDEFINED)
         return enum_obj;
 
-    p = JS_VALUE_GET_OBJ(obj);
-
     /* fast path: assume no enumerable properties in the prototype chain */
-    p1 = p->shape->proto;
-    while (p1 != NULL) {
-        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p1,
-                                   JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY))
+    obj1 = JS_DupValue(ctx, obj);
+    for(;;) {
+        obj1 = JS_GetPrototypeFree(ctx, obj1);
+        if (JS_IsNull(obj1))
+            break;
+        if (JS_IsException(obj1))
             goto fail;
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
+                                           JS_VALUE_GET_OBJ(obj1),
+                                           JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY)) {
+            JS_FreeValue(ctx, obj1);
+            goto fail;
+        }
         js_free_prop_enum(ctx, tab_atom, tab_atom_count);
         if (tab_atom_count != 0) {
+            JS_FreeValue(ctx, obj1);
             goto slow_path;
         }
-        p1 = p1->shape->proto;
+        /* must check for timeout to avoid infinite loop */
+        if (js_poll_interrupts(ctx)) {
+            JS_FreeValue(ctx, obj1);
+            goto fail;
+        }
     }
+
+    p = JS_VALUE_GET_OBJ(obj);
+
     if (p->fast_array) {
         JSShape *sh;
         JSShapeProperty *prs;
@@ -15095,17 +15155,30 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
  slow_path:
     /* non enumerable properties hide the enumerables ones in the
        prototype chain */
-    while (p != NULL) {
-        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
-                                   JS_GPN_STRING_MASK | JS_GPN_SET_ENUM))
+    obj1 = JS_DupValue(ctx, obj);
+    for(;;) {
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
+                                           JS_VALUE_GET_OBJ(obj1),
+                                           JS_GPN_STRING_MASK | JS_GPN_SET_ENUM)) {
+            JS_FreeValue(ctx, obj1);
             goto fail;
+        }
         for(i = 0; i < tab_atom_count; i++) {
             JS_DefinePropertyValue(ctx, enum_obj, tab_atom[i].atom, JS_NULL,
                                    (tab_atom[i].is_enumerable ?
                                     JS_PROP_ENUMERABLE : 0));
         }
         js_free_prop_enum(ctx, tab_atom, tab_atom_count);
-        p = p->shape->proto;
+        obj1 = JS_GetPrototypeFree(ctx, obj1);
+        if (JS_IsNull(obj1))
+            break;
+        if (JS_IsException(obj1))
+            goto fail;
+        /* must check for timeout to avoid infinite loop */
+        if (js_poll_interrupts(ctx)) {
+            JS_FreeValue(ctx, obj1);
+            goto fail;
+        }
     }
     return enum_obj;
 
@@ -15572,8 +15645,10 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
     uint32_t i, tab_atom_count;
     JSObject *p;
     JSObject *pexcl = NULL;
-    int ret = 0, flags;
-
+    int ret, gpn_flags;
+    JSPropertyDescriptor desc;
+    BOOL is_enumerable;
+    
     if (JS_VALUE_GET_TAG(source) != JS_TAG_OBJECT)
         return 0;
 
@@ -15581,37 +15656,57 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
         pexcl = JS_VALUE_GET_OBJ(excluded);
 
     p = JS_VALUE_GET_OBJ(source);
+
+    gpn_flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK | JS_GPN_ENUM_ONLY;
+    if (p->is_exotic) {
+        const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
+        /* cannot use JS_GPN_ENUM_ONLY with e.g. proxies because it
+           introduces a visible change */
+        if (em && em->get_own_property_names) {
+            gpn_flags &= ~JS_GPN_ENUM_ONLY;
+        }
+    }
     if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
-                               JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK |
-                               JS_GPN_ENUM_ONLY))
+                                       gpn_flags))
         return -1;
-
-    flags = JS_PROP_C_W_E;
-
+    
     for (i = 0; i < tab_atom_count; i++) {
         if (pexcl) {
             ret = JS_GetOwnPropertyInternal(ctx, NULL, pexcl, tab_atom[i].atom);
             if (ret) {
                 if (ret < 0)
-                    break;
-                ret = 0;
+                    goto exception;
                 continue;
             }
         }
-        ret = -1;
+        if (!(gpn_flags & JS_GPN_ENUM_ONLY)) {
+            /* test if the property is enumerable */
+            ret = JS_GetOwnPropertyInternal(ctx, &desc, p, tab_atom[i].atom);
+            if (ret < 0)
+                goto exception;
+            if (!ret)
+                continue;
+            is_enumerable = (desc.flags & JS_PROP_ENUMERABLE) != 0;
+            js_free_desc(ctx, &desc);
+            if (!is_enumerable)
+                continue;
+        }
         val = JS_GetProperty(ctx, source, tab_atom[i].atom);
         if (JS_IsException(val))
-            break;
+            goto exception;
         if (setprop)
             ret = JS_SetProperty(ctx, target, tab_atom[i].atom, val);
         else
-            ret = JS_DefinePropertyValue(ctx, target, tab_atom[i].atom, val, flags);
+            ret = JS_DefinePropertyValue(ctx, target, tab_atom[i].atom, val,
+                                         JS_PROP_C_W_E);
         if (ret < 0)
-            break;
-        ret = 0;
+            goto exception;
     }
     js_free_prop_enum(ctx, tab_atom, tab_atom_count);
-    return ret;
+    return 0;
+ exception:
+    js_free_prop_enum(ctx, tab_atom, tab_atom_count);
+    return -1;
 }
 
 /* only valid inside C functions */
@@ -16654,7 +16749,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_check_ctor):
             if (JS_IsUndefined(new_target)) {
-                JS_ThrowTypeError(caller_ctx, "class constructors must be invoked with 'new'");
+                JS_ThrowTypeError(ctx, "class constructors must be invoked with 'new'");
                 goto exception;
             }
             BREAK;
@@ -17770,8 +17865,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = JS_ValueToAtom(ctx, sp[-2]);
                 if (unlikely(atom == JS_ATOM_NULL))
                     goto exception;
-                ret = JS_SetPropertyGeneric(ctx, JS_VALUE_GET_OBJ(sp[-3]),
-                                            atom, sp[-1], sp[-4],
+                ret = JS_SetPropertyGeneric(ctx, sp[-3], atom, sp[-1], sp[-4],
                                             JS_PROP_THROW_STRICT);
                 JS_FreeAtom(ctx, atom);
                 JS_FreeValue(ctx, sp[-4]);
@@ -22678,7 +22772,7 @@ static __exception int js_parse_left_hand_side_expr(JSParseState *s)
     return js_parse_postfix_expr(s, PF_POSTFIX_CALL);
 }
 
-/* XXX: is there is nicer solution ? */
+/* XXX: could generate specific bytecode */
 static __exception int js_parse_class_default_ctor(JSParseState *s,
                                                    BOOL has_super,
                                                    JSFunctionDef **pfd)
@@ -22691,7 +22785,8 @@ static __exception int js_parse_class_default_ctor(JSParseState *s,
     
     js_parse_get_pos(s, &pos);
     if (has_super) {
-        str = "(...a){super(...a);}";
+        /* spec change: no argument evaluation */
+        str = "(){super(...arguments);}";
         func_type = JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR;
     } else {
         str = "(){}";
@@ -34227,6 +34322,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     bc_put_leb128(s, b->cpool_count);
     bc_put_leb128(s, b->byte_code_len);
     if (b->vardefs) {
+        /* XXX: this field is redundant */
         bc_put_leb128(s, b->arg_count + b->var_count);
         for(i = 0; i < b->arg_count + b->var_count; i++) {
             JSVarDef *vd = &b->vardefs[i];
@@ -35196,6 +35292,16 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
             
     memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
     b->header.ref_count = 1;
+    if (local_count != 0) {
+        b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
+    }
+    if (b->closure_var_count != 0) {
+        b->closure_var = (void *)((uint8_t*)b + closure_var_offset);
+    }
+    if (b->cpool_count != 0) {
+        b->cpool = (void *)((uint8_t*)b + cpool_offset);
+    }
+    
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
             
     obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
@@ -35211,7 +35317,6 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
 
     if (local_count != 0) {
         bc_read_trace(s, "vars {\n");
-        b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
         for(i = 0; i < local_count; i++) {
             JSVarDef *vd = &b->vardefs[i];
             if (bc_get_atom(s, &vd->var_name))
@@ -35236,7 +35341,6 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     }
     if (b->closure_var_count != 0) {
         bc_read_trace(s, "closure vars {\n");
-        b->closure_var = (void *)((uint8_t*)b + closure_var_offset);
         for(i = 0; i < b->closure_var_count; i++) {
             JSClosureVar *cv = &b->closure_var[i];
             int var_idx;
@@ -35288,7 +35392,6 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     }
     if (b->cpool_count != 0) {
         bc_read_trace(s, "cpool {\n");
-        b->cpool = (void *)((uint8_t*)b + cpool_offset);
         for(i = 0; i < b->cpool_count; i++) {
             JSValue val;
             val = JS_ReadObjectRec(s);
@@ -37493,6 +37596,10 @@ static JSValue *build_arg_list(JSContext *ctx, uint32_t *plen,
     }
     if (js_get_length32(ctx, &len, array_arg))
         return NULL;
+    if (len > JS_MAX_LOCAL_VARS) {
+        JS_ThrowInternalError(ctx, "too many arguments");
+        return NULL;
+    }
     /* avoid allocating 0 bytes */
     tab = js_mallocz(ctx, sizeof(tab[0]) * max_uint32(1, len));
     if (!tab)
@@ -38293,9 +38400,16 @@ static JSValue js_array_every(JSContext *ctx, JSValueConst this_val,
     n = 0;
 
     for(k = 0; k < len; k++) {
-        present = JS_TryGetPropertyInt64(ctx, obj, k, &val);
-        if (present < 0)
-            goto exception;
+        if (special & special_TA) {
+            val = JS_GetPropertyInt64(ctx, obj, k);
+            if (JS_IsException(val))
+                goto exception;
+            present = TRUE;
+        } else {
+            present = JS_TryGetPropertyInt64(ctx, obj, k, &val);
+            if (present < 0)
+                goto exception;
+        }
         if (present) {
             index_val = JS_NewInt64(ctx, k);
             if (JS_IsException(index_val))
@@ -38413,18 +38527,32 @@ static JSValue js_array_reduce(JSContext *ctx, JSValueConst this_val,
             }
             k1 = (special & special_reduceRight) ? len - k - 1 : k;
             k++;
-            present = JS_TryGetPropertyInt64(ctx, obj, k1, &acc);
-            if (present < 0)
-                goto exception;
-            if (present)
+            if (special & special_TA) {
+                acc = JS_GetPropertyInt64(ctx, obj, k1);
+                if (JS_IsException(acc))
+                    goto exception;
                 break;
+            } else {
+                present = JS_TryGetPropertyInt64(ctx, obj, k1, &acc);
+                if (present < 0)
+                    goto exception;
+                if (present)
+                    break;
+            }
         }
     }
     for (; k < len; k++) {
         k1 = (special & special_reduceRight) ? len - k - 1 : k;
-        present = JS_TryGetPropertyInt64(ctx, obj, k1, &val);
-        if (present < 0)
-            goto exception;
+        if (special & special_TA) {
+            val = JS_GetPropertyInt64(ctx, obj, k1);
+            if (JS_IsException(val))
+                goto exception;
+            present = TRUE;
+        } else {
+            present = JS_TryGetPropertyInt64(ctx, obj, k1, &val);
+            if (present < 0)
+                goto exception;
+        }
         if (present) {
             index_val = JS_NewInt64(ctx, k1);
             if (JS_IsException(index_val))
@@ -38829,27 +38957,64 @@ static JSValue js_array_push(JSContext *ctx, JSValueConst this_val,
     int64_t len, from, newLen;
 
     obj = JS_ToObject(ctx, this_val);
-    if (js_get_length64(ctx, &len, obj))
-        goto exception;
-    newLen = len + argc;
-    if (newLen > MAX_SAFE_INTEGER) {
-        JS_ThrowTypeError(ctx, "Array loo long");
-        goto exception;
-    }
-    from = len;
-    if (unshift && argc > 0) {
-        if (JS_CopySubArray(ctx, obj, argc, 0, len, -1))
+
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(obj);
+        if (p->class_id != JS_CLASS_ARRAY ||
+            !p->fast_array || !p->extensible)
+            goto generic_case;
+        /* length must be writable */
+        if (unlikely(!(get_shape_prop(p->shape)->flags & JS_PROP_WRITABLE)))
+            goto generic_case;
+        /* check the length */
+        if (unlikely(JS_VALUE_GET_TAG(p->prop[0].u.value) != JS_TAG_INT))
+            goto generic_case;
+        len = JS_VALUE_GET_INT(p->prop[0].u.value);
+        /* we don't support holes */
+        if (unlikely(len != p->u.array.count))
+            goto generic_case;
+        newLen = len + argc;
+        if (unlikely(newLen > INT32_MAX))
+            goto generic_case;
+        if (newLen > p->u.array.u1.size) {
+            if (expand_fast_array(ctx, p, newLen))
+                goto exception;
+        }
+        if (unshift && argc > 0) {
+            memmove(p->u.array.u.values + argc, p->u.array.u.values,
+                    len * sizeof(p->u.array.u.values[0]));
+            from = 0;
+        } else {
+            from = len;
+        }
+        for(i = 0; i < argc; i++) {
+            p->u.array.u.values[from + i] = JS_DupValue(ctx, argv[i]);
+        }
+        p->u.array.count = newLen;
+        p->prop[0].u.value = JS_NewInt32(ctx, newLen);
+    } else {
+    generic_case:
+        if (js_get_length64(ctx, &len, obj))
             goto exception;
-        from = 0;
-    }
-    for(i = 0; i < argc; i++) {
-        if (JS_SetPropertyInt64(ctx, obj, from + i,
-                                JS_DupValue(ctx, argv[i])) < 0)
+        newLen = len + argc;
+        if (newLen > MAX_SAFE_INTEGER) {
+            JS_ThrowTypeError(ctx, "Array loo long");
+            goto exception;
+        }
+        from = len;
+        if (unshift && argc > 0) {
+            if (JS_CopySubArray(ctx, obj, argc, 0, len, -1))
+                goto exception;
+            from = 0;
+        }
+        for(i = 0; i < argc; i++) {
+            if (JS_SetPropertyInt64(ctx, obj, from + i,
+                                    JS_DupValue(ctx, argv[i])) < 0)
+                goto exception;
+        }
+        if (JS_SetProperty(ctx, obj, JS_ATOM_length, JS_NewInt64(ctx, newLen)) < 0)
             goto exception;
     }
-    if (JS_SetProperty(ctx, obj, JS_ATOM_length, JS_NewInt64(ctx, newLen)) < 0)
-        goto exception;
-
     JS_FreeValue(ctx, obj);
     return JS_NewInt64(ctx, newLen);
 
@@ -39079,6 +39244,11 @@ static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValueConst target,
     int64_t sourceIndex, elementLen;
     int present, is_array;
 
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        return -1;
+    }
+
     for (sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
         present = JS_TryGetPropertyInt64(ctx, source, sourceIndex, &element);
         if (present < 0)
@@ -41816,7 +41986,7 @@ static JSValue js___date_clock(JSContext *ctx, JSValueConst this_val,
 }
 
 /* OS dependent. d = argv[0] is in ms from 1970. Return the difference
-   between local time and UTC time 'd' in minutes */
+   between UTC time and local time 'd' in minutes */
 static int getTimezoneOffset(int64_t time) {
 #if defined(_WIN32)
     /* XXX: TODO */
@@ -44165,7 +44335,7 @@ static JSValue js_reflect_set(JSContext *ctx, JSValueConst this_val,
     atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
-    ret = JS_SetPropertyGeneric(ctx, JS_VALUE_GET_OBJ(obj), atom,
+    ret = JS_SetPropertyGeneric(ctx, obj, atom,
                                 JS_DupValue(ctx, val), receiver, 0);
     JS_FreeAtom(ctx, atom);
     if (ret < 0)
@@ -44513,7 +44683,7 @@ static int js_proxy_set(JSContext *ctx, JSValueConst obj, JSAtom atom,
     if (!s)
         return -1;
     if (JS_IsUndefined(method)) {
-        return JS_SetPropertyGeneric(ctx, JS_VALUE_GET_OBJ(s->target), atom,
+        return JS_SetPropertyGeneric(ctx, s->target, atom,
                                      JS_DupValue(ctx, value), receiver,
                                      flags);
     }
@@ -48134,24 +48304,22 @@ static void string_skip_non_spaces(JSString *sp, int *pp) {
         *pp += 1;
 }
 
-/* parse a numeric field */
-static int string_get_field(JSString *sp, int *pp, int64_t *pval) {
+/* parse a numeric field with an optional sign if accept_sign is TRUE */
+static int string_get_digits(JSString *sp, int *pp, int64_t *pval) {
     int64_t v = 0;
-    int c, p = *pp;
-
-    /* skip non digits, should only skip spaces? */
-    while (p < sp->len) {
-        c = string_get(sp, p);
-        if (c >= '0' && c <= '9')
-            break;
-        p++;
-    }
+    int c, p = *pp, p_start;
+    
     if (p >= sp->len)
         return -1;
+    p_start = p;
     while (p < sp->len) {
         c = string_get(sp, p);
-        if (!(c >= '0' && c <= '9'))
-            break;
+        if (!(c >= '0' && c <= '9')) {
+            if (p == p_start)
+                return -1;
+            else
+                break;
+        }
         v = v * 10 + c - '0';
         p++;
     }
@@ -48160,8 +48328,25 @@ static int string_get_field(JSString *sp, int *pp, int64_t *pval) {
     return 0;
 }
 
+static int string_get_signed_digits(JSString *sp, int *pp, int64_t *pval) {
+    int res, sgn, p = *pp;
+    
+    if (p >= sp->len)
+        return -1;
+
+    sgn = string_get(sp, p);
+    if (sgn == '-' || sgn == '+')
+        p++;
+ 
+    res = string_get_digits(sp, &p, pval);
+    if (res == 0 && sgn == '-')
+        *pval = -*pval;
+    *pp = p;
+    return res;
+}
+
 /* parse a fixed width numeric field */
-static int string_get_digits(JSString *sp, int *pp, int n, int64_t *pval) {
+static int string_get_fixed_width_digits(JSString *sp, int *pp, int n, int64_t *pval) {
     int64_t v = 0;
     int i, c, p = *pp;
 
@@ -48179,23 +48364,32 @@ static int string_get_digits(JSString *sp, int *pp, int n, int64_t *pval) {
     return 0;
 }
 
-/* parse a signed numeric field */
-static int string_get_signed_field(JSString *sp, int *pp, int64_t *pval) {
-    int sgn, res;
-
-    if (*pp >= sp->len)
+static int string_get_milliseconds(JSString *sp, int *pp, int64_t *pval) {
+    /* parse milliseconds as a fractional part, round to nearest */
+    /* XXX: the spec does not indicate which rounding should be used */
+    int mul = 1000, ms = 0, p = *pp, c, p_start;
+    if (p >= sp->len)
         return -1;
-
-    sgn = string_get(sp, *pp);
-    if (sgn == '-' || sgn == '+')
-        *pp += 1;
-
-    res = string_get_field(sp, pp, pval);
-    if (res == 0 && sgn == '-')
-        *pval = -*pval;
-    return res;
+    p_start = p;
+    while (p < sp->len) {
+        c = string_get(sp, p);
+        if (!(c >= '0' && c <= '9')) {
+            if (p == p_start)
+                return -1;
+            else
+                break;
+        }
+        if (mul == 1 && c >= '5')
+            ms += 1;
+        ms += (c - '0') * (mul /= 10);
+        p++;
+    }
+    *pval = ms;
+    *pp = p;
+    return 0;
 }
 
+
 static int find_abbrev(JSString *sp, int p, const char *list, int count) {
     int n, i;
 
@@ -48234,7 +48428,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
     double fields1[7];
     int64_t tz, hh, mm;
     double d;
-    int p, i, c, sgn;
+    int p, i, c, sgn, l;
     JSString *sp;
     BOOL is_local;
     
@@ -48249,50 +48443,74 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
     if (p < sp->len && (((c = string_get(sp, p)) >= '0' && c <= '9') || c == '+' || c == '-')) {
         /* ISO format */
         /* year field can be negative */
-        /* XXX: could be stricter */
-        if (string_get_signed_field(sp, &p, &fields[0]))
+        if (string_get_signed_digits(sp, &p, &fields[0]))
             goto done;
 
-        is_local = TRUE;
-        for (i = 1; i < 6; i++) {
-            if (string_get_field(sp, &p, &fields[i]))
+        for (i = 1; i < 7; i++) {
+            if (p >= sp->len)
                 break;
-        }
-        if (i <= 3) {
-            /* no time: UTC by default */
-            is_local = FALSE;
-        } else if (i == 6 && p < sp->len && string_get(sp, p) == '.') {
-            /* parse milliseconds as a fractional part, round to nearest */
-            /* XXX: the spec does not indicate which rounding should be used */
-            int mul = 1000, ms = 0;
-            while (++p < sp->len) {
-                int c = string_get(sp, p);
-                if (!(c >= '0' && c <= '9'))
-                    break;
-                if (mul == 1 && c >= '5')
-                    ms += 1;
-                ms += (c - '0') * (mul /= 10);
+            switch(i) {
+            case 1:
+            case 2:
+                c = '-';
+                break;
+            case 3:
+                c = 'T';
+                break;
+            case 4:
+            case 5:
+                c = ':';
+                break;
+            case 6:
+                c = '.';
+                break;
+            }
+            if (string_get(sp, p) != c)
+                break;
+            p++;
+            if (i == 6) {
+                if (string_get_milliseconds(sp, &p, &fields[i]))
+                    goto done;
+            } else {
+                if (string_get_digits(sp, &p, &fields[i]))
+                    goto done;
             }
-            fields[6] = ms;
         }
+        /* no time: UTC by default */
+        is_local = (i > 3);
         fields[1] -= 1;
 
-        /* parse the time zone offset if present: [+-]HH:mm */
+        /* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
         tz = 0;
         if (p < sp->len) {
             sgn = string_get(sp, p);
             if (sgn == '+' || sgn == '-') {
-                if (string_get_field(sp, &p, &hh))
+                p++;
+                l = sp->len - p;
+                if (l != 4 && l != 5)
+                    goto done;
+                if (string_get_fixed_width_digits(sp, &p, 2, &hh))
                     goto done;
-                if (string_get_field(sp, &p, &mm))
+                if (l == 5) {
+                    if (string_get(sp, p) != ':')
+                        goto done;
+                    p++;
+                }
+                if (string_get_fixed_width_digits(sp, &p, 2, &mm))
                     goto done;
                 tz = hh * 60 + mm;
                 if (sgn == '-')
                     tz = -tz;
                 is_local = FALSE;
             } else if (sgn == 'Z') {
+                p++;
                 is_local = FALSE;
+            } else {
+                goto done;
             }
+            /* error if extraneous characters */
+            if (p != sp->len)
+                goto done;
         }
     } else {
         /* toString or toUTCString format */
@@ -48304,7 +48522,7 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
         c = string_get(sp, p);
         if (c >= '0' && c <= '9') {
             /* day of month first */
-            if (string_get_field(sp, &p, &fields[2]))
+            if (string_get_digits(sp, &p, &fields[2]))
                 goto done;
             if (string_get_month(sp, &p, &fields[1]))
                 goto done;
@@ -48312,16 +48530,26 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
             /* month first */
             if (string_get_month(sp, &p, &fields[1]))
                 goto done;
-            if (string_get_field(sp, &p, &fields[2]))
+            string_skip_spaces(sp, &p);
+            if (string_get_digits(sp, &p, &fields[2]))
                 goto done;
         }
+        /* year */
         string_skip_spaces(sp, &p);
-        if (string_get_signed_field(sp, &p, &fields[0]))
+        if (string_get_signed_digits(sp, &p, &fields[0]))
             goto done;
 
         /* hour, min, seconds */
+        string_skip_spaces(sp, &p);
         for(i = 0; i < 3; i++) {
-            if (string_get_field(sp, &p, &fields[3 + i]))
+            if (i == 1 || i == 2) {
+                if (p >= sp->len)
+                    goto done;
+                if (string_get(sp, p) != ':')
+                    goto done;
+                p++;
+            }
+            if (string_get_digits(sp, &p, &fields[3 + i]))
                 goto done;
         }
         // XXX: parse optional milliseconds?
@@ -48333,9 +48561,9 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
             sgn = string_get(sp, p);
             if (sgn == '+' || sgn == '-') {
                 p++;
-                if (string_get_digits(sp, &p, 2, &hh))
+                if (string_get_fixed_width_digits(sp, &p, 2, &hh))
                     goto done;
-                if (string_get_digits(sp, &p, 2, &mm))
+                if (string_get_fixed_width_digits(sp, &p, 2, &mm))
                     goto done;
                 tz = hh * 60 + mm;
                 if (sgn == '-')
@@ -51886,10 +52114,16 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         inc = 1;
     }
 
-    if (validate_typed_array(ctx, this_val))
-        goto exception;
     p = JS_VALUE_GET_OBJ(this_val);
-
+    /* if the array was detached, no need to go further (but no
+       exception is raised) */
+    if (typed_array_is_detached(ctx, p)) {
+        /* "includes" scans all the properties, so "undefined" can match */
+        if (special == special_includes && JS_IsUndefined(argv[0]) && len > 0)
+            res = 0;
+        goto done;
+    }
+    
     is_bigint = 0;
     is_int = 0; /* avoid warning */
     v64 = 0; /* avoid warning */
@@ -51925,7 +52159,6 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         goto done;
     }
 
-    p = JS_VALUE_GET_OBJ(this_val);
     switch (p->class_id) {
     case JS_CLASS_INT8_ARRAY:
         if (is_int && (int8_t)v64 == v64)
@@ -52114,13 +52347,16 @@ static JSValue js_typed_array_join(JSContext *ctx, JSValueConst this_val,
             }
         }
         el = JS_GetPropertyUint32(ctx, this_val, i);
-        if (JS_IsException(el))
-            goto fail;
-        if (toLocaleString) {
-            el = JS_ToLocaleStringFree(ctx, el);
+        /* Can return undefined for example if the typed array is detached */
+        if (!JS_IsNull(el) && !JS_IsUndefined(el)) {
+            if (JS_IsException(el))
+                goto fail;
+            if (toLocaleString) {
+                el = JS_ToLocaleStringFree(ctx, el);
+            }
+            if (string_buffer_concat_value_free(b, el))
+                goto fail;
         }
-        if (string_buffer_concat_value_free(b, el))
-            goto fail;
     }
     JS_FreeValue(ctx, sep);
     return string_buffer_end(b);
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index bfe130708c..054019147e 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -1,8 +1,8 @@
 /*
  * QuickJS Javascript Engine
  *
- * Copyright (c) 2017-2020 Fabrice Bellard
- * Copyright (c) 2017-2020 Charlie Gordon
+ * Copyright (c) 2017-2021 Fabrice Bellard
+ * Copyright (c) 2017-2021 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -333,7 +333,11 @@ JSRuntime *JS_NewRuntime(void);
 void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);
 void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);
 void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);
+/* use 0 to disable maximum stack size check */
 void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size);
+/* should be called when changing thread to update the stack top value
+   used to check stack overflow. */
+void JS_UpdateStackTop(JSRuntime *rt);
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);
 void JS_FreeRuntime(JSRuntime *rt);
 void *JS_GetRuntimeOpaque(JSRuntime *rt);

From b143917a6c5a608ab2062527ac09ea5ba46cbb72 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Apr 2021 10:32:34 +0300
Subject: [PATCH 096/185] replace reinterpret with static cast where possible

---
 quickjspp.hpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f097ee374b..845ca5f092 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -723,7 +723,7 @@ struct js_traits<std::shared_ptr<T>>
                     name,
                     // destructor
                     [](JSRuntime * rt, JSValue obj) noexcept {
-                        auto pptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
+                        auto pptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
                         delete pptr;
                     },
                     nullptr,
@@ -767,7 +767,7 @@ struct js_traits<std::shared_ptr<T>>
     /// @throws exception if #v doesn't have the correct class id
     static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
     {
-        auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
+        auto ptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
         if(!ptr)
             throw exception{};
         return *ptr;
@@ -803,8 +803,7 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
 
     static T * unwrap(JSContext * ctx, JSValueConst v)
     {
-        auto ptr = reinterpret_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v,
-                                                                        js_traits<std::shared_ptr<T>>::QJSClassId));
+        auto ptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, js_traits<std::shared_ptr<T>>::QJSClassId));
         if(!ptr)
             throw exception{};
         return ptr->get();
@@ -827,7 +826,7 @@ struct function
     template <typename Functor>
     static function * create(JSRuntime * rt, Functor&& f)
     {
-        auto fptr = reinterpret_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
+        auto fptr = static_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
         if(!fptr)
             throw std::bad_alloc{};
         new(fptr) function;
@@ -837,7 +836,7 @@ struct function
         if constexpr(!std::is_trivially_destructible_v<Functor>)
         {
             fptr->destroyer = [](function * fptr) {
-                auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
+                auto functorptr = static_cast<Functor *>(fptr->functor);
                 functorptr->~Functor();
             };
         }
@@ -867,7 +866,7 @@ struct js_traits<detail::function>
                 name,
                 // destructor
                 [](JSRuntime * rt, JSValue obj) noexcept {
-                    auto fptr = reinterpret_cast<detail::function *>(JS_GetOpaque(obj, QJSClassId));
+                    auto fptr = static_cast<detail::function *>(JS_GetOpaque(obj, QJSClassId));
                     assert(fptr);
                     if(fptr->destroyer)
                         fptr->destroyer(fptr);
@@ -877,7 +876,7 @@ struct js_traits<detail::function>
                 // call
                 [](JSContext * ctx, JSValueConst func_obj, JSValueConst this_val, int argc,
                    JSValueConst * argv, int flags) -> JSValue {
-                    auto ptr = reinterpret_cast<detail::function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
+                    auto ptr = static_cast<detail::function *>(JS_GetOpaque2(ctx, func_obj, QJSClassId));
                     if(!ptr)
                         return JS_EXCEPTION;
                     return ptr->invoker(ptr, ctx, this_val, argc, argv);
@@ -1483,7 +1482,7 @@ class Context
     {
         void * ptr = JS_GetContextOpaque(ctx);
         assert(ptr);
-        return *reinterpret_cast<Context *>(ptr);
+        return *static_cast<Context *>(ptr);
     }
 };
 

From 635d6a702f92eb8bd01a3dcf3c153c43ae973661 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 13 Sep 2021 14:31:41 +0300
Subject: [PATCH 097/185] enable LTO

---
 CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 997baf6888..1a6ebf8870 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,8 @@
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.13)
 project(quickjspp)
 
 set(CMAKE_CXX_STANDARD 17)
-#set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
 
 if(CMAKE_COMPILER_IS_GNUCC)
     add_compile_options(-Wall -Wno-unused-parameter)

From 0dfb55f4648d16de06b32ffbe901de6339f6ce59 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 13 Apr 2021 10:41:28 +0300
Subject: [PATCH 098/185] constexpr fix

---
 quickjspp.hpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 845ca5f092..7b8b2491e2 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1329,11 +1329,7 @@ class Context
             template <auto FGet, auto FSet = nullptr>
             class_registrar& property(const char * name)
             {
-#if defined(__GNUC__) && __GNUC__ <= 8 // gcc-8 workaround
-                if(FSet == nullptr)
-#else
-                if constexpr (FSet == nullptr)
-#endif
+                if constexpr (std::is_same_v<decltype(FSet), std::nullptr_t>)
                     prototype.add_getter<FGet>(name);
                 else
                     prototype.add_getter_setter<FGet, FSet>(name);

From bfc4512b28e5cb243376e7af0bb4c320f3be409c Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 13 Sep 2021 14:01:12 +0300
Subject: [PATCH 099/185] remove bad exception test

---
 test/exception.cpp | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/test/exception.cpp b/test/exception.cpp
index fcab41a16c..20a8bce859 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -24,20 +24,6 @@ int main()
         assert(exc.isError() && (std::string) exc == "TypeError: cannot convert symbol to number");
     }
 
-    try
-    {
-        std::string big;
-        big.resize((1 << 30) + 1);
-        auto fun = context.eval("(function(a, b, c) { println(a); println(b); println(c); })").as<std::function<void(double, std::string, int)>>();
-        fun(0, std::move(big), 0);
-        assert(false);
-    }
-    catch(qjs::exception)
-    {
-        auto exc = context.getException();
-        std::cout << (std::string) exc << '\n' << (std::string_view) exc["stack"];
-    }
-
     try
     {
         //context.global().add("emptyf", [](JSValue v) {} );

From 43f9d9d5db23efc0a774052b06e27ffb261c67b2 Mon Sep 17 00:00:00 2001
From: dodola <dinophp@gmail.com>
Date: Thu, 28 Oct 2021 19:16:03 +0800
Subject: [PATCH 100/185] Set property is JS_NULL when c pointer is nullptr

---
 quickjspp.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 7b8b2491e2..0d1864af6c 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -782,6 +782,9 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
 {
     static JSValue wrap(JSContext * ctx, T * ptr)
     {
+        if (ptr == nullptr) {
+            return JS_NULL;
+        }   
         if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
         {
 #if defined(__cpp_rtti)
@@ -803,6 +806,9 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
 
     static T * unwrap(JSContext * ctx, JSValueConst v)
     {
+        if (JS_IsNull(v)) {
+            return nullptr;
+        }
         auto ptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, js_traits<std::shared_ptr<T>>::QJSClassId));
         if(!ptr)
             throw exception{};

From 4119bf46d452ad74bf3ea8a02b699b8c923a7745 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:21:04 +0000
Subject: [PATCH 101/185] Add missing header

---
 test/conversions.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/conversions.cpp b/test/conversions.cpp
index 3ad82cca8b..b5af948bd4 100644
--- a/test/conversions.cpp
+++ b/test/conversions.cpp
@@ -1,6 +1,7 @@
 #include "quickjspp.hpp"
 #include <iostream>
 #include <numeric>
+#include <limits>
 
 template <typename T>
 void test_conv(qjs::Context& context, T x)

From 7511bc620dca04eebc6de485601982d57c98f6ba Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:22:34 +0000
Subject: [PATCH 102/185] Add test for JS function call with fewer arguments
 that its C++ implementation

---
 test/CMakeLists.txt    |  2 +-
 test/function_call.cpp | 27 +++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)
 create mode 100644 test/function_call.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 63c2aa3840..b6b4960c79 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant
+        value class exception example multicontext conversions point variant function_call
         )
 make_test(${test})
 endforeach()
diff --git a/test/function_call.cpp b/test/function_call.cpp
new file mode 100644
index 0000000000..a38ade5cf5
--- /dev/null
+++ b/test/function_call.cpp
@@ -0,0 +1,27 @@
+#include "quickjspp.hpp"
+#include <cstdio>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    std::string msg;
+
+    context.global().add("f_with_3_args", [](int a, int b, int c) {
+        printf("%d %d %d\n", a, b, c);
+    });
+
+    try
+    {
+        context.eval("f_with_3_args(1);");
+    }
+    catch(qjs::exception)
+    {
+        msg = (std::string)context.getException();
+    }
+
+    assert(msg == "TypeError: Expected type 3 arguments but only 1 were provided");
+
+    return 0;
+}
\ No newline at end of file

From c13bb03441446f3c7982179dcfee01cf192c2332 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:25:12 +0000
Subject: [PATCH 103/185] Add runtime check to ensurer JS function call has at
 least as many arguments as its C++ implementation

---
 quickjspp.hpp | 58 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 0d1864af6c..ff0cd9912a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -492,19 +492,32 @@ T unwrap_free(JSContext * ctx, JSValue val)
     }
 }
 
+template <typename T, size_t I, size_t NArgs>
+struct unwrap_arg_impl {
+    static auto unwrap(JSContext * ctx, int argc, JSValueConst * argv)
+    {
+        if (size_t(argc) <= I) {
+            JS_ThrowTypeError(ctx, "Expected type %lu arguments but only %d were provided",
+                              NArgs, argc);
+            throw exception{};
+        }
+        return js_traits<std::decay_t<T>>::unwrap(ctx, argv[I]);
+    }
+};
+
 template <class Tuple, std::size_t... I>
-Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
+Tuple unwrap_args_impl(JSContext * ctx, int argc, JSValueConst * argv, std::index_sequence<I...>)
 {
-    return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
+    return Tuple{unwrap_arg_impl<std::tuple_element_t<I, Tuple>, I, sizeof...(I)>::unwrap(ctx, argc, argv)...};
 }
 
 /** Helper function to convert an array of JSValues to a tuple.
  * @tparam Args C++ types of the argv array
  */
 template <typename... Args>
-std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, JSValueConst * argv)
+std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, int argc, JSValueConst * argv)
 {
-    return unwrap_args_impl<std::tuple<std::decay_t<Args>...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
+    return unwrap_args_impl<std::tuple<std::decay_t<Args>...>>(ctx, argc, argv, std::make_index_sequence<sizeof...(Args)>());
 }
 
 /** Helper function to call f with an array of JSValues.
@@ -517,20 +530,20 @@ std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, JSValueConst * ar
  * @return converted return value of f or JS_NULL if f returns void
  */
 template <typename R, typename... Args, typename Callable>
-JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
+JSValue wrap_call(JSContext * ctx, Callable&& f, int argc, JSValueConst * argv) noexcept
 {
     try
     {
         if constexpr(std::is_same_v<R, void>)
         {
-            std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
+            std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argc, argv));
             return JS_NULL;
         }
         else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
-                                                               unwrap_args<Args...>(ctx, argv)));
+                                                               unwrap_args<Args...>(ctx, argc, argv)));
         }
     }
     catch(exception)
@@ -543,14 +556,14 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
  * @tparam FirstArg type of this_value
  */
 template <typename R, typename FirstArg, typename... Args, typename Callable>
-JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
+JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, int argc, JSValueConst * argv) noexcept
 {
     try
     {
         if constexpr(std::is_same_v<R, void>)
         {
-            std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
-                                                                 unwrap_args<Args...>(ctx, argv)));
+            std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, 1, &this_value),
+                                                                 unwrap_args<Args...>(ctx, argc, argv)));
             return JS_NULL;
         }
         else
@@ -558,8 +571,8 @@ JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, J
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
                                                                std::tuple_cat(
-                                                                       unwrap_args<FirstArg>(ctx, &this_value),
-                                                                       unwrap_args<Args...>(ctx, argv))));
+                                                                       unwrap_args<FirstArg>(ctx, 1, &this_value),
+                                                                       unwrap_args<Args...>(ctx, argc, argv))));
         }
     }
     catch(exception)
@@ -607,9 +620,9 @@ struct js_traits<fwrapper<F, PassThis>>
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
             if constexpr(PassThis)
-                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argv);
+                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
             else
-                return detail::wrap_call<R, Args...>(ctx, F, argv);
+                return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -623,7 +636,7 @@ struct js_traits<fwrapper<F, PassThis>>
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -637,7 +650,7 @@ struct js_traits<fwrapper<F, PassThis>>
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -683,9 +696,14 @@ struct js_traits<ctor_wrapper<T, Args...>>
             if(JS_IsException(jsobj))
                 return jsobj;
 
-            std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
-            JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
-            return jsobj;
+            try {
+                std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argc, argv));
+                JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
+                return jsobj;
+            } catch (exception) {
+                JS_FreeValue(ctx, jsobj);
+                return JS_EXCEPTION;
+            }
 
             // return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
         }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
@@ -1561,7 +1579,7 @@ struct js_traits<std::function<R(Args...)>>
         fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
             assert(self);
             auto f = reinterpret_cast<Functor *>(&self->functor);
-            return detail::wrap_call<R, Args...>(ctx, *f, argv);
+            return detail::wrap_call<R, Args...>(ctx, *f, argc, argv);
         };
         JS_SetOpaque(obj, fptr);
         return obj;

From 736b5528a5e78964a50abb2c37386fbb15501e7f Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:25:32 +0000
Subject: [PATCH 104/185] Add .gitignore

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000..978559761a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+build
+.cache

From db521c284c4865675ebe2e125f62ea4ae0b03346 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:21:04 +0000
Subject: [PATCH 105/185] Add missing header

---
 test/conversions.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/conversions.cpp b/test/conversions.cpp
index 3ad82cca8b..b5af948bd4 100644
--- a/test/conversions.cpp
+++ b/test/conversions.cpp
@@ -1,6 +1,7 @@
 #include "quickjspp.hpp"
 #include <iostream>
 #include <numeric>
+#include <limits>
 
 template <typename T>
 void test_conv(qjs::Context& context, T x)

From 023def3ce5c3ce65223542e05a7d4973a1e2ed3b Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:22:34 +0000
Subject: [PATCH 106/185] Add test for JS function call with fewer arguments
 that its C++ implementation

---
 test/CMakeLists.txt    |  2 +-
 test/function_call.cpp | 27 +++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)
 create mode 100644 test/function_call.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 63c2aa3840..b6b4960c79 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant
+        value class exception example multicontext conversions point variant function_call
         )
 make_test(${test})
 endforeach()
diff --git a/test/function_call.cpp b/test/function_call.cpp
new file mode 100644
index 0000000000..a38ade5cf5
--- /dev/null
+++ b/test/function_call.cpp
@@ -0,0 +1,27 @@
+#include "quickjspp.hpp"
+#include <cstdio>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    std::string msg;
+
+    context.global().add("f_with_3_args", [](int a, int b, int c) {
+        printf("%d %d %d\n", a, b, c);
+    });
+
+    try
+    {
+        context.eval("f_with_3_args(1);");
+    }
+    catch(qjs::exception)
+    {
+        msg = (std::string)context.getException();
+    }
+
+    assert(msg == "TypeError: Expected type 3 arguments but only 1 were provided");
+
+    return 0;
+}
\ No newline at end of file

From 1678a8fe2c53d0c0b899b6ebac1e41602ccf228b Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:25:12 +0000
Subject: [PATCH 107/185] Add runtime check to ensurer JS function call has at
 least as many arguments as its C++ implementation

---
 quickjspp.hpp | 58 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 0d1864af6c..ff0cd9912a 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -492,19 +492,32 @@ T unwrap_free(JSContext * ctx, JSValue val)
     }
 }
 
+template <typename T, size_t I, size_t NArgs>
+struct unwrap_arg_impl {
+    static auto unwrap(JSContext * ctx, int argc, JSValueConst * argv)
+    {
+        if (size_t(argc) <= I) {
+            JS_ThrowTypeError(ctx, "Expected type %lu arguments but only %d were provided",
+                              NArgs, argc);
+            throw exception{};
+        }
+        return js_traits<std::decay_t<T>>::unwrap(ctx, argv[I]);
+    }
+};
+
 template <class Tuple, std::size_t... I>
-Tuple unwrap_args_impl(JSContext * ctx, JSValueConst * argv, std::index_sequence<I...>)
+Tuple unwrap_args_impl(JSContext * ctx, int argc, JSValueConst * argv, std::index_sequence<I...>)
 {
-    return Tuple{js_traits<std::decay_t<std::tuple_element_t<I, Tuple>>>::unwrap(ctx, argv[I])...};
+    return Tuple{unwrap_arg_impl<std::tuple_element_t<I, Tuple>, I, sizeof...(I)>::unwrap(ctx, argc, argv)...};
 }
 
 /** Helper function to convert an array of JSValues to a tuple.
  * @tparam Args C++ types of the argv array
  */
 template <typename... Args>
-std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, JSValueConst * argv)
+std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, int argc, JSValueConst * argv)
 {
-    return unwrap_args_impl<std::tuple<std::decay_t<Args>...>>(ctx, argv, std::make_index_sequence<sizeof...(Args)>());
+    return unwrap_args_impl<std::tuple<std::decay_t<Args>...>>(ctx, argc, argv, std::make_index_sequence<sizeof...(Args)>());
 }
 
 /** Helper function to call f with an array of JSValues.
@@ -517,20 +530,20 @@ std::tuple<std::decay_t<Args>...> unwrap_args(JSContext * ctx, JSValueConst * ar
  * @return converted return value of f or JS_NULL if f returns void
  */
 template <typename R, typename... Args, typename Callable>
-JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
+JSValue wrap_call(JSContext * ctx, Callable&& f, int argc, JSValueConst * argv) noexcept
 {
     try
     {
         if constexpr(std::is_same_v<R, void>)
         {
-            std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argv));
+            std::apply(std::forward<Callable>(f), unwrap_args<Args...>(ctx, argc, argv));
             return JS_NULL;
         }
         else
         {
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
-                                                               unwrap_args<Args...>(ctx, argv)));
+                                                               unwrap_args<Args...>(ctx, argc, argv)));
         }
     }
     catch(exception)
@@ -543,14 +556,14 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, JSValueConst * argv) noexcept
  * @tparam FirstArg type of this_value
  */
 template <typename R, typename FirstArg, typename... Args, typename Callable>
-JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, JSValueConst * argv) noexcept
+JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, int argc, JSValueConst * argv) noexcept
 {
     try
     {
         if constexpr(std::is_same_v<R, void>)
         {
-            std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, &this_value),
-                                                                 unwrap_args<Args...>(ctx, argv)));
+            std::apply(std::forward<Callable>(f), std::tuple_cat(unwrap_args<FirstArg>(ctx, 1, &this_value),
+                                                                 unwrap_args<Args...>(ctx, argc, argv)));
             return JS_NULL;
         }
         else
@@ -558,8 +571,8 @@ JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, J
             return js_traits<std::decay_t<R>>::wrap(ctx,
                                                     std::apply(std::forward<Callable>(f),
                                                                std::tuple_cat(
-                                                                       unwrap_args<FirstArg>(ctx, &this_value),
-                                                                       unwrap_args<Args...>(ctx, argv))));
+                                                                       unwrap_args<FirstArg>(ctx, 1, &this_value),
+                                                                       unwrap_args<Args...>(ctx, argc, argv))));
         }
     }
     catch(exception)
@@ -607,9 +620,9 @@ struct js_traits<fwrapper<F, PassThis>>
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
             if constexpr(PassThis)
-                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argv);
+                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
             else
-                return detail::wrap_call<R, Args...>(ctx, F, argv);
+                return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -623,7 +636,7 @@ struct js_traits<fwrapper<F, PassThis>>
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -637,7 +650,7 @@ struct js_traits<fwrapper<F, PassThis>>
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argv);
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
         }, fw.name, sizeof...(Args));
 
     }
@@ -683,9 +696,14 @@ struct js_traits<ctor_wrapper<T, Args...>>
             if(JS_IsException(jsobj))
                 return jsobj;
 
-            std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argv));
-            JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
-            return jsobj;
+            try {
+                std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argc, argv));
+                JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
+                return jsobj;
+            } catch (exception) {
+                JS_FreeValue(ctx, jsobj);
+                return JS_EXCEPTION;
+            }
 
             // return detail::wrap_call<std::shared_ptr<T>, Args...>(ctx, std::make_shared<T, Args...>, argv);
         }, cw.name, sizeof...(Args), JS_CFUNC_constructor, 0);
@@ -1561,7 +1579,7 @@ struct js_traits<std::function<R(Args...)>>
         fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
             assert(self);
             auto f = reinterpret_cast<Functor *>(&self->functor);
-            return detail::wrap_call<R, Args...>(ctx, *f, argv);
+            return detail::wrap_call<R, Args...>(ctx, *f, argc, argv);
         };
         JS_SetOpaque(obj, fptr);
         return obj;

From 3d38559a3fa0926384e57fd7cfde760df1fbd7ff Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 16:25:32 +0000
Subject: [PATCH 108/185] Add .gitignore

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000..978559761a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+build
+.cache

From a032027fe10e17bb3698d1d35d5c3f63dd859d64 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 18 Nov 2021 22:42:59 +0300
Subject: [PATCH 109/185] fix class testcase

---
 test/class.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/class.cpp b/test/class.cpp
index d81adf3d86..c9c162487a 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -125,7 +125,8 @@ int main()
                                 "var b = new test.base_test();"
                                 "b.base_field = [[5],[1,2,3,4],[6]];"
                                 "assert(b.base_field[1][3] === 4);"
-                                "assert(b.base_method() === 5);"
+                                "assert(b.base_method(123) === 5);"
+                                "assert(b.base_field[0][0] === 123);"
 
                                 "var t = new test.TestSimple(12);"
                                 "var q = new test.Test(13, t.vb, t.vi, t.vd, t, t, t.vs, t.vs);"

From 76154e91b2919857b2498928a59ae99b0bb44a27 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 18 Nov 2021 22:44:36 +0300
Subject: [PATCH 110/185] suppress printf warning in mingw

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index ff0cd9912a..8475560641 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -498,7 +498,7 @@ struct unwrap_arg_impl {
     {
         if (size_t(argc) <= I) {
             JS_ThrowTypeError(ctx, "Expected type %lu arguments but only %d were provided",
-                              NArgs, argc);
+                              (unsigned long)NArgs, argc);
             throw exception{};
         }
         return js_traits<std::decay_t<T>>::unwrap(ctx, argv[I]);

From 2f24dd7fcaee957adf9c86414016634df7fb8dd8 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Fri, 19 Nov 2021 02:04:04 +0000
Subject: [PATCH 111/185] Add inheritance

---
 quickjspp.hpp        | 108 ++++++++++++++++++---
 test/CMakeLists.txt  |   2 +-
 test/inheritance.cpp | 224 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 322 insertions(+), 12 deletions(-)
 create mode 100644 test/inheritance.cpp

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 8475560641..7d61f9ddf0 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -15,6 +15,8 @@
 #include <stdexcept>
 #include <variant>
 #include <optional>
+#include <type_traits>
+#include <unordered_map>
 
 
 #if defined(__cpp_rtti)
@@ -597,6 +599,12 @@ void wrap_args(JSContext * ctx, JSValue * argv, Args&& ... args)
     wrap_args_impl(ctx, argv, std::make_tuple(std::forward<Args>(args)...),
                    std::make_index_sequence<sizeof...(Args)>());
 }
+
+// Helper trait to obtain `T` in `T::*` expressions
+template<typename T> struct class_from_member_pointer { using type = void; };
+template<typename T, typename U> struct class_from_member_pointer<T U::*> { using type = U; };
+template<typename T> using class_from_member_pointer_t = typename class_from_member_pointer<T>::type;
+
 } // namespace detail
 
 /** A wrapper type for free and class member functions.
@@ -721,6 +729,66 @@ struct js_traits<std::shared_ptr<T>>
     /// Registered class id in QuickJS.
     inline static JSClassID QJSClassId = 0;
 
+    /// Signature of the function to obtain the std::shared_ptr from the JSValue.
+    using ptr_cast_fcn_t = std::function<std::shared_ptr<T>(JSContext*, JSValueConst)>;
+
+    /// Used by registerDerivedClass to register new derived classes with this class' base type.
+    inline static std::function<void(JSClassID, ptr_cast_fcn_t)> registerWithBase;
+
+    /// Mapping between derived class' JSClassID and function to obtain the std::shared_ptr from the JSValue.
+    inline static std::unordered_map<JSClassID, ptr_cast_fcn_t> ptrCastFcnMap;
+
+    /** Register a class as a derived class.
+     * 
+     * @tparam D type of the derived class
+     * @param derived_class_id class id of the derived class
+     * @param ptr_cast_fcn function to obtain a std::shared_ptr from the JSValue
+     */
+    template<typename D>
+    static void registerDerivedClass(JSClassID derived_class_id, ptr_cast_fcn_t ptr_cast_fcn) {
+        static_assert(std::is_base_of<T,D>::value && !std::is_same<T,D>::value, "Type is not a derived class");
+        using derived_ptr_cast_fcn_t = typename js_traits<std::shared_ptr<D>>::ptr_cast_fcn_t;
+
+        // Register how to obtain the std::shared_ptr from the derived class.
+        ptrCastFcnMap[derived_class_id] = ptr_cast_fcn;
+
+        // Propagate the registration to our base class (if any).
+        if (registerWithBase) registerWithBase(derived_class_id, ptr_cast_fcn);
+
+        // Instrument the derived class so that it can propagate new derived classes to us.
+        auto old_registerWithBase = js_traits<std::shared_ptr<D>>::registerWithBase;
+        js_traits<std::shared_ptr<D>>::registerWithBase =
+            [old_registerWithBase = std::move(old_registerWithBase)]
+            (JSClassID derived_class_id, derived_ptr_cast_fcn_t derived_ptr_cast_fcn){
+                if (old_registerWithBase) old_registerWithBase(derived_class_id, derived_ptr_cast_fcn);
+                registerDerivedClass<D>(derived_class_id, [derived_cast_fcn = std::move(derived_ptr_cast_fcn)](JSContext * ctx, JSValueConst v) {
+                    return std::shared_ptr<T>(derived_cast_fcn(ctx, v));
+                });
+            };
+    }
+
+    template <typename B>
+    static
+    std::enable_if_t<std::is_same_v<B, T> || std::is_same_v<B, void>>
+    ensureCanCastToBase() { }
+
+    template <typename B>
+    static
+    std::enable_if_t<!std::is_same_v<B, T> && !std::is_same_v<B, void>>
+    ensureCanCastToBase() {
+        static_assert(std::is_base_of_v<B, T>, "Type is not a derived class");
+
+        if(js_traits<std::shared_ptr<T>>::QJSClassId == 0)
+            JS_NewClassID(&js_traits<std::shared_ptr<T>>::QJSClassId);
+
+        js_traits<std::shared_ptr<B>>::template registerDerivedClass<T>(QJSClassId, unwrap);
+    }
+
+    template <auto M>
+    static void ensureCanCastToBase() {
+        ensureCanCastToBase<detail::class_from_member_pointer_t<decltype(M)>>();
+    }
+
     /** Register class in QuickJS context.
      *
      * @param ctx context
@@ -783,12 +851,26 @@ struct js_traits<std::shared_ptr<T>>
     }
 
     /// @throws exception if #v doesn't have the correct class id
-    static const std::shared_ptr<T>& unwrap(JSContext * ctx, JSValueConst v)
-    {
-        auto ptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, QJSClassId));
+    static const std::shared_ptr<T> unwrap(JSContext * ctx, JSValueConst v)
+    {
+        std::shared_ptr<T> ptr = nullptr;
+        auto obj_class_id = JS_GetClassID(v);
+
+        if (obj_class_id == QJSClassId) {
+            // The JS object is of class T
+            ptr = *static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, obj_class_id));
+        } else if (ptrCastFcnMap.count(obj_class_id)) {
+            // The JS object is of a class derived from T
+            ptr = ptrCastFcnMap[obj_class_id](ctx, v);
+        } else {
+            // The JS object does not derives from T
+            JS_ThrowTypeError(ctx, "Expected type %s, got object with classid %d",
+                              QJSPP_TYPENAME(T), obj_class_id);
+            throw exception{};
+        }
         if(!ptr)
             throw exception{};
-        return *ptr;
+        return ptr;
     }
 };
 
@@ -827,9 +909,7 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
         if (JS_IsNull(v)) {
             return nullptr;
         }
-        auto ptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, js_traits<std::shared_ptr<T>>::QJSClassId));
-        if(!ptr)
-            throw exception{};
+        auto ptr = js_traits<std::shared_ptr<T>>::unwrap(ctx, v);
         return ptr->get();
     }
 };
@@ -1000,12 +1080,12 @@ struct get_set<M>
 {
     using is_const = std::is_const<R>;
 
-    static const R& get(const std::shared_ptr<T>& ptr)
+    static const R& get(std::shared_ptr<T> ptr)
     {
         return *ptr.*M;
     }
 
-    static R& set(const std::shared_ptr<T>& ptr, R value)
+    static R& set(std::shared_ptr<T> ptr, R value)
     {
         return *ptr.*M = std::move(value);
     }
@@ -1346,6 +1426,7 @@ class Context
             template <auto F>
             class_registrar& fun(const char * name)
             {
+                js_traits<std::shared_ptr<T>>::template ensureCanCastToBase<F>();
                 prototype.add<F>(name);
                 return *this;
             }
@@ -1353,6 +1434,8 @@ class Context
             template <auto FGet, auto FSet = nullptr>
             class_registrar& property(const char * name)
             {
+                js_traits<std::shared_ptr<T>>::template ensureCanCastToBase<FGet>();
+                js_traits<std::shared_ptr<T>>::template ensureCanCastToBase<FSet>();
                 if constexpr (std::is_same_v<decltype(FSet), std::nullptr_t>)
                     prototype.add_getter<FGet>(name);
                 else
@@ -1375,11 +1458,15 @@ class Context
                 return *this;
             }
 
-            /* TODO: needs casting to base class
+            /** Sets the base class
+             * @tparam B base class
+             */
             template <class B>
             class_registrar& base()
             {
+                static_assert(!std::is_same_v<B, T>, "Type cannot be a base of itself");
                 assert(js_traits<std::shared_ptr<B>>::QJSClassId && "base class is not registered");
+                js_traits<std::shared_ptr<T>>::template ensureCanCastToBase<B>();
                 auto base_proto = JS_GetClassProto(context.ctx, js_traits<std::shared_ptr<B>>::QJSClassId);
                 int err = JS_SetPrototype(context.ctx, prototype.v, base_proto);
                 JS_FreeValue(context.ctx, base_proto);
@@ -1387,7 +1474,6 @@ class Context
                     throw exception{};
                 return *this;
             }
-             */
 
             ~class_registrar()
             {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b6b4960c79..2a57bcf026 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant function_call
+        value class exception example multicontext conversions point variant function_call inheritance
         )
 make_test(${test})
 endforeach()
diff --git a/test/inheritance.cpp b/test/inheritance.cpp
new file mode 100644
index 0000000000..d7a9166819
--- /dev/null
+++ b/test/inheritance.cpp
@@ -0,0 +1,224 @@
+#include "quickjspp.hpp"
+#include <iostream>
+
+struct A {
+    int a;
+    A(int a) : a(a) {}
+    virtual ~A() = default;
+    virtual int vfunc_a1() {
+        return a;
+    }
+    virtual int vfunc_a2() {
+        return a + 1;
+    }
+    int non_vfunc_a1() {
+        return a + 2;
+    }
+    int non_vfunc_a2() {
+        return a + 3;
+    }
+};
+
+struct B {
+    int b;
+    B(int b) : b(b) {}
+    virtual ~B() = default;
+    virtual int vfunc_b1() {
+        return b;
+    }
+    virtual int vfunc_b2() {
+        return b + 1;
+    }
+    int non_vfunc_b1() {
+        return b + 2;
+    }
+    int non_vfunc_b2() {
+        return b + 3;
+    }
+};
+
+struct H {
+    int h;
+    H(int h) : h(h) {}
+    virtual ~H() = default;
+    virtual int vfunc_h1() {
+        return h;
+    }
+    virtual int vfunc_h2() {
+        return h + 1;
+    }
+    int non_vfunc_h1() {
+        return h + 2;
+    }
+    int non_vfunc_h2() {
+        return h + 3;
+    }
+};
+
+struct C : public A, public B, public H {
+    int c;
+    C(int a, int b, int c, int h) : A(a), B(b), H(h), c(c) {}
+    int vfunc_a1() override {
+        return 42;
+    }
+    int vfunc_b2() override {
+        return 84;
+    }
+    int non_vfunc_a1() {
+        return -42;
+    }
+    int non_vfunc_b2() {
+        return -84;
+    }
+    int non_vfunc_h1() {
+        return -126;
+    }
+};
+
+
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    auto& test = context.addModule("test");
+    test.class_<A>("A")
+        .constructor<int>()
+        .fun<&A::a>("a")
+        .fun<&A::vfunc_a1>("vfunc_a1")
+        .fun<&A::vfunc_a2>("vfunc_a2")
+        .fun<&A::non_vfunc_a1>("non_vfunc_a1")
+        .fun<&A::non_vfunc_a2>("non_vfunc_a2");
+
+    test.class_<B>("B")
+        .constructor<int>()
+        .fun<&B::b>("b")
+        .fun<&B::vfunc_b1>("vfunc_b1")
+        .fun<&B::vfunc_b2>("vfunc_b2")
+        .fun<&B::non_vfunc_b1>("non_vfunc_b1")
+        .fun<&B::non_vfunc_b2>("non_vfunc_b2");
+
+    test.class_<C>("C")
+        .constructor<int, int, int, int>()
+        .base<A>()
+        .fun<&C::c>("c")
+        .fun<&C::b>("b")
+        .fun<&C::h>("h")
+        .fun<&C::vfunc_b1>("vfunc_b1")
+        .fun<&C::vfunc_b2>("vfunc_b2")
+        .fun<&C::vfunc_h1>("vfunc_h1")
+        .fun<&C::vfunc_h2>("vfunc_h2")
+        .fun<&C::non_vfunc_a1>("non_vfunc_a1")
+        .fun<&C::non_vfunc_b1>("non_vfunc_b1")
+        .fun<&C::non_vfunc_b2>("non_vfunc_b2")
+        .fun<&C::non_vfunc_h1>("non_vfunc_h1")
+        .fun<&C::non_vfunc_h2>("non_vfunc_h2");
+
+    try {
+        context.eval(R"xxx(
+            import { A, B, C } from "test";
+
+            function assert(b, str = "FAIL") {
+                if (b) {
+                    return;
+                } else {
+                    throw Error("assertion failed: " + str);
+                }
+            }
+
+            function assert_eq(a, b, str = "") {
+                assert(a === b, `${JSON.stringify(a)} should be equal to ${JSON.stringify(b)}. ${str}`);
+            }
+
+            function assert_throw(g, str = "") {
+                try {
+                    f();
+                    assert(false, `Expression should have thrown`)
+                } catch (e) {
+                }
+            }
+
+            // A
+            const a = new A(123);
+            
+            assert_eq(a.a, 123, "a.a == 123");
+            assert_eq(a.vfunc_a1(), 123, "a.vfunc_a1() == 123");
+            assert_eq(a.vfunc_a2(), 124, "a.vfunc_a2() == 124");
+            assert_eq(a.non_vfunc_a1(), 125, "a.non_vfunc_a1() == 125");
+            assert_eq(a.non_vfunc_a2(), 126, "a.non_vfunc_a2() == 126");
+
+            // B
+            const b = new B(123);
+            
+            assert_eq(b.b, 123, "b.b == 123");
+            assert_eq(b.vfunc_b1(), 123, "b.vfunc_b1() == 123");
+            assert_eq(b.vfunc_b2(), 124, "b.vfunc_b2() == 124");
+            assert_eq(b.non_vfunc_b1(), 125, "b.non_vfunc_b1() == 125");
+            assert_eq(b.non_vfunc_b2(), 126, "b.non_vfunc_b2() == 126");
+
+            // These should throw because A can't be casted to B
+            assert_throw(() => b.vfunc_b1.call(a), "b.vfunc_b1.call(a)");
+            assert_throw(() => b.vfunc_b2.call(a), "b.vfunc_b2.call(a)");
+            assert_throw(() => b.non_vfunc_b1.call(a), "b.non_vfunc_b1.call(a)");
+            assert_throw(() => b.non_vfunc_b2.call(a), "b.non_vfunc_b2.call(a)");
+
+            // C
+            const c = new C(10, 20, 30, 40);
+
+            assert_eq(c.c, 30, "c.c == 30");
+
+            assert_eq(c instanceof A, true, "(c instanceof A) == true");
+            assert_eq(c instanceof B, false, "(c instanceof B) == false");
+            
+            // Properties and methods inherited from A should work on C
+            // These are the basic test
+            assert_eq(c.a, 10, "c.a == 10");
+            assert_eq(c.vfunc_a1(), 42, "c.vfunc_a1() == 42");
+            assert_eq(c.vfunc_a2(), 11, "c.vfunc_a2() == 11");
+            assert_eq(c.non_vfunc_a1(), -42, "c.non_vfunc_a1() == -42");
+            assert_eq(c.non_vfunc_a2(), 13, "c.non_vfunc_a2() == 13");
+
+            // Check the behaviour of using A's methods on a C object
+            // These test the behavior of virtual and non virtual functions
+            assert_eq(a.vfunc_a1.call(c), 42, "a.vfunc_a1.call(c) == 42");
+            assert_eq(a.vfunc_a2.call(c), 11, "a.vfunc_a2.call(c) == 11");
+            assert_eq(a.non_vfunc_a1.call(c), 12, "a.non_vfunc_a1.call(c) == 12");
+            assert_eq(a.non_vfunc_a2.call(c), 13, "a.non_vfunc_a2.call(c) == 13");
+
+            // Properties and methods inherited from B should work on C
+            // The interest of these test cases is that B is not the first inherited class
+            assert_eq(c.b, 20, "c.b == 20");
+            assert_eq(c.vfunc_b1(), 20, "c.vfunc_b1() == 20");
+            assert_eq(c.vfunc_b2(), 84, "c.vfunc_b2() == 84");
+            assert_eq(c.non_vfunc_b1(), 22, "c.non_vfunc_b1() == 22");
+            assert_eq(c.non_vfunc_b2(), -84, "c.non_vfunc_b2() == -84");
+
+            // Check the behaviour of using B's methods on a C object
+            // These test the behavior of virtual and non virtual functions
+            assert_eq(b.vfunc_b1.call(c), 20, "b.vfunc_b1.call(c) == 20");
+            assert_eq(b.vfunc_b2.call(c), 84, "b.vfunc_b2.call(c) == 84");
+            assert_eq(b.non_vfunc_b1.call(c), 22, "b.non_vfunc_b1.call(c) == 22");
+            assert_eq(b.non_vfunc_b2.call(c), 23, "b.non_vfunc_b2.call(c) == 23");
+
+            // Properties and methods inherited from H should work on C
+            // The interest of these test cases is that H is never registered with JS
+            assert_eq(c.h, 40, "c.h == 40");
+            assert_eq(c.vfunc_h1(), 40, "c.vfunc_h1() == 40");
+            assert_eq(c.vfunc_h2(), 41, "c.vfunc_h2() == 41");
+            assert_eq(c.non_vfunc_h1(), -126, "c.non_vfunc_h1() == -126");
+            assert_eq(c.non_vfunc_h2(), 43, "c.non_vfunc_h2() == 43");
+
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+
+    return 0;
+}
\ No newline at end of file

From ae1d2f12a97c159ef8a8c8a91ca9ccb76374acfa Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Fri, 19 Nov 2021 14:11:19 +0000
Subject: [PATCH 112/185] Add ftk suggestion

Verify that the opaque is not null before derreferencing.

Co-authored-by: ftk <ftk@users.noreply.github.com>
---
 quickjspp.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index dcee52c83d..12fd7554c6 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -858,7 +858,9 @@ struct js_traits<std::shared_ptr<T>>
 
         if (obj_class_id == QJSClassId) {
             // The JS object is of class T
-            ptr = *static_cast<std::shared_ptr<T> *>(JS_GetOpaque2(ctx, v, obj_class_id));
+            void * opaque = JS_GetOpaque2(ctx, v, obj_class_id);
+            assert(opaque && "No opaque pointer in object");
+            ptr = *static_cast<std::shared_ptr<T> *>(opaque);
         } else if (ptrCastFcnMap.count(obj_class_id)) {
             // The JS object is of a class derived from T
             ptr = ptrCastFcnMap[obj_class_id](ctx, v);

From 88498b437d090ddc6ac45e862e4a96636886932d Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Fri, 19 Nov 2021 14:48:55 +0000
Subject: [PATCH 113/185] Fix warning when calling JS_ThrowTypeError

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 12fd7554c6..ddcf4690ca 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -500,7 +500,7 @@ struct unwrap_arg_impl {
     {
         if (size_t(argc) <= I) {
             JS_ThrowTypeError(ctx, "Expected type %lu arguments but only %d were provided",
-                              NArgs, argc);
+                              (unsigned long)NArgs, argc);
             throw exception{};
         }
         return js_traits<std::decay_t<T>>::unwrap(ctx, argv[I]);

From d288ad1ffc6b27558511ce85967df0976c382c21 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 18 Nov 2021 17:01:17 +0000
Subject: [PATCH 114/185] Add support for rest arguments in C++

---
 quickjspp.hpp          | 19 ++++++++++++++
 test/function_call.cpp | 57 +++++++++++++++++++++++++++++++-----------
 2 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index ddcf4690ca..44b4ad983f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -467,6 +467,13 @@ struct js_traits<std::variant<Ts...>>
     }
 };
 
+template <typename T>
+struct rest : std::vector<T>
+{
+    using std::vector<T>::vector;
+    using std::vector<T>::operator=;
+};
+
 namespace detail {
 
 /** Helper function to convert and then free JSValue. */
@@ -507,6 +514,18 @@ struct unwrap_arg_impl {
     }
 };
 
+template <typename T, size_t I, size_t NArgs>
+struct unwrap_arg_impl<rest<T>, I, NArgs> {
+    static rest<T> unwrap(JSContext * ctx, int argc, JSValueConst * argv) {
+        static_assert(I == NArgs - 1, "The `rest` argument must be the last function argument.");
+        rest<T> result;
+        result.reserve(argc - I);
+        for (size_t i = I; i < size_t(argc); ++i)
+            result.push_back(js_traits<T>::unwrap(ctx, argv[i]));
+        return result;
+    }
+};
+
 template <class Tuple, std::size_t... I>
 Tuple unwrap_args_impl(JSContext * ctx, int argc, JSValueConst * argv, std::index_sequence<I...>)
 {
diff --git a/test/function_call.cpp b/test/function_call.cpp
index a38ade5cf5..9cd6040ab9 100644
--- a/test/function_call.cpp
+++ b/test/function_call.cpp
@@ -1,27 +1,56 @@
+#include "quickjs/quickjs.h"
 #include "quickjspp.hpp"
 #include <cstdio>
+#include <string_view>
 
-int main()
-{
-    qjs::Runtime runtime;
-    qjs::Context context(runtime);
+void qjs_assert(bool cond) {
+    if (!cond) {
+        printf("FAIL\n");
+        throw qjs::exception{};
+    }
+}
 
+void test_not_enough_arguments(qjs::Context & ctx) {
     std::string msg;
 
-    context.global().add("f_with_3_args", [](int a, int b, int c) {
+    ctx.global().add("test_fcn", [](int a, int b, int c) {
         printf("%d %d %d\n", a, b, c);
     });
 
-    try
-    {
-        context.eval("f_with_3_args(1);");
-    }
-    catch(qjs::exception)
-    {
-        msg = (std::string)context.getException();
-    }
+    ctx.eval(
+        "try {"
+        "  test_fcn(1);"
+        "  assert(false);"
+        "} catch (err) {"
+        "  assert("
+        "    (err instanceof TypeError) && "
+        "    err.message === 'Expected type 3 arguments but only 1 were provided'"
+        "  );"
+        "}"
+    );
+}
+
+void test_call_with_rest_arguments(qjs::Context & ctx) {
+    ctx.global().add("test_fcn", [](int a, qjs::rest<int> args) {
+        qjs_assert(a == 1);
+        qjs_assert(args.size() == 3);
+        qjs_assert(args[0] == 2);
+        qjs_assert(args[1] == 3);
+        qjs_assert(args[2] == 4);
+    });
+
+    ctx.eval("test_fcn(1,2,3,4);");
+}
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    context.global().add("assert", &qjs_assert);
 
-    assert(msg == "TypeError: Expected type 3 arguments but only 1 were provided");
+    test_not_enough_arguments(context);
+    test_call_with_rest_arguments(context);
 
     return 0;
 }
\ No newline at end of file

From ab9e531eedb9273ae1dbf51663cde57495f677eb Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Fri, 19 Nov 2021 17:11:25 +0000
Subject: [PATCH 115/185] Add test for rest parameters and refactor
 function_call tests

---
 test/function_call.cpp | 128 ++++++++++++++++++++++++++++++-----------
 1 file changed, 94 insertions(+), 34 deletions(-)

diff --git a/test/function_call.cpp b/test/function_call.cpp
index 9cd6040ab9..8611509be3 100644
--- a/test/function_call.cpp
+++ b/test/function_call.cpp
@@ -1,45 +1,106 @@
 #include "quickjs/quickjs.h"
 #include "quickjspp.hpp"
-#include <cstdio>
+#include <iostream>
 #include <string_view>
 
-void qjs_assert(bool cond) {
-    if (!cond) {
-        printf("FAIL\n");
-        throw qjs::exception{};
-    }
-}
-
-void test_not_enough_arguments(qjs::Context & ctx) {
+int test_not_enough_arguments(qjs::Context & ctx) {
     std::string msg;
 
     ctx.global().add("test_fcn", [](int a, int b, int c) {
-        printf("%d %d %d\n", a, b, c);
+        return a + b + c;
     });
 
-    ctx.eval(
-        "try {"
-        "  test_fcn(1);"
-        "  assert(false);"
-        "} catch (err) {"
-        "  assert("
-        "    (err instanceof TypeError) && "
-        "    err.message === 'Expected type 3 arguments but only 1 were provided'"
-        "  );"
-        "}"
-    );
+    try
+    {
+        ctx.eval(R"xxx(
+            function assert(b, str = "FAIL") {
+                if (b) {
+                    return;
+                } else {
+                    throw Error("assertion failed: " + str);
+                }
+            }
+
+            function assert_eq(a, b, str = "") {
+                assert(a === b, `${JSON.stringify(a)} should be equal to ${JSON.stringify(b)}. ${str}`);
+            }
+
+            try {
+                test_fcn(1);
+                assert(false);
+            } catch (err) {
+                assert(err instanceof TypeError); 
+                assert_eq(err.message, 'Expected type 3 arguments but only 1 were provided');
+            }
+        )xxx");
+    }
+    catch(qjs::exception)
+    {
+        auto exc = ctx.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+
+    return 0;
 }
 
-void test_call_with_rest_arguments(qjs::Context & ctx) {
-    ctx.global().add("test_fcn", [](int a, qjs::rest<int> args) {
-        qjs_assert(a == 1);
-        qjs_assert(args.size() == 3);
-        qjs_assert(args[0] == 2);
-        qjs_assert(args[1] == 3);
-        qjs_assert(args[2] == 4);
+int test_call_with_rest_parameters(qjs::Context & ctx) {
+    ctx.global().add("test_fcn_rest", [](int a, qjs::rest<int> args) {
+        for (auto arg : args) {
+            a += arg;
+        }
+        return a;
+    });
+
+    ctx.global().add("test_fcn_vec", [](int a, std::vector<int> args) {
+        for (auto arg : args) {
+            a += arg;
+        }
+        return a;
     });
 
-    ctx.eval("test_fcn(1,2,3,4);");
+    try
+    {
+        ctx.eval(R"xxx(
+            function assert(b, str = "FAIL") {
+                if (b) {
+                    return;
+                } else {
+                    throw Error("assertion failed: " + str);
+                }
+            }
+
+            function assert_eq(a, b, str = "") {
+                assert(a === b, `${JSON.stringify(a)} should be equal to ${JSON.stringify(b)}. ${str}`);
+            }
+
+            function assert_throw(g, str = "") {
+                try {
+                    f();
+                    assert(false, `Expression should have thrown`)
+                } catch (e) {
+                }
+            }
+
+            assert_eq(test_fcn_rest(1, 2, 3, 4), 10);
+            assert_eq(test_fcn_vec(1, [2, 3, 4]), 10);
+            
+            assert_throw(() => test_fcn_rest(1, [2, 3, 4]));
+            assert_throw(() => test_fcn_vec(1, 2, 3, 4));
+        )xxx");
+    }
+    catch(qjs::exception)
+    {
+        auto exc = ctx.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if((bool) exc["stack"])
+            std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+
+    return 0;
 }
 
 int main()
@@ -47,10 +108,9 @@ int main()
     qjs::Runtime runtime;
     qjs::Context context(runtime);
 
-    context.global().add("assert", &qjs_assert);
+    int ret = 0;
+    ret |= test_not_enough_arguments(context);
+    ret |= test_call_with_rest_parameters(context);
 
-    test_not_enough_arguments(context);
-    test_call_with_rest_arguments(context);
-
-    return 0;
+    return ret;
 }
\ No newline at end of file

From d45be7d4cb537fe009624266d96b18b382718414 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Fri, 19 Nov 2021 17:36:02 +0000
Subject: [PATCH 116/185] Add mention to `qjs::rest` in readme

---
 readme.md | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/readme.md b/readme.md
index 1876a1e00f..e4bbd0746d 100644
--- a/readme.md
+++ b/readme.md
@@ -17,7 +17,10 @@ public:
     std::string member_function(const std::string& s) { return "Hello, " + s; }
 };
 
-void println(const std::string& str) { std::cout << str << std::endl; }
+void println(qjs::rest<std::string> args) {
+    for (auto const & arg : args) std::cout << arg << " ";
+    std::cout << "\n";
+}
 
 int main()
 {
@@ -34,15 +37,19 @@ int main()
                 .fun<&MyClass::member_variable>("member_variable")
                 .fun<&MyClass::member_function>("member_function");
         // import module
-        context.eval("import * as my from 'MyModule'; globalThis.my = my;", "<import>", JS_EVAL_TYPE_MODULE);
+        context.eval(R"xxx(
+            import * as my from 'MyModule';
+            globalThis.my = my;
+        )xxx", "<import>", JS_EVAL_TYPE_MODULE);
         // evaluate js code
-        context.eval("let v1 = new my.MyClass();" "\n"
-                     "v1.member_variable = 1;" "\n"
-                     "let v2 = new my.MyClassA([1,2,3]);" "\n"
-                     "function my_callback(str) {" "\n"
-                     "  my.println(v2.member_function(str));" "\n"
-                     "}" "\n"
-        );
+        context.eval(R"xxx(
+            let v1 = new my.MyClass();
+            v1.member_variable = 1;
+            let v2 = new my.MyClassA([1,2,3]);
+            function my_callback(str) {
+              my.println("at callback:", v2.member_function(str));
+            }
+        )xxx");
 
         // callback
         auto cb = (std::function<void(const std::string&)>) context.eval("my_callback");

From ef2f43b47f970206c6ec7595810ca95877b9db3e Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 19 Nov 2021 21:06:07 +0300
Subject: [PATCH 117/185] update example (by @jprendes)

---
 test/example.cpp | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/test/example.cpp b/test/example.cpp
index 73eff19f59..1c8ba816b0 100644
--- a/test/example.cpp
+++ b/test/example.cpp
@@ -11,7 +11,10 @@ class MyClass
     std::string member_function(const std::string& s) { return "Hello, " + s; }
 };
 
-void println(const std::string& str) { std::cout << str << std::endl; }
+void println(qjs::rest<std::string> args) {
+    for (auto const & arg : args) std::cout << arg << " ";
+    std::cout << "\n";
+}
 
 int main()
 {
@@ -28,15 +31,19 @@ int main()
                 .fun<&MyClass::member_variable>("member_variable")
                 .fun<&MyClass::member_function>("member_function");
         // import module
-        context.eval("import * as my from 'MyModule'; globalThis.my = my;", "<import>", JS_EVAL_TYPE_MODULE);
+        context.eval(R"xxx(
+            import * as my from 'MyModule';
+            globalThis.my = my;
+        )xxx", "<import>", JS_EVAL_TYPE_MODULE);
         // evaluate js code
-        context.eval("let v1 = new my.MyClass();" "\n"
-                     "v1.member_variable = 1;" "\n"
-                     "let v2 = new my.MyClassA([1,2,3]);" "\n"
-                     "function my_callback(str) {" "\n"
-                     "  my.println(v2.member_function(str));" "\n"
-                     "}" "\n"
-        );
+        context.eval(R"xxx(
+            let v1 = new my.MyClass();
+            v1.member_variable = 1;
+            let v2 = new my.MyClassA([1,2,3]);
+            function my_callback(str) {
+              my.println("at callback:", v2.member_function(str));
+            }
+        )xxx");
 
         // callback
         auto cb = (std::function<void(const std::string&)>) context.eval("my_callback");
@@ -50,4 +57,4 @@ int main()
             std::cerr << (std::string) exc["stack"] << std::endl;
         return 1;
     }
-}
\ No newline at end of file
+}

From 6014b8cc61e5718cfa60361af157e817634bc1c3 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 19 Nov 2021 21:27:55 +0300
Subject: [PATCH 118/185] update CI

---
 .github/workflows/cxx.yml        | 37 +++++++++++++++++++++-----------
 .github/workflows/doxygen.yml    |  2 ++
 .github/workflows/quickjsdll.yml |  2 ++
 .github/workflows/valgrind.yml   | 22 +++++++++++++++++++
 4 files changed, 51 insertions(+), 12 deletions(-)
 create mode 100644 .github/workflows/valgrind.yml

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index 7179f775ec..65d061f852 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -8,7 +8,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        compiler: [linux-gcc, linux-clang, linux-gcc9, linux-clang9, windows-gcc, linux-gcc-ubsan, linux-gcc-asan, linux-gcc-32, linux-gcc-x32]
+        compiler: [linux-gcc,linux-clang,linux-gcc8,linux-gcc10,linux-gcc-ubsan,linux-gcc-asan,linux-gcc-32,linux-gcc-x32,linux-clang11,linux-clang12,windows-gcc,macos-clang]
         build_type: [Debug]
         include:
           - compiler: linux-gcc
@@ -18,10 +18,15 @@ jobs:
             os: ubuntu-latest
             cmake_opts: -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
 
-          - compiler: linux-gcc9
+          - compiler: linux-gcc8
             os: ubuntu-18.04
-            preconfigure: sudo apt-get update && sudo apt-get install -y gcc-9 g++-9
-            cmake_opts: -DCMAKE_C_COMPILER=gcc-9 -DCMAKE_CXX_COMPILER=g++-9
+            preconfigure: sudo apt-get update && sudo apt-get install -y gcc-8 g++-8
+            cmake_opts: -DCMAKE_C_COMPILER=gcc-8 -DCMAKE_CXX_COMPILER=g++-8
+
+          - compiler: linux-gcc10
+            os: ubuntu-20.04
+            preconfigure: sudo apt-get update && sudo apt-get install -y gcc-10 g++-10
+            cmake_opts: -DCMAKE_C_COMPILER=gcc-10 -DCMAKE_CXX_COMPILER=g++-10
 
           - compiler: linux-gcc-ubsan
             os: ubuntu-latest
@@ -35,17 +40,23 @@ jobs:
             os: ubuntu-latest
             preconfigure: sudo apt-get update && sudo apt-get install gcc-multilib g++-multilib
             cflags: -m32
-            
+
           - compiler: linux-gcc-x32
             os: ubuntu-latest
             preconfigure: sudo apt-get update && sudo apt-get install gcc-multilib g++-multilib
             cflags: -mx32
 
-          - compiler: linux-clang9
-            os: ubuntu-18.04
-            preconfigure: sudo apt-get update && sudo apt-get install -y clang-9 libc++-9-dev libc++abi-9-dev
-            cmake_opts: -DCMAKE_C_COMPILER=clang-9 -DCMAKE_CXX_COMPILER=clang++-9
-            #cflags: -stdlib=libc++
+          - compiler: linux-clang11
+            os: ubuntu-20.04
+            preconfigure: sudo apt-get update && sudo apt-get install -y clang-11 libc++-11-dev libc++abi-11-dev
+            cmake_opts: -DCMAKE_C_COMPILER=clang-11 -DCMAKE_CXX_COMPILER=clang++-11
+            cflags: -stdlib=libc++
+
+          - compiler: linux-clang12
+            os: ubuntu-20.04
+            preconfigure: sudo apt-get update && sudo apt-get install -y clang-12 libc++-12-dev libc++abi-12-dev
+            cmake_opts: -DCMAKE_C_COMPILER=clang-12 -DCMAKE_CXX_COMPILER=clang++-12
+            cflags: -stdlib=libc++
 
 #          - compiler: windows-msvs # not supported
 #            os: windows-latest
@@ -54,11 +65,13 @@ jobs:
             os: windows-2019
             cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
 
-#          - compiler: macos-clang # libc++ is broken
-#            os: macos-latest
+          - compiler: macos-clang
+            os: macos-latest
 
     steps:
     - uses: actions/checkout@v2
+      with:
+        submodules: recursive
     - name: preconfigure
       run: ${{ matrix.preconfigure }}
     - name: configure
diff --git a/.github/workflows/doxygen.yml b/.github/workflows/doxygen.yml
index e89f8dc13c..aaffb4917c 100644
--- a/.github/workflows/doxygen.yml
+++ b/.github/workflows/doxygen.yml
@@ -9,6 +9,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+      with:
+        submodules: recursive
     - name: Doxygen install
       run: sudo apt-get install -y doxygen graphviz 
     - name: Doxygen
diff --git a/.github/workflows/quickjsdll.yml b/.github/workflows/quickjsdll.yml
index cf4fc6fc66..45f843cd71 100644
--- a/.github/workflows/quickjsdll.yml
+++ b/.github/workflows/quickjsdll.yml
@@ -15,6 +15,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
+      with:
+        submodules: recursive
     - name: install mingw
       run: sudo apt-get update ; sudo apt-get install -y mingw-w64
     - name: build dlls
diff --git a/.github/workflows/valgrind.yml b/.github/workflows/valgrind.yml
new file mode 100644
index 0000000000..e73f43a4e3
--- /dev/null
+++ b/.github/workflows/valgrind.yml
@@ -0,0 +1,22 @@
+name: Valgrind
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: install
+        run: sudo apt-get update; sudo apt-get install -y valgrind
+      - name: configure
+        run: echo 'include(Dart)' >> CMakeLists.txt && cmake -S . -B build_dir -Wdev -DCMAKE_BUILD_TYPE=Debug -DMEMORYCHECK_COMMAND_OPTIONS="--leak-check=full --track-origins=yes --error-exitcode=1"
+      - name: build
+        run: cmake --build build_dir --verbose
+      - name: test
+        run: ctest -T memcheck --output-on-failure .
+        working-directory: build_dir
+      - name: logs
+        run: cat build_dir/Testing/Temporary/MemoryChecker.*.log

From 7ebc0dab0a92f8d97b8796375cece678ca480fec Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 20 Nov 2021 00:57:40 +0300
Subject: [PATCH 119/185] fix noexcept functions

---
 quickjspp.hpp | 67 ++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 35 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 44b4ad983f..413ee92c7b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -638,50 +638,47 @@ struct fwrapper
     const char * name = nullptr;
 };
 
-/** Conversion to JSValue for free function in fwrapper. */
-template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
-struct js_traits<fwrapper<F, PassThis>>
-{
-    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
-    {
-        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                       JSValueConst * argv) noexcept -> JSValue {
-            if constexpr(PassThis)
-                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
-            else
-                return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
-        }, fw.name, sizeof...(Args));
-
-    }
-};
-
-/** Conversion to JSValue for class member function in fwrapper. PassThis is ignored and treated as true */
-template <typename R, class T, typename... Args, R (T::*F)(Args...), bool PassThis/*=ignored*/>
-struct js_traits<fwrapper<F, PassThis>>
+namespace detail {
+template <typename R, typename Class, auto F, bool PassThis, typename... Args>
+struct fwrapper_trait_helper
 {
     static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
+            if constexpr(std::is_same_v<Class, void>)
+            {
+                if constexpr(PassThis)
+                    return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
+                else
+                    return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
+            }
+            else // PassThis is ignored if Class is not void
+                return detail::wrap_this_call<R, std::shared_ptr<Class>, Args...>(ctx, F, this_value, argc, argv);
         }, fw.name, sizeof...(Args));
-
     }
 };
+} // namespace detail {
 
-/** Conversion to JSValue for const class member function in fwrapper. PassThis is ignored and treated as true */
-template <typename R, class T, typename... Args, R (T::*F)(Args...) const, bool PassThis/*=ignored*/>
-struct js_traits<fwrapper<F, PassThis>>
-{
-    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
-    {
-        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
-                                       JSValueConst * argv) noexcept -> JSValue {
-            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
-        }, fw.name, sizeof...(Args));
-
-    }
-};
+/** Conversion to JSValue for free function in fwrapper. */
+#define QJSPP_DEFINE_TRAIT(specifiers) \
+template <typename R, typename... Args, R (* F)(Args...) specifiers, bool PassThis> \
+struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, void, F, PassThis, Args...> {}
+
+QJSPP_DEFINE_TRAIT();
+QJSPP_DEFINE_TRAIT(noexcept);
+#undef QJSPP_DEFINE_TRAIT
+
+/** Conversion to JSValue for class member function (incl. const and noexcept functions) in fwrapper. PassThis is ignored and treated as true */
+#define QJSPP_DEFINE_TRAIT(specifiers) \
+template <typename R, class T, typename... Args, R (T::*F)(Args...) specifiers, bool PassThis/*=ignored*/> \
+struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, T, F, PassThis, Args...> {}
+
+QJSPP_DEFINE_TRAIT();
+QJSPP_DEFINE_TRAIT(noexcept);
+QJSPP_DEFINE_TRAIT(const);
+QJSPP_DEFINE_TRAIT(const noexcept);
+#undef QJSPP_DEFINE_TRAIT
 
 /** A wrapper type for constructor of type T with arguments Args.
  * Compilation fails if no such constructor is defined.

From d6cea5c8fea06d0f1573cda2ece3fba2a2c3c8a5 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 20 Nov 2021 01:18:16 +0300
Subject: [PATCH 120/185] fix noexcept for clang<12 :(

---
 quickjspp.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 413ee92c7b..aa5b955ff6 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -666,7 +666,9 @@ template <typename R, typename... Args, R (* F)(Args...) specifiers, bool PassTh
 struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, void, F, PassThis, Args...> {}
 
 QJSPP_DEFINE_TRAIT();
+#if !defined(__clang_major__) || __clang_major__ >= 12 // clang < 12 is broken
 QJSPP_DEFINE_TRAIT(noexcept);
+#endif
 #undef QJSPP_DEFINE_TRAIT
 
 /** Conversion to JSValue for class member function (incl. const and noexcept functions) in fwrapper. PassThis is ignored and treated as true */
@@ -675,9 +677,11 @@ template <typename R, class T, typename... Args, R (T::*F)(Args...) specifiers,
 struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, T, F, PassThis, Args...> {}
 
 QJSPP_DEFINE_TRAIT();
-QJSPP_DEFINE_TRAIT(noexcept);
 QJSPP_DEFINE_TRAIT(const);
+#if !defined(__clang_major__) || __clang_major__ >= 12
+QJSPP_DEFINE_TRAIT(noexcept);
 QJSPP_DEFINE_TRAIT(const noexcept);
+#endif
 #undef QJSPP_DEFINE_TRAIT
 
 /** A wrapper type for constructor of type T with arguments Args.

From 5b866fb8e8ed2883a88dca314ff100fe80d6fea1 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 20 Nov 2021 01:19:43 +0300
Subject: [PATCH 121/185] allow converting JS_NULL to/from std::shared_ptr<T>
 (same as T*)

---
 quickjspp.hpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index aa5b955ff6..6dd1b17159 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -739,7 +739,7 @@ struct js_traits<ctor_wrapper<T, Args...>>
 };
 
 
-/** Conversions for std::shared_ptr<T>.
+/** Conversions for std::shared_ptr<T>. Empty shared_ptr corresponds to JS_NULL.
  * T should be registered to a context before conversions.
  * @tparam T class type
  */
@@ -851,6 +851,8 @@ struct js_traits<std::shared_ptr<T>>
      */
     static JSValue wrap(JSContext * ctx, std::shared_ptr<T> ptr)
     {
+        if(!ptr)
+            return JS_NULL;
         if(QJSClassId == 0) // not registered
         {
 #if defined(__cpp_rtti)
@@ -871,9 +873,12 @@ struct js_traits<std::shared_ptr<T>>
     }
 
     /// @throws exception if #v doesn't have the correct class id
-    static const std::shared_ptr<T> unwrap(JSContext * ctx, JSValueConst v)
+    static std::shared_ptr<T> unwrap(JSContext * ctx, JSValueConst v)
     {
         std::shared_ptr<T> ptr = nullptr;
+        if (JS_IsNull(v)) {
+            return ptr;
+        }
         auto obj_class_id = JS_GetClassID(v);
 
         if (obj_class_id == QJSClassId) {
@@ -896,7 +901,7 @@ struct js_traits<std::shared_ptr<T>>
     }
 };
 
-/** Conversions for non-owning pointers to class T.
+/** Conversions for non-owning pointers to class T. nullptr corresponds to JS_NULL.
  * @tparam T class type
  */
 template <class T>

From 9cbbc558de814b76759b64c9b027007da8ad84eb Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 20 Nov 2021 01:20:03 +0300
Subject: [PATCH 122/185] remove unnecessary overload

---
 quickjspp.hpp | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 6dd1b17159..7273250248 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1369,13 +1369,6 @@ class Context
             return *this;
         }
 
-        Module& add(const char * name, Value value)
-        {
-            assert(value.ctx == ctx);
-            exports.push_back({name, std::move(value)});
-            JS_AddModuleExport(ctx, m, name);
-            return *this;
-        }
 
         template <typename T>
         Module& add(const char * name, T value)

From b43c156a8a9c7e1707f4c0509b1bd842b544c5a3 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 21 Nov 2021 14:35:52 +0300
Subject: [PATCH 123/185] Revert "fix noexcept for clang<12 :("

This reverts commit d6cea5c8fea06d0f1573cda2ece3fba2a2c3c8a5.
---
 quickjspp.hpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 7273250248..57848ab3d0 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -666,9 +666,7 @@ template <typename R, typename... Args, R (* F)(Args...) specifiers, bool PassTh
 struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, void, F, PassThis, Args...> {}
 
 QJSPP_DEFINE_TRAIT();
-#if !defined(__clang_major__) || __clang_major__ >= 12 // clang < 12 is broken
 QJSPP_DEFINE_TRAIT(noexcept);
-#endif
 #undef QJSPP_DEFINE_TRAIT
 
 /** Conversion to JSValue for class member function (incl. const and noexcept functions) in fwrapper. PassThis is ignored and treated as true */
@@ -677,11 +675,9 @@ template <typename R, class T, typename... Args, R (T::*F)(Args...) specifiers,
 struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, T, F, PassThis, Args...> {}
 
 QJSPP_DEFINE_TRAIT();
-QJSPP_DEFINE_TRAIT(const);
-#if !defined(__clang_major__) || __clang_major__ >= 12
 QJSPP_DEFINE_TRAIT(noexcept);
+QJSPP_DEFINE_TRAIT(const);
 QJSPP_DEFINE_TRAIT(const noexcept);
-#endif
 #undef QJSPP_DEFINE_TRAIT
 
 /** A wrapper type for constructor of type T with arguments Args.

From b433b4add663a17bf57e06bfcca4709ae0ddb144 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 21 Nov 2021 14:35:52 +0300
Subject: [PATCH 124/185] Revert "fix noexcept functions"

This reverts commit 7ebc0dab0a92f8d97b8796375cece678ca480fec.
---
 quickjspp.hpp | 67 +++++++++++++++++++++++++++------------------------
 1 file changed, 35 insertions(+), 32 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 57848ab3d0..5a3f07d7f5 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -638,47 +638,50 @@ struct fwrapper
     const char * name = nullptr;
 };
 
-namespace detail {
-template <typename R, typename Class, auto F, bool PassThis, typename... Args>
-struct fwrapper_trait_helper
+/** Conversion to JSValue for free function in fwrapper. */
+template <typename R, typename... Args, R (* F)(Args...), bool PassThis>
+struct js_traits<fwrapper<F, PassThis>>
 {
     static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
     {
         return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
                                        JSValueConst * argv) noexcept -> JSValue {
-            if constexpr(std::is_same_v<Class, void>)
-            {
-                if constexpr(PassThis)
-                    return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
-                else
-                    return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
-            }
-            else // PassThis is ignored if Class is not void
-                return detail::wrap_this_call<R, std::shared_ptr<Class>, Args...>(ctx, F, this_value, argc, argv);
+            if constexpr(PassThis)
+                return detail::wrap_this_call<R, Args...>(ctx, F, this_value, argc, argv);
+            else
+                return detail::wrap_call<R, Args...>(ctx, F, argc, argv);
         }, fw.name, sizeof...(Args));
+
     }
 };
-} // namespace detail {
 
-/** Conversion to JSValue for free function in fwrapper. */
-#define QJSPP_DEFINE_TRAIT(specifiers) \
-template <typename R, typename... Args, R (* F)(Args...) specifiers, bool PassThis> \
-struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, void, F, PassThis, Args...> {}
-
-QJSPP_DEFINE_TRAIT();
-QJSPP_DEFINE_TRAIT(noexcept);
-#undef QJSPP_DEFINE_TRAIT
-
-/** Conversion to JSValue for class member function (incl. const and noexcept functions) in fwrapper. PassThis is ignored and treated as true */
-#define QJSPP_DEFINE_TRAIT(specifiers) \
-template <typename R, class T, typename... Args, R (T::*F)(Args...) specifiers, bool PassThis/*=ignored*/> \
-struct js_traits<fwrapper<F, PassThis>> : public detail::fwrapper_trait_helper<R, T, F, PassThis, Args...> {}
-
-QJSPP_DEFINE_TRAIT();
-QJSPP_DEFINE_TRAIT(noexcept);
-QJSPP_DEFINE_TRAIT(const);
-QJSPP_DEFINE_TRAIT(const noexcept);
-#undef QJSPP_DEFINE_TRAIT
+/** Conversion to JSValue for class member function in fwrapper. PassThis is ignored and treated as true */
+template <typename R, class T, typename... Args, R (T::*F)(Args...), bool PassThis/*=ignored*/>
+struct js_traits<fwrapper<F, PassThis>>
+{
+    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
+    {
+        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                       JSValueConst * argv) noexcept -> JSValue {
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
+        }, fw.name, sizeof...(Args));
+
+    }
+};
+
+/** Conversion to JSValue for const class member function in fwrapper. PassThis is ignored and treated as true */
+template <typename R, class T, typename... Args, R (T::*F)(Args...) const, bool PassThis/*=ignored*/>
+struct js_traits<fwrapper<F, PassThis>>
+{
+    static JSValue wrap(JSContext * ctx, fwrapper<F, PassThis> fw) noexcept
+    {
+        return JS_NewCFunction(ctx, [](JSContext * ctx, JSValueConst this_value, int argc,
+                                       JSValueConst * argv) noexcept -> JSValue {
+            return detail::wrap_this_call<R, std::shared_ptr<T>, Args...>(ctx, F, this_value, argc, argv);
+        }, fw.name, sizeof...(Args));
+
+    }
+};
 
 /** A wrapper type for constructor of type T with arguments Args.
  * Compilation fails if no such constructor is defined.

From 10b3ad0ab2fe1606ce356c46f0796a4854f797db Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 21 Nov 2021 14:41:16 +0300
Subject: [PATCH 125/185] remove noexcept from class test for now, it seems to
 be a bug that is only in clang >=12

https://gcc.godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:(filename:'1',fontScale:14,fontUsePx:'0',j:1,lang:c%2B%2B,selection:(endColumn:2,endLineNumber:17,positionColumn:2,positionLineNumber:17,selectionStartColumn:2,selectionStartLineNumber:17,startColumn:2,startLineNumber:17),source:'template+%3Cauto+F%3E%0Astruct+x%7B%7D%3B%0A%0Atemplate+%3Ctypename+T%3E+struct+t%7B%7D%3B%0A%0Atemplate%3Ctypename+R,+typename...+Args,+R+(*F)(Args...)%3E%0Astruct+t%3Cx%3CF%3E%3E+%7Bstatic+const+int+i+%3D+1%3B+%7D%3B%0A%0A//template%3Ctypename+R,+typename...+Args,+R+(*F)(Args...)+noexcept%3E%0A//struct+t%3Cx%3CF%3E%3E+%7Bstatic+const+int+i+%3D+2%3B+%7D%3B%0A%0A%0Aint+f(int,+int)+noexcept+%7Breturn+0%3B%7D%0A%0Aint+main()+%7B%0A++++return+t%3Cx%3C%26f%3E%3E::i%3B%0A%7D%0A%0A'),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0')),k:33.333333333333336,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((h:compiler,i:(compiler:clang1200,filters:(b:'0',binary:'1',commentOnly:'0',demangle:'0',directives:'0',execute:'1',intel:'0',libraryCode:'0',trim:'1'),flagsViewOpen:'1',fontScale:14,fontUsePx:'0',j:1,lang:c%2B%2B,libs:!(),options:'-std%3Dc%2B%2B17',selection:(endColumn:1,endLineNumber:1,positionColumn:1,positionLineNumber:1,selectionStartColumn:1,selectionStartLineNumber:1,startColumn:1,startLineNumber:1),source:1,tree:'1'),l:'5',n:'0',o:'x86-64+clang+12.0.0+(C%2B%2B,+Editor+%231,+Compiler+%231)',t:'0')),k:33.333333333333336,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((h:output,i:(compiler:1,editor:1,fontScale:14,fontUsePx:'0',tree:'1',wrap:'1'),l:'5',n:'0',o:'Output+of+x86-64+clang+12.0.0+(Compiler+%231)',t:'0')),k:33.33333333333333,l:'4',n:'0',o:'',s:0,t:'0')),l:'2',n:'0',o:'',t:'0')),version:4
---
 test/class.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/class.cpp b/test/class.cpp
index c9c162487a..94cb1ea8ed 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -37,8 +37,8 @@ class test : public base_test
     { printf("dtor!\n"); }
 
     int32_t fi(TYPES) const { i++; return i; }
-    bool fb(TYPES) noexcept { i++; return b; }
-    double fd(TYPES) const noexcept { i++; return d; }
+    bool fb(TYPES) { i++; return b; }
+    double fd(TYPES) const { i++; return d; }
     const std::shared_ptr<test>& fspt(TYPES) { i++; return spt; }
     const std::string& fs(TYPES) { i++; return s; }
     void f(TYPES) { i++; }

From e1ae963a0348d5ac5110f509185b47f0096aa72b Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 09:00:47 +0000
Subject: [PATCH 126/185] Add test for throwing non qjs::exception objects. Fix
 a few typos.

---
 quickjspp.hpp      | 19 ++++++++++---------
 test/exception.cpp | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 44b4ad983f..df3a50e45b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -506,7 +506,7 @@ struct unwrap_arg_impl {
     static auto unwrap(JSContext * ctx, int argc, JSValueConst * argv)
     {
         if (size_t(argc) <= I) {
-            JS_ThrowTypeError(ctx, "Expected type %lu arguments but only %d were provided",
+            JS_ThrowTypeError(ctx, "Expected at least %lu arguments but received %d",
                               (unsigned long)NArgs, argc);
             throw exception{};
         }
@@ -838,7 +838,7 @@ struct js_traits<std::shared_ptr<T>>
             int e = JS_NewClass(rt, QJSClassId, &def);
             if(e < 0)
             {
-                JS_ThrowInternalError(ctx, "Cant register class %s", name);
+                JS_ThrowInternalError(ctx, "Can't register class %s", name);
                 throw exception{};
             }
         }
@@ -951,18 +951,19 @@ struct function
     template <typename Functor>
     static function * create(JSRuntime * rt, Functor&& f)
     {
-        auto fptr = static_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor)));
+        using Functor_t = std::decay_t<Functor>;
+        auto fptr = static_cast<function *>(js_malloc_rt(rt, sizeof(function) + sizeof(Functor_t)));
         if(!fptr)
             throw std::bad_alloc{};
         new(fptr) function;
-        auto functorptr = reinterpret_cast<Functor *>(fptr->functor);
-        new(functorptr) Functor(std::forward<Functor>(f));
+        auto functorptr = reinterpret_cast<Functor_t *>(fptr->functor);
+        new(functorptr) Functor_t(std::forward<Functor>(f));
         fptr->destroyer = nullptr;
-        if constexpr(!std::is_trivially_destructible_v<Functor>)
+        if constexpr(!std::is_trivially_destructible_v<Functor_t>)
         {
             fptr->destroyer = [](function * fptr) {
-                auto functorptr = static_cast<Functor *>(fptr->functor);
-                functorptr->~Functor();
+                auto functorptr = reinterpret_cast<Functor_t *>(fptr->functor);
+                functorptr->~Functor_t();
             };
         }
         return fptr;
@@ -1685,7 +1686,7 @@ struct js_traits<std::function<R(Args...)>>
         auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
         fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
             assert(self);
-            auto f = reinterpret_cast<Functor *>(&self->functor);
+            auto f = reinterpret_cast<std::decay_t<Functor> *>(&self->functor);
             return detail::wrap_call<R, Args...>(ctx, *f, argc, argv);
         };
         JS_SetOpaque(obj, fptr);
diff --git a/test/exception.cpp b/test/exception.cpp
index 20a8bce859..5558841643 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -52,4 +52,20 @@ int main()
             std::cerr << (std::string)exc["stack"] << std::endl;
     }
 
+    try
+    {
+        qjs::Value caller = context.eval("(f) => f();", "<test>");
+        caller.as<std::function<void(std::function<void()>)>>()([](){
+            throw std::runtime_error("some error");
+        });
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+    }
+
 }

From 7fbfbf9026c881aca42fb3be70ba8b0034251e4f Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 10:06:06 +0000
Subject: [PATCH 127/185] Avoid any kind of C++ exception from reaching
 quickjs's C code.

---
 quickjspp.hpp | 63 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 60 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index df3a50e45b..57b9009061 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -571,6 +571,16 @@ JSValue wrap_call(JSContext * ctx, Callable&& f, int argc, JSValueConst * argv)
     {
         return JS_EXCEPTION;
     }
+    catch (std::exception const & err)
+    {
+        JS_ThrowInternalError(ctx, "%s", err.what());
+        return JS_EXCEPTION;
+    }
+    catch (...)
+    {
+        JS_ThrowInternalError(ctx, "Unknown error");
+        return JS_EXCEPTION;
+    }
 }
 
 /** Same as wrap_call, but pass this_value as first argument.
@@ -600,6 +610,16 @@ JSValue wrap_this_call(JSContext * ctx, Callable&& f, JSValueConst this_value, i
     {
         return JS_EXCEPTION;
     }
+    catch (std::exception const & err)
+    {
+        JS_ThrowInternalError(ctx, "%s", err.what());
+        return JS_EXCEPTION;
+    }
+    catch (...)
+    {
+        JS_ThrowInternalError(ctx, "Unknown error");
+        return JS_EXCEPTION;
+    }
 }
 
 template <class Tuple, std::size_t... I>
@@ -723,12 +743,27 @@ struct js_traits<ctor_wrapper<T, Args...>>
             if(JS_IsException(jsobj))
                 return jsobj;
 
-            try {
+            try
+            {
                 std::shared_ptr<T> ptr = std::apply(std::make_shared<T, Args...>, detail::unwrap_args<Args...>(ctx, argc, argv));
                 JS_SetOpaque(jsobj, new std::shared_ptr<T>(std::move(ptr)));
                 return jsobj;
-            } catch (exception) {
+            }
+            catch (exception)
+            {
+                JS_FreeValue(ctx, jsobj);
+                return JS_EXCEPTION;
+            }
+            catch (std::exception const & err)
+            {
                 JS_FreeValue(ctx, jsobj);
+                JS_ThrowInternalError(ctx, "%s", err.what());
+                return JS_EXCEPTION;
+            }
+            catch (...)
+            {
+                JS_FreeValue(ctx, jsobj);
+                JS_ThrowInternalError(ctx, "Unknown error");
                 return JS_EXCEPTION;
             }
 
@@ -889,8 +924,10 @@ struct js_traits<std::shared_ptr<T>>
                               QJSPP_TYPENAME(T), obj_class_id);
             throw exception{};
         }
-        if(!ptr)
+        if(!ptr) {
+            JS_ThrowInternalError(ctx, "Object's opaque pointer is NULL");
             throw exception{};
+        }
         return ptr;
     }
 };
@@ -1711,6 +1748,16 @@ struct js_traits<std::vector<T>>
         {
             return JS_EXCEPTION;
         }
+        catch (std::exception const & err)
+        {
+            JS_ThrowInternalError(ctx, "%s", err.what());
+            return JS_EXCEPTION;
+        }
+        catch (...)
+        {
+            JS_ThrowInternalError(ctx, "Unknown error");
+            return JS_EXCEPTION;
+        }
     }
 
     static std::vector<T> unwrap(JSContext * ctx, JSValueConst jsarr)
@@ -1747,6 +1794,16 @@ struct js_traits<std::pair<U, V>>
         {
             return JS_EXCEPTION;
         }
+        catch (std::exception const & err)
+        {
+            JS_ThrowInternalError(ctx, "%s", err.what());
+            return JS_EXCEPTION;
+        }
+        catch (...)
+        {
+            JS_ThrowInternalError(ctx, "Unknown error");
+            return JS_EXCEPTION;
+        }
     }
 
     static std::pair<U, V> unwrap(JSContext * ctx, JSValueConst jsarr)

From 9492e8a65a7eb29a594cd551445f2c8922ef8d35 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 10:06:23 +0000
Subject: [PATCH 128/185] Add more test for throwing non qjs::exception
 objects.

---
 test/exception.cpp | 65 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

diff --git a/test/exception.cpp b/test/exception.cpp
index 5558841643..8d2edbe146 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -1,8 +1,19 @@
 #include "quickjspp.hpp"
 #include <iostream>
+#include <stdexcept>
 
 struct A{};
 
+struct B {
+    B() {
+        throw std::runtime_error("constructor error");
+    }
+    B(int) {}
+    void a_method() {
+        throw std::runtime_error("method error");
+    }
+};
+
 int main()
 {
     qjs::Runtime runtime;
@@ -12,6 +23,13 @@ int main()
     context.registerClass<A>("A");
     context.registerClass<A>("A");
 
+    auto& testMod = context.addModule("test");
+
+    testMod.class_<B>("B")
+        .constructor<>("B")
+        .constructor<int>("B_int")
+        .fun<&B::a_method>("a_method");
+
     try
     {
         auto obj = context.eval("Symbol.toPrimitive");
@@ -21,6 +39,9 @@ int main()
     catch(qjs::exception)
     {
         auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
         assert(exc.isError() && (std::string) exc == "TypeError: cannot convert symbol to number");
     }
 
@@ -34,7 +55,10 @@ int main()
     catch(qjs::exception)
     {
         auto exc = context.getException();
-        std::cout << (std::string) exc << '\n' << (std::string_view) exc["stack"];
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+        assert(exc.isError() && (std::string) exc == "TypeError: cannot convert symbol to number");
     }
 
     try
@@ -50,8 +74,10 @@ int main()
         std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
         if((bool)exc["stack"])
             std::cerr << (std::string)exc["stack"] << std::endl;
+        assert(exc.isError() && (std::string) exc == "ReferenceError: 'b' is not defined");
     }
 
+    // test the `wrap_call` case
     try
     {
         qjs::Value caller = context.eval("(f) => f();", "<test>");
@@ -66,6 +92,43 @@ int main()
         std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
         if((bool)exc["stack"])
             std::cerr << (std::string)exc["stack"] << std::endl;
+        assert(exc.isError() && (std::string) exc == "InternalError: some error");
     }
 
+    // test the `ctor_wrapper` case
+    try
+    {
+        qjs::Value caller = context.eval(R"xxx(
+            import { B } from "test";
+            const b = new B();
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+        assert(exc.isError() && (std::string) exc == "InternalError: constructor error");
+    }
+
+    // test the `wrap_this_call` case
+    try
+    {
+        qjs::Value caller = context.eval(R"xxx(
+            import { B_int } from "test";
+            const b = new B_int(123);
+            b.a_method();
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+        assert(false);
+    }
+    catch(qjs::exception)
+    {
+        auto exc = context.getException();
+        std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
+        if((bool)exc["stack"])
+            std::cerr << (std::string)exc["stack"] << std::endl;
+        assert(exc.isError() && (std::string) exc == "InternalError: method error");
+    }
 }

From 753654f401a5ff38befb71bef905aa75bd506d06 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 10:50:30 +0000
Subject: [PATCH 129/185] Fix failing test in function_call

---
 test/function_call.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/function_call.cpp b/test/function_call.cpp
index 8611509be3..15d3fd2f8a 100644
--- a/test/function_call.cpp
+++ b/test/function_call.cpp
@@ -30,7 +30,7 @@ int test_not_enough_arguments(qjs::Context & ctx) {
                 assert(false);
             } catch (err) {
                 assert(err instanceof TypeError); 
-                assert_eq(err.message, 'Expected type 3 arguments but only 1 were provided');
+                assert_eq(err.message, 'Expected at least 3 arguments but received 1');
             }
         )xxx");
     }

From b71945e0ffd585ac024bb8fc5c5523b896fd92f6 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Nov 2021 14:36:26 +0300
Subject: [PATCH 130/185] add install target to cmake, fixes #38

---
 CMakeLists.txt         | 15 ++++++++++++---
 quickjs/CMakeLists.txt | 13 ++++++++++---
 test/CMakeLists.txt    |  5 ++---
 3 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1a6ebf8870..a117b385e2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.13)
-project(quickjspp)
+project(quickjspp LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 17)
+#set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
 
 if(CMAKE_COMPILER_IS_GNUCC)
@@ -9,8 +9,17 @@ if(CMAKE_COMPILER_IS_GNUCC)
 endif()
 
 add_subdirectory(quickjs)
+
+add_library(quickjspp INTERFACE)
+target_link_libraries(quickjspp INTERFACE quickjs)
+target_compile_features(quickjspp INTERFACE cxx_std_17)
+set_target_properties(quickjspp PROPERTIES PUBLIC_HEADER quickjspp.hpp)
+target_include_directories(quickjspp INTERFACE .)
+
 add_executable(qjs qjs.cpp)
-target_link_libraries(qjs quickjs)
+target_link_libraries(qjs quickjspp)
 
 enable_testing()
 add_subdirectory(test)
+
+install(TARGETS quickjspp qjs)
diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index 4862129b27..2664223d55 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -1,20 +1,27 @@
 project(quickjs LANGUAGES C)
 
-
 file(STRINGS VERSION version)
 
 set(quickjs_src quickjs.c libbf.c libunicode.c libregexp.c cutils.c quickjs-libc.c)
 set(quickjs_def CONFIG_VERSION="${version}" _GNU_SOURCE CONFIG_BIGNUM)
 
-
 add_library(quickjs ${quickjs_src})
 target_compile_definitions(quickjs PRIVATE ${quickjs_def} )
+set_target_properties(quickjs PROPERTIES PUBLIC_HEADER "quickjs.h;quickjs-libc.h")
 
 add_library(quickjs-dumpleaks ${quickjs_src})
 target_compile_definitions(quickjs-dumpleaks PRIVATE ${quickjs_def} DUMP_LEAKS=1)
 
-if(UNIX)
+if(UNIX OR MINGW)
   find_package(Threads)
   target_link_libraries(quickjs ${CMAKE_DL_LIBS} m Threads::Threads)
   target_link_libraries(quickjs-dumpleaks ${CMAKE_DL_LIBS} m Threads::Threads)
 endif()
+
+# install
+include(GNUInstallDirs)
+install(TARGETS quickjs
+        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/quickjs
+        ARCHIVE       DESTINATION ${CMAKE_INSTALL_LIBDIR}/quickjs
+        LIBRARY       DESTINATION ${CMAKE_INSTALL_LIBDIR}/quickjs
+        )
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2a57bcf026..ccd23e7b82 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,12 +1,11 @@
-include_directories(..)
-
 macro(make_test name)
 add_executable(${name} ${name}.cpp)
-target_link_libraries(${name} quickjs-dumpleaks)
+target_link_libraries(${name} quickjspp quickjs-dumpleaks)
 add_test(${name} ${name})
 # try to compile with -DCONFIG_CHECK_JSVALUE
 add_library(${name}-checkjsv OBJECT ${name}.cpp)
 target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
+target_link_libraries(${name}-checkjsv quickjspp)
 endmacro()
 
 foreach(test

From fc2519b90d00fbf30ffd6cc6ad73de0ff5205270 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 22 Nov 2021 14:59:35 +0300
Subject: [PATCH 131/185] add option to disable tests in cmake
 -DBUILD_TESTING=OFF

---
 CMakeLists.txt | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a117b385e2..3ccf600fc8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,13 +13,16 @@ add_subdirectory(quickjs)
 add_library(quickjspp INTERFACE)
 target_link_libraries(quickjspp INTERFACE quickjs)
 target_compile_features(quickjspp INTERFACE cxx_std_17)
-set_target_properties(quickjspp PROPERTIES PUBLIC_HEADER quickjspp.hpp)
 target_include_directories(quickjspp INTERFACE .)
+set_target_properties(quickjspp PROPERTIES PUBLIC_HEADER quickjspp.hpp)
 
 add_executable(qjs qjs.cpp)
 target_link_libraries(qjs quickjspp)
 
-enable_testing()
-add_subdirectory(test)
+# cmake -DBUILD_TESTING=OFF to disable tests
+include(CTest)
+if(BUILD_TESTING)
+    add_subdirectory(test)
+endif()
 
 install(TARGETS quickjspp qjs)

From cf5f20c0b30e63fed0f7f373f6a740d69cac80fe Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 13:56:02 +0000
Subject: [PATCH 132/185] Expose the API to enqueue/run jobs

---
 quickjspp.hpp       | 52 ++++++++++++++++++++++++++++++++++++++++++++-
 test/CMakeLists.txt |  2 +-
 test/jobs.cpp       | 32 ++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 2 deletions(-)
 create mode 100644 test/jobs.cpp

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 771512fda0..a250e2fdee 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -951,7 +951,13 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
         if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
         {
 #if defined(__cpp_rtti)
-            js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
+            if constexpr(std::is_same_v<std::decay_t<T> *, JSValue>) {
+                // This needs to be a special case because in `CONFIG_CHECK_JSVALUE` mode
+                // `JSValue` is a pointer to an incomplete type, which doesn't support `typeid`.
+                js_traits<std::shared_ptr<T>>::register_class(ctx, "JSValue");
+            } else {
+                js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
+            }
 #else
             JS_ThrowTypeError(ctx, "quickjspp js_traits<T *>::wrap: Class is not registered");
             return JS_EXCEPTION;
@@ -1356,6 +1362,12 @@ class Runtime
     {
         JS_FreeRuntime(rt);
     }
+
+    void executePendingJob();
+
+    bool isJobPending() const {
+        return JS_IsJobPending(rt);
+    }
 };
 
 /** Wrapper over JSContext * ctx
@@ -1583,6 +1595,8 @@ class Context
         JS_FreeContext(ctx);
     }
 
+    void enqueueJob(std::function<void()> && job);
+
     /** Create module and return a reference to it */
     Module& addModule(const char * name)
     {
@@ -1868,4 +1882,40 @@ property_proxy<Key>::operator Value() const
 }
 }
 
+inline void Context::enqueueJob(std::function<void()> && job_fcn) {
+    // No need to free the new value. It will be freed automatically when
+    // the function is called.
+    JSValueConst job_val = newValue(std::move(job_fcn)).release();
+    JS_EnqueueJob(ctx, [](JSContext *ctx, int argc, JSValueConst *argv){
+        try
+        {
+            // use Value constructor rather than context.newValue to avoid retrieving the Context object.
+            Value{ctx, argv[0]}.as<std::function<void()>>()();
+        }
+        catch (exception)
+        {
+            return JS_EXCEPTION;
+        }
+        catch (std::exception const & err)
+        {
+            JS_ThrowInternalError(ctx, "%s", err.what());
+            return JS_EXCEPTION;
+        }
+        catch (...)
+        {
+            JS_ThrowInternalError(ctx, "Unknown error");
+            return JS_EXCEPTION;
+        }
+        return JS_UNDEFINED;
+    }, 1, &job_val);
+}
+
+inline void Runtime::executePendingJob() {
+    JSContext * ctx;
+    auto err = JS_ExecutePendingJob(rt, &ctx);
+    if (err < 0) {
+        throw exception{};
+    }
+}
+
 } // namespace qjs
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2a57bcf026..a411f134cb 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,7 +10,7 @@ target_compile_definitions(${name}-checkjsv PRIVATE CONFIG_CHECK_JSVALUE=1)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant function_call inheritance
+        value class exception example multicontext conversions point variant function_call inheritance jobs
         )
 make_test(${test})
 endforeach()
diff --git a/test/jobs.cpp b/test/jobs.cpp
new file mode 100644
index 0000000000..00154b1388
--- /dev/null
+++ b/test/jobs.cpp
@@ -0,0 +1,32 @@
+#include "quickjspp.hpp"
+#include <iostream>
+#include <stdexcept>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    
+    context.global().add("nextTick", [&context](std::function<void()> f) {
+        context.enqueueJob(std::move(f));
+    });
+
+    bool called = false;
+    context.global().add("testFcn", [&called]() {
+        called = true;
+    });
+
+    qjs::Value caller = context.eval(R"xxx(
+        nextTick(testFcn);
+    )xxx");
+
+    assert(!called && "`testFcn` should not be called yet");
+
+    while (runtime.isJobPending()) {
+        runtime.executePendingJob();
+    }
+
+    assert(called && "`testFcn` should have been called");
+
+    return 0;
+}

From c7d8fe59166c421ca0dcaaf48853c1ee36c1084b Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 14:15:44 +0000
Subject: [PATCH 133/185] Add context information to exceptions

---
 quickjspp.hpp | 66 ++++++++++++++++++++++++++++++---------------------
 1 file changed, 39 insertions(+), 27 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index a250e2fdee..14b44e3e6f 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -28,11 +28,17 @@
 
 namespace qjs {
 
+class Context;
 
 /** Exception type.
  * Indicates that exception has occured in JS context.
  */
-class exception {};
+class exception {
+    JSContext * ctx;
+public:
+    exception(JSContext * ctx) : ctx(ctx) {}
+    Context & context() const;
+};
 
 /** Javascript conversion traits.
  * Describes how to convert type R to/from JSValue. Second template argument can be used for SFINAE/enable_if type filters.
@@ -83,14 +89,14 @@ struct js_traits<Int, std::enable_if_t<std::is_integral_v<Int> && sizeof(Int) <=
         {
             int64_t r;
             if(JS_ToInt64(ctx, &r, v))
-                throw exception{};
+                throw exception{ctx};
             return static_cast<Int>(r);
         }
         else
         {
             int32_t r;
             if(JS_ToInt32(ctx, &r, v))
-                throw exception{};
+                throw exception{ctx};
             return static_cast<Int>(r);
         }
     }
@@ -130,7 +136,7 @@ struct js_traits<void>
     static void unwrap(JSContext * ctx, JSValueConst value)
     {
         if(JS_IsException(value))
-            throw exception{};
+            throw exception{ctx};
     }
 };
 
@@ -144,7 +150,7 @@ struct js_traits<double>
     {
         double r;
         if(JS_ToFloat64(ctx, &r, v))
-            throw exception{};
+            throw exception{ctx};
         return r;
     }
 
@@ -195,7 +201,7 @@ struct js_traits<std::string_view>
         size_t plen;
         const char * ptr = JS_ToCStringLen(ctx, &plen, v);
         if(!ptr)
-            throw exception{};
+            throw exception{ctx};
         return detail::js_string{ctx, ptr, plen};
     }
 
@@ -353,7 +359,7 @@ struct js_traits<std::variant<Ts...>>
             return unwrapPriority<Traits...>(ctx, v);
         }
         JS_ThrowTypeError(ctx, "Expected type %s", QJSPP_TYPENAME(std::variant<Ts...>));
-        throw exception{};
+        throw exception{ctx};
     }
 
     template <typename T>
@@ -463,7 +469,7 @@ struct js_traits<std::variant<Ts...>>
                 return unwrapPriority<is_double, std::is_floating_point>(ctx, v);
         }
 
-        throw exception{};
+        throw exception{ctx};
     }
 };
 
@@ -508,7 +514,7 @@ struct unwrap_arg_impl {
         if (size_t(argc) <= I) {
             JS_ThrowTypeError(ctx, "Expected at least %lu arguments but received %d",
                               (unsigned long)NArgs, argc);
-            throw exception{};
+            throw exception{ctx};
         }
         return js_traits<std::decay_t<T>>::unwrap(ctx, argv[I]);
     }
@@ -874,7 +880,7 @@ struct js_traits<std::shared_ptr<T>>
             if(e < 0)
             {
                 JS_ThrowInternalError(ctx, "Can't register class %s", name);
-                throw exception{};
+                throw exception{ctx};
             }
         }
         JS_SetClassProto(ctx, QJSClassId, proto);
@@ -927,11 +933,11 @@ struct js_traits<std::shared_ptr<T>>
             // The JS object does not derives from T
             JS_ThrowTypeError(ctx, "Expected type %s, got object with classid %d",
                               QJSPP_TYPENAME(T), obj_class_id);
-            throw exception{};
+            throw exception{ctx};
         }
         if(!ptr) {
             JS_ThrowInternalError(ctx, "Object's opaque pointer is NULL");
-            throw exception{};
+            throw exception{ctx};
         }
         return ptr;
     }
@@ -1082,7 +1088,7 @@ struct js_property_traits<const char *>
     {
         int err = JS_SetPropertyStr(ctx, this_obj, name, value);
         if(err < 0)
-            throw exception{};
+            throw exception{ctx};
     }
 
     static JSValue get_property(JSContext * ctx, JSValue this_obj, const char * name) noexcept
@@ -1098,7 +1104,7 @@ struct js_property_traits<uint32_t>
     {
         int err = JS_SetPropertyUint32(ctx, this_obj, idx, value);
         if(err < 0)
-            throw exception{};
+            throw exception{ctx};
     }
 
     static JSValue get_property(JSContext * ctx, JSValue this_obj, uint32_t idx) noexcept
@@ -1184,7 +1190,7 @@ class Value
     {
         v = js_traits<std::decay_t<T>>::wrap(ctx, std::forward<T>(val));
         if(JS_IsException(v))
-            throw exception{};
+            throw exception{ctx};
     }
 
     Value(const Value& rhs)
@@ -1292,7 +1298,7 @@ class Value
         );
         JS_FreeAtom(ctx, prop);
         if(ret < 0)
-            throw exception{};
+            throw exception{ctx};
         return *this;
     }
 
@@ -1309,7 +1315,7 @@ class Value
         );
         JS_FreeAtom(ctx, prop);
         if(ret < 0)
-            throw exception{};
+            throw exception{ctx};
         return *this;
     }
 
@@ -1363,7 +1369,7 @@ class Runtime
         JS_FreeRuntime(rt);
     }
 
-    void executePendingJob();
+    Context &executePendingJob();
 
     bool isJobPending() const {
         return JS_IsJobPending(rt);
@@ -1408,7 +1414,7 @@ class Context
                 return 0;
             });
             if(!m)
-                throw exception{};
+                throw exception{ctx};
         }
 
         Module& add(const char * name, JSValue value)
@@ -1540,7 +1546,7 @@ class Context
                 int err = JS_SetPrototype(context.ctx, prototype.v, base_proto);
                 JS_FreeValue(context.ctx, base_proto);
                 if(err < 0)
-                    throw exception{};
+                    throw exception{context.ctx};
                 return *this;
             }
 
@@ -1697,7 +1703,7 @@ struct js_traits<std::function<R(Args...)>>
                 if(JS_IsException(result))
                 {
                     JS_FreeValue(jsfun_obj.ctx, result);
-                    throw exception{};
+                    throw exception{ctx};
                 }
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
@@ -1714,7 +1720,7 @@ struct js_traits<std::function<R(Args...)>>
                 if(JS_IsException(result))
                 {
                     JS_FreeValue(jsfun_obj.ctx, result);
-                    throw exception{};
+                    throw exception{ctx};
                 }
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
@@ -1778,7 +1784,7 @@ struct js_traits<std::vector<T>>
         if(e == 0)
             JS_ThrowTypeError(ctx, "js_traits<std::vector<T>>::unwrap expects array");
         if(e <= 0)
-            throw exception{};
+            throw exception{ctx};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
         std::vector<T> arr;
         auto len = static_cast<int32_t>(jsarray["length"]);
@@ -1824,14 +1830,14 @@ struct js_traits<std::pair<U, V>>
         if(e == 0)
             JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expects array", QJSPP_TYPENAME(std::pair<U, V>));
         if(e <= 0)
-            throw exception{};
+            throw exception{ctx};
         Value jsarray{ctx, JS_DupValue(ctx, jsarr)};
         const auto len = static_cast<uint32_t>(jsarray["length"]);
         if(len != 2)
         {
             JS_ThrowTypeError(ctx, "js_traits<%s>::unwrap expected array of length 2, got length %d",
                               QJSPP_TYPENAME(std::pair<U, V>), len);
-            throw exception{};
+            throw exception{ctx};
         }
         return std::pair<U, V>{
                 static_cast<U>(jsarray[uint32_t(0)]),
@@ -1910,12 +1916,18 @@ inline void Context::enqueueJob(std::function<void()> && job_fcn) {
     }, 1, &job_val);
 }
 
-inline void Runtime::executePendingJob() {
+Context & exception::context() const {
+    return Context::get(ctx);
+}
+
+inline Context &Runtime::executePendingJob() {
     JSContext * ctx;
     auto err = JS_ExecutePendingJob(rt, &ctx);
+    assert(ctx && "The context of the job was NULL");
     if (err < 0) {
-        throw exception{};
+        throw exception{ctx};
     }
+    return Context::get(ctx);
 }
 
 } // namespace qjs

From eb7c9464ce7f623d7429e0e1e009b63ce78a2dfe Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 14:21:03 +0000
Subject: [PATCH 134/185] Add tests for context information in exceptions

---
 quickjspp.hpp    |  4 ++--
 test/jobs.cpp    | 13 +++++++++++++
 test/variant.cpp |  3 ++-
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 14b44e3e6f..4452880a8b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1698,7 +1698,7 @@ struct js_traits<std::function<R(Args...)>>
         const int argc = sizeof...(Args);
         if constexpr(argc == 0)
         {
-            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}]() -> R {
+            return [ctx, jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}]() -> R {
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, 0, nullptr);
                 if(JS_IsException(result))
                 {
@@ -1710,7 +1710,7 @@ struct js_traits<std::function<R(Args...)>>
         }
         else
         {
-            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
+            return [ctx, jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
                 const int argc = sizeof...(Args);
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
diff --git a/test/jobs.cpp b/test/jobs.cpp
index 00154b1388..e6ed94ad48 100644
--- a/test/jobs.cpp
+++ b/test/jobs.cpp
@@ -28,5 +28,18 @@ int main()
 
     assert(called && "`testFcn` should have been called");
 
+    context.enqueueJob([](){
+        throw std::runtime_error("some error");
+    });
+
+    try {
+        while (runtime.isJobPending()) {
+            runtime.executePendingJob();
+        }
+        assert(false && "Job execution should have failed");
+    } catch (qjs::exception const & exc) {
+        assert(&exc.context() == &context && "Exception should contain context information");
+    }
+
     return 0;
 }
diff --git a/test/variant.cpp b/test/variant.cpp
index d33eb15ea2..d7006e3516 100644
--- a/test/variant.cpp
+++ b/test/variant.cpp
@@ -1,4 +1,5 @@
 #include "quickjspp.hpp"
+#include <stdexcept>
 #include <variant>
 #include <iostream>
 
@@ -40,7 +41,7 @@ auto f2(var2 v2) -> var
 
 void assert_(bool condition)
 {
-    if(!condition) throw qjs::exception{};
+    if(!condition) throw std::runtime_error("assertion failed");
 }
 
 static void qjs_glue(qjs::Context::Module& m)

From b3828f410ff2cafad198e1e2b44b8d41a8917cc4 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 14:46:38 +0000
Subject: [PATCH 135/185] Make exception::context inline to avoid multiple
 definitions

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 4452880a8b..298e9affdc 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1916,7 +1916,7 @@ inline void Context::enqueueJob(std::function<void()> && job_fcn) {
     }, 1, &job_val);
 }
 
-Context & exception::context() const {
+inline Context & exception::context() const {
     return Context::get(ctx);
 }
 

From 66c21f85d9860110cbb014b9217657ad0bf0dfc7 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 16:36:31 +0000
Subject: [PATCH 136/185] Handle the case when there's no job to run

---
 quickjspp.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 298e9affdc..4409996525 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1369,7 +1369,7 @@ class Runtime
         JS_FreeRuntime(rt);
     }
 
-    Context &executePendingJob();
+    Context * executePendingJob();
 
     bool isJobPending() const {
         return JS_IsJobPending(rt);
@@ -1920,14 +1920,16 @@ inline Context & exception::context() const {
     return Context::get(ctx);
 }
 
-inline Context &Runtime::executePendingJob() {
+inline Context * Runtime::executePendingJob() {
     JSContext * ctx;
     auto err = JS_ExecutePendingJob(rt, &ctx);
-    assert(ctx && "The context of the job was NULL");
-    if (err < 0) {
+    if (err == 0) {
+        // There was no job to run
+        return nullptr;
+    } else if (err < 0) {
         throw exception{ctx};
     }
-    return Context::get(ctx);
+    return &Context::get(ctx);
 }
 
 } // namespace qjs

From 7455d6fc48f2338aafcbf8d23229990605c4d612 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 18:38:19 +0000
Subject: [PATCH 137/185] Add `executePendingJob` documentation

Co-authored-by: ftk <ftk@users.noreply.github.com>
---
 quickjspp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 4409996525..8980c9a03b 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1369,6 +1369,7 @@ class Runtime
         JS_FreeRuntime(rt);
     }
 
+    /// @return pointer to qjs::Context of the executed job or nullptr if no job is pending
     Context * executePendingJob();
 
     bool isJobPending() const {

From bbe839cddc0eb8ab8d6a7b7a24aa1e49c2697f96 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 21:45:41 +0000
Subject: [PATCH 138/185] Allow enqueueJob to take a templated Function rather
 than a std::function.

---
 quickjspp.hpp | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 8980c9a03b..ec2931193d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -957,13 +957,9 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
         if(js_traits<std::shared_ptr<T>>::QJSClassId == 0) // not registered
         {
 #if defined(__cpp_rtti)
-            if constexpr(std::is_same_v<std::decay_t<T> *, JSValue>) {
-                // This needs to be a special case because in `CONFIG_CHECK_JSVALUE` mode
-                // `JSValue` is a pointer to an incomplete type, which doesn't support `typeid`.
-                js_traits<std::shared_ptr<T>>::register_class(ctx, "JSValue");
-            } else {
-                js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
-            }
+            // If you have an error here with T=JSValueConst
+            // it probably means you are passing JSValueConst to where JSValue is expected
+            js_traits<std::shared_ptr<T>>::register_class(ctx, typeid(T).name());
 #else
             JS_ThrowTypeError(ctx, "quickjspp js_traits<T *>::wrap: Class is not registered");
             return JS_EXCEPTION;
@@ -1602,7 +1598,8 @@ class Context
         JS_FreeContext(ctx);
     }
 
-    void enqueueJob(std::function<void()> && job);
+    template <typename Function>
+    void enqueueJob(Function && job);
 
     /** Create module and return a reference to it */
     Module& addModule(const char * name)
@@ -1889,15 +1886,15 @@ property_proxy<Key>::operator Value() const
 }
 }
 
-inline void Context::enqueueJob(std::function<void()> && job_fcn) {
-    // No need to free the new value. It will be freed automatically when
-    // the function is called.
-    JSValueConst job_val = newValue(std::move(job_fcn)).release();
-    JS_EnqueueJob(ctx, [](JSContext *ctx, int argc, JSValueConst *argv){
+template <typename Function>
+void Context::enqueueJob(Function && job) {
+    JSValue job_val = js_traits<std::function<void()>>::wrap(ctx, std::forward<Function>(job));
+    JSValueConst arg = job_val;
+    int err = JS_EnqueueJob(ctx, [](JSContext *ctx, int argc, JSValueConst *argv){
         try
         {
-            // use Value constructor rather than context.newValue to avoid retrieving the Context object.
-            Value{ctx, argv[0]}.as<std::function<void()>>()();
+            assert(argc >= 1);
+            js_traits<std::function<void()>>::unwrap(ctx, argv[0])();
         }
         catch (exception)
         {
@@ -1914,7 +1911,10 @@ inline void Context::enqueueJob(std::function<void()> && job_fcn) {
             return JS_EXCEPTION;
         }
         return JS_UNDEFINED;
-    }, 1, &job_val);
+    }, 1, &arg);
+    JS_FreeValue(ctx, job_val);
+    if(err < 0)
+        throw exception{ctx};
 }
 
 inline Context & exception::context() const {

From f7c08b4b03445feff459584289c8ff272a2e48cd Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 21:46:24 +0000
Subject: [PATCH 139/185] Add test for memory leanks on jobs not run.

Co-authored-by: ftk <ftk@users.noreply.github.com>
---
 test/jobs.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/jobs.cpp b/test/jobs.cpp
index e6ed94ad48..b462d68f03 100644
--- a/test/jobs.cpp
+++ b/test/jobs.cpp
@@ -40,6 +40,9 @@ int main()
     } catch (qjs::exception const & exc) {
         assert(&exc.context() == &context && "Exception should contain context information");
     }
-
+    // Check that not executed jobs won't introduce memory leaks
+    context.enqueueJob([](){
+        assert(false && "This job will not be called");
+    });
     return 0;
 }

From f0dc1c108de01e46e50789eb4097b4488b013356 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 16:54:40 +0000
Subject: [PATCH 140/185] Add unhandled promise patch for quickjs

---
 quickjs/patches/unhandled_rejection.patch | 72 +++++++++++++++++++++++
 quickjs/quickjs.c                         | 21 +++++++
 quickjs/quickjs.h                         |  1 +
 3 files changed, 94 insertions(+)
 create mode 100644 quickjs/patches/unhandled_rejection.patch

diff --git a/quickjs/patches/unhandled_rejection.patch b/quickjs/patches/unhandled_rejection.patch
new file mode 100644
index 0000000000..45ae58da9d
--- /dev/null
+++ b/quickjs/patches/unhandled_rejection.patch
@@ -0,0 +1,72 @@
+diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
+index 8afc4ca..c3f98e2 100644
+--- a/quickjs/quickjs.c
++++ b/quickjs/quickjs.c
+@@ -282,6 +282,9 @@ struct JSRuntime {
+ 
+     JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
+     void *host_promise_rejection_tracker_opaque;
++
++    JSHostPromiseRejectionTracker *host_unhandled_promise_rejection_tracker;
++    void *host_unhandled_promise_rejection_tracker_opaque;
+     
+     struct list_head job_list; /* list of JSJobEntry.link */
+ 
+@@ -46255,6 +46258,7 @@ typedef struct JSPromiseData {
+     struct list_head promise_reactions[2];
+     BOOL is_handled; /* Note: only useful to debug */
+     JSValue promise_result;
++    JSContext * ctx;
+ } JSPromiseData;
+ 
+ typedef struct JSPromiseFunctionDataResolved {
+@@ -46335,6 +46339,14 @@ void JS_SetHostPromiseRejectionTracker(JSRuntime *rt,
+     rt->host_promise_rejection_tracker_opaque = opaque;
+ }
+ 
++void JS_SetHostUnhandledPromiseRejectionTracker(JSRuntime *rt,
++                                       JSHostPromiseRejectionTracker *cb,
++                                       void *opaque)
++{
++    rt->host_unhandled_promise_rejection_tracker = cb;
++    rt->host_unhandled_promise_rejection_tracker_opaque = opaque;
++}
++
+ static void fulfill_or_reject_promise(JSContext *ctx, JSValueConst promise,
+                                       JSValueConst value, BOOL is_reject)
+ {
+@@ -46539,6 +46551,14 @@ static void js_promise_finalizer(JSRuntime *rt, JSValue val)
+ 
+     if (!s)
+         return;
++
++    if (s->promise_state == JS_PROMISE_REJECTED && !s->is_handled) {
++        if (rt->host_unhandled_promise_rejection_tracker) {
++            rt->host_unhandled_promise_rejection_tracker(s->ctx, val, s->promise_result, FALSE,
++                                                         rt->host_unhandled_promise_rejection_tracker_opaque);
++        }
++    }
++
+     for(i = 0; i < 2; i++) {
+         list_for_each_safe(el, el1, &s->promise_reactions[i]) {
+             JSPromiseReactionData *rd =
+@@ -46589,6 +46609,7 @@ static JSValue js_promise_constructor(JSContext *ctx, JSValueConst new_target,
+     s = js_mallocz(ctx, sizeof(*s));
+     if (!s)
+         goto fail;
++    s->ctx = ctx;
+     s->promise_state = JS_PROMISE_PENDING;
+     s->is_handled = FALSE;
+     for(i = 0; i < 2; i++)
+diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
+index 0540191..215e7b2 100644
+--- a/quickjs/quickjs.h
++++ b/quickjs/quickjs.h
+@@ -839,6 +839,7 @@ typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
+                                            JSValueConst reason,
+                                            JS_BOOL is_handled, void *opaque);
+ void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
++void JS_SetHostUnhandledPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
+ 
+ /* return != 0 if the JS code needs to be interrupted */
+ typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 8afc4caa13..c3f98e2e06 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -282,6 +282,9 @@ struct JSRuntime {
 
     JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
     void *host_promise_rejection_tracker_opaque;
+
+    JSHostPromiseRejectionTracker *host_unhandled_promise_rejection_tracker;
+    void *host_unhandled_promise_rejection_tracker_opaque;
     
     struct list_head job_list; /* list of JSJobEntry.link */
 
@@ -46255,6 +46258,7 @@ typedef struct JSPromiseData {
     struct list_head promise_reactions[2];
     BOOL is_handled; /* Note: only useful to debug */
     JSValue promise_result;
+    JSContext * ctx;
 } JSPromiseData;
 
 typedef struct JSPromiseFunctionDataResolved {
@@ -46335,6 +46339,14 @@ void JS_SetHostPromiseRejectionTracker(JSRuntime *rt,
     rt->host_promise_rejection_tracker_opaque = opaque;
 }
 
+void JS_SetHostUnhandledPromiseRejectionTracker(JSRuntime *rt,
+                                       JSHostPromiseRejectionTracker *cb,
+                                       void *opaque)
+{
+    rt->host_unhandled_promise_rejection_tracker = cb;
+    rt->host_unhandled_promise_rejection_tracker_opaque = opaque;
+}
+
 static void fulfill_or_reject_promise(JSContext *ctx, JSValueConst promise,
                                       JSValueConst value, BOOL is_reject)
 {
@@ -46539,6 +46551,14 @@ static void js_promise_finalizer(JSRuntime *rt, JSValue val)
 
     if (!s)
         return;
+
+    if (s->promise_state == JS_PROMISE_REJECTED && !s->is_handled) {
+        if (rt->host_unhandled_promise_rejection_tracker) {
+            rt->host_unhandled_promise_rejection_tracker(s->ctx, val, s->promise_result, FALSE,
+                                                         rt->host_unhandled_promise_rejection_tracker_opaque);
+        }
+    }
+
     for(i = 0; i < 2; i++) {
         list_for_each_safe(el, el1, &s->promise_reactions[i]) {
             JSPromiseReactionData *rd =
@@ -46589,6 +46609,7 @@ static JSValue js_promise_constructor(JSContext *ctx, JSValueConst new_target,
     s = js_mallocz(ctx, sizeof(*s));
     if (!s)
         goto fail;
+    s->ctx = ctx;
     s->promise_state = JS_PROMISE_PENDING;
     s->is_handled = FALSE;
     for(i = 0; i < 2; i++)
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 054019147e..215e7b2fc9 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -839,6 +839,7 @@ typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
                                            JSValueConst reason,
                                            JS_BOOL is_handled, void *opaque);
 void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
+void JS_SetHostUnhandledPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
 
 /* return != 0 if the JS code needs to be interrupted */
 typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);

From f707fed1497ada8375db9cdeff7286beb00daad6 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Mon, 22 Nov 2021 17:53:42 +0000
Subject: [PATCH 141/185] Add unhandled promise rejection support

---
 quickjspp.hpp                | 17 ++++++++
 test/CMakeLists.txt          |  2 +-
 test/unhandled_rejection.cpp | 79 ++++++++++++++++++++++++++++++++++++
 3 files changed, 97 insertions(+), 1 deletion(-)
 create mode 100644 test/unhandled_rejection.cpp

diff --git a/quickjspp.hpp b/quickjspp.hpp
index ec2931193d..770c83a80c 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1355,6 +1355,8 @@ class Runtime
         rt = JS_NewRuntime();
         if(!rt)
             throw std::runtime_error{"qjs: Cannot create runtime"};
+        
+        JS_SetHostUnhandledPromiseRejectionTracker(rt, promise_unhandled_rejection_tracker, NULL);
     }
 
     // noncopyable
@@ -1371,6 +1373,10 @@ class Runtime
     bool isJobPending() const {
         return JS_IsJobPending(rt);
     }
+
+private:
+    static void promise_unhandled_rejection_tracker(JSContext *ctx, JSValueConst promise,
+                                                    JSValueConst reason, JS_BOOL is_handled, void *opaque);
 };
 
 /** Wrapper over JSContext * ctx
@@ -1598,6 +1604,8 @@ class Context
         JS_FreeContext(ctx);
     }
 
+    std::function<void(Value)> onUnhandledPromiseRejection;
+
     template <typename Function>
     void enqueueJob(Function && job);
 
@@ -1921,6 +1929,15 @@ inline Context & exception::context() const {
     return Context::get(ctx);
 }
 
+inline void Runtime::promise_unhandled_rejection_tracker(JSContext *ctx, JSValueConst promise,
+                                                         JSValueConst reason, JS_BOOL is_handled, void *opaque)
+{
+    auto & context = Context::get(ctx);
+    if (context.onUnhandledPromiseRejection) {
+        context.onUnhandledPromiseRejection(context.newValue(JS_DupValue(ctx, reason)));
+    }
+}
+
 inline Context * Runtime::executePendingJob() {
     JSContext * ctx;
     auto err = JS_ExecutePendingJob(rt, &ctx);
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 4b9f36799d..4a850d4daf 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -9,7 +9,7 @@ target_link_libraries(${name}-checkjsv quickjspp)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant function_call inheritance jobs
+        value class exception example multicontext conversions point variant function_call inheritance jobs unhandled_rejection
         )
 make_test(${test})
 endforeach()
diff --git a/test/unhandled_rejection.cpp b/test/unhandled_rejection.cpp
new file mode 100644
index 0000000000..5ff9e85ec7
--- /dev/null
+++ b/test/unhandled_rejection.cpp
@@ -0,0 +1,79 @@
+#include "quickjspp.hpp"
+#include <iostream>
+#include <stdexcept>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    
+    context.global().add("nextTick", [&context](std::function<void()> f) {
+        context.enqueueJob(std::move(f));
+    });
+
+    bool called = false;
+    context.onUnhandledPromiseRejection = [&called](qjs::Value reason) {
+        called = true;
+    };
+
+    // Catch the rejection
+    called = false;
+    context.eval(R"xxx(
+        (() => {
+            const p = new Promise((resolve, reject) => {
+                nextTick(() => {
+                    reject(123);
+                })
+            });
+            p.catch(() => {/* no-op */});
+        })();
+    )xxx");
+
+    while (runtime.isJobPending()) {
+        runtime.executePendingJob();
+    }
+
+    assert(!called && "Unhandled Promise rejection should not have been called");
+
+    // Catch the rejection, but only one *after* it happens.
+    called = false;
+    context.eval(R"xxx(
+        (() => {
+            const p = new Promise((resolve, reject) => {
+                reject(123);
+                nextTick(() => {
+                    p.catch(() => {/* no-op */});
+                });
+            });
+        })();
+    )xxx");
+
+    while (runtime.isJobPending()) {
+        runtime.executePendingJob();
+    }
+
+    assert(!called && "Unhandled Promise rejection should not have been called");
+
+    // Do not catch the rejection
+    called = false;
+    context.eval(R"xxx(
+        (() => {
+            const p = new Promise((resolve, reject) => {
+                reject(123);
+                nextTick(() => {
+                    p.then(() => {/* no-op */})
+                });
+            });
+        })();
+    )xxx");
+
+    assert(!called && "Unhandled Promise rejection should not have been called yet");
+
+    while (runtime.isJobPending()) {
+        runtime.executePendingJob();
+    }
+
+    assert(called && "Unhandled Promise rejection should have been called");
+
+    return 0;
+}

From 52e2acd00acfbb2c98217e28e7c7b0204da3fdf6 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Tue, 23 Nov 2021 12:53:49 +0000
Subject: [PATCH 142/185] Add doc description to the callback

---
 quickjspp.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 770c83a80c..1ba9a9fab7 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1604,6 +1604,7 @@ class Context
         JS_FreeContext(ctx);
     }
 
+    /** Callback triggered when a Promise rejection won't ever be handled */
     std::function<void(Value)> onUnhandledPromiseRejection;
 
     template <typename Function>

From ea893d8f0c104f37175d1ef9333d1b27e707fa72 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 15:38:05 +0300
Subject: [PATCH 143/185] qjs::exception::get

---
 quickjspp.hpp         | 14 +++++++++++---
 test/multicontext.cpp |  8 ++++----
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1ba9a9fab7..9475fc1984 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -29,6 +29,7 @@
 namespace qjs {
 
 class Context;
+class Value;
 
 /** Exception type.
  * Indicates that exception has occured in JS context.
@@ -38,6 +39,9 @@ class exception {
 public:
     exception(JSContext * ctx) : ctx(ctx) {}
     Context & context() const;
+
+    /// Clears and returns the occurred exception.
+    Value get();
 };
 
 /** Javascript conversion traits.
@@ -1109,7 +1113,6 @@ struct js_property_traits<uint32_t>
     }
 };
 
-class Value;
 
 namespace detail {
 template <typename Key>
@@ -1355,7 +1358,7 @@ class Runtime
         rt = JS_NewRuntime();
         if(!rt)
             throw std::runtime_error{"qjs: Cannot create runtime"};
-        
+
         JS_SetHostUnhandledPromiseRejectionTracker(rt, promise_unhandled_rejection_tracker, NULL);
     }
 
@@ -1627,7 +1630,7 @@ class Context
     template <typename T>
     Value newValue(T&& val) { return Value{ctx, std::forward<T>(val)}; }
 
-    /** returns current exception associated with context, and resets it. Should be called when qjs::exception is caught */
+    /** returns current exception associated with context and clears it. Should be called when qjs::exception is caught */
     Value getException() { return Value{ctx, JS_GetException(ctx)}; }
 
     /** Register class T for conversions to/from std::shared_ptr<T> to work.
@@ -1930,6 +1933,10 @@ inline Context & exception::context() const {
     return Context::get(ctx);
 }
 
+inline Value exception::get() {
+    return context().getException();
+}
+
 inline void Runtime::promise_unhandled_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                                          JSValueConst reason, JS_BOOL is_handled, void *opaque)
 {
@@ -1939,6 +1946,7 @@ inline void Runtime::promise_unhandled_rejection_tracker(JSContext *ctx, JSValue
     }
 }
 
+
 inline Context * Runtime::executePendingJob() {
     JSContext * ctx;
     auto err = JS_ExecutePendingJob(rt, &ctx);
diff --git a/test/multicontext.cpp b/test/multicontext.cpp
index c0d65c693f..de1cfa8af4 100644
--- a/test/multicontext.cpp
+++ b/test/multicontext.cpp
@@ -35,9 +35,9 @@ int main()
                      , "<eval>", JS_EVAL_TYPE_MODULE
         );
     }
-    catch(qjs::exception)
+    catch(qjs::exception e)
     {
-        auto exc = context1.getException();
+        auto exc = e.get();
         std::cerr << (std::string) exc << std::endl;
         if((bool) exc["stack"])
             std::cerr << (std::string) exc["stack"] << std::endl;
@@ -51,9 +51,9 @@ int main()
                       ,"<eval>", JS_EVAL_TYPE_MODULE
         );
     }
-    catch(qjs::exception)
+    catch(qjs::exception e)
     {
-        auto exc = context2.getException();
+        auto exc = e.get();
         std::cerr << (std::string) exc << std::endl;
         if((bool) exc["stack"])
             std::cerr << (std::string) exc["stack"] << std::endl;

From 36d39e14414838aafefec866df0af186bf229145 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 16:21:24 +0300
Subject: [PATCH 144/185] accept only rv JSValue

---
 quickjspp.hpp | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 9475fc1984..194d04e767 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -74,7 +74,7 @@ struct js_traits<JSValue>
         return JS_DupValue(ctx, v);
     }
 
-    static JSValue wrap(JSContext * ctx, JSValue v) noexcept
+    static JSValue wrap(JSContext * ctx, JSValue&& v) noexcept
     {
         return v;
     }
@@ -1192,6 +1192,8 @@ class Value
             throw exception{ctx};
     }
 
+    Value(JSValue&& v) : v(std::move(v)), ctx(nullptr) {}
+
     Value(const Value& rhs)
     {
         ctx = rhs.ctx;
@@ -1334,13 +1336,12 @@ class Value
     }
 
     std::string
-    toJSON(const Value& replacer = Value{nullptr, JS_UNDEFINED}, const Value& space = Value{nullptr, JS_UNDEFINED})
+    toJSON(const Value& replacer = JS_UNDEFINED, const Value& space = JS_UNDEFINED)
     {
         assert(ctx);
         assert(!replacer.ctx || ctx == replacer.ctx);
         assert(!space.ctx || ctx == space.ctx);
-        JSValue json = JS_JSONStringify(ctx, v, replacer.v, space.v);
-        return (std::string) Value{ctx, json};
+        return (std::string) Value{ctx, JS_JSONStringify(ctx, v, replacer.v, space.v)};
     }
 
 };
@@ -1423,18 +1424,18 @@ class Context
                 throw exception{ctx};
         }
 
-        Module& add(const char * name, JSValue value)
+        Module& add(const char * name, JSValue&& value)
         {
-            exports.push_back({name, {ctx, value}});
+            exports.push_back({name, {ctx, std::move(value)}});
             JS_AddModuleExport(ctx, m, name);
             return *this;
         }
 
 
         template <typename T>
-        Module& add(const char * name, T value)
+        Module& add(const char * name, T&& value)
         {
-            return add(name, js_traits<T>::wrap(ctx, std::move(value)));
+            return add(name, js_traits<T>::wrap(ctx, std::forward<T>(value)));
         }
 
         Module(const Module&) = delete;
@@ -1645,29 +1646,30 @@ class Context
         js_traits<std::shared_ptr<T>>::register_class(ctx, name, proto);
     }
 
-    Value eval(std::string_view buffer, const char * filename = "<eval>", unsigned eval_flags = 0)
+    /// @see JS_Eval
+    Value eval(std::string_view buffer, const char * filename = "<eval>", int flags = 0)
     {
         assert(buffer.data()[buffer.size()] == '\0' && "eval buffer is not null-terminated"); // JS_Eval requirement
-        JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, eval_flags);
-        return Value{ctx, v};
+        JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, flags);
+        return Value{ctx, std::move(v)};
     }
 
-    Value evalFile(const char * filename, unsigned eval_flags = 0)
+    Value evalFile(const char * filename, int flags = 0)
     {
         size_t buf_len;
         auto deleter = [this](void * p) { js_free(ctx, p); };
         auto buf = std::unique_ptr<uint8_t, decltype(deleter)>{js_load_file(ctx, &buf_len, filename), deleter};
         if(!buf)
             throw std::runtime_error{std::string{"evalFile: can't read file: "} + filename};
-        return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, eval_flags);
+        return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, flags);
     }
 
-    Value fromJSON(std::string_view buffer, const char * filename = "<fromJSON>")
+    /// @see JS_ParseJSON2
+    Value fromJSON(std::string_view buffer, const char * filename = "<fromJSON>", int flags = 0)
     {
         assert(buffer.data()[buffer.size()] == '\0' &&
                "fromJSON buffer is not null-terminated"); // JS_ParseJSON requirement
-        JSValue v = JS_ParseJSON(ctx, buffer.data(), buffer.size(), filename);
-        return Value{ctx, v};
+        return Value{ctx, JS_ParseJSON2(ctx, buffer.data(), buffer.size(), filename, flags)};
     }
 
     /** Get qjs::Context from JSContext opaque pointer */

From 83b2eb80777445b8bc41bc9b3a3e061df3b28e69 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 17:51:14 +0300
Subject: [PATCH 145/185] allow to chain property access

---
 quickjspp.hpp  | 23 +++++++++++++++++++----
 test/value.cpp | 21 +++++++++++++++++++++
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 194d04e767..de267544a1 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1113,6 +1113,9 @@ struct js_property_traits<uint32_t>
     }
 };
 
+template <>
+struct js_property_traits<int> : js_property_traits<uint32_t> {};
+
 
 namespace detail {
 template <typename Key>
@@ -1136,13 +1139,24 @@ struct property_proxy
     /** Implicit converion to qjs::Value */
     operator Value() const; // defined later due to Value being incomplete type
 
-    template <typename Value>
-    property_proxy& operator =(Value value)
+    /// noncopyable
+    property_proxy& operator =(property_proxy) = delete;
+
+    template <typename T>
+    property_proxy& operator =(T&& value)
     {
         js_property_traits<Key>::set_property(ctx, this_obj, key,
-                                              js_traits<Value>::wrap(ctx, std::move(value)));
+                                              js_traits<std::decay_t<T>>::wrap(ctx, std::forward<T>(value)));
         return *this;
     }
+
+    template <typename Key2>
+    property_proxy<Key2> operator[](Key2 key2) const
+    {
+        return {ctx, as<JSValue>(), std::move(key2)};
+    }
+
+    ~property_proxy() noexcept { JS_FreeValue(ctx, this_obj); }
 };
 
 
@@ -1262,7 +1276,8 @@ class Value
     template <typename Key>
     detail::property_proxy<Key> operator [](Key key)
     {
-        return {ctx, v, std::move(key)};
+        assert(ctx && "Trying to access properties of Value with no JSContext");
+        return {ctx, JS_DupValue(ctx, v), std::move(key)};
     }
 
 
diff --git a/test/value.cpp b/test/value.cpp
index 01ca7e5fc9..92b3c342de 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -54,6 +54,27 @@ int main()
 
         qjs::Value one = val1["a"];
         assert((int)one == 1);
+
+        assert(val1.toJSON() == val2.toJSON());
+
+        val1["b"] = context.newObject();
+        val1["b"][2] = 2;
+        assert((int)val1["b"][2] == 2);
+
+        assert(val1.toJSON() == context.fromJSON(val1.toJSON(JS_UNDEFINED, context.newValue("\t"))).toJSON());
+
+        assert(val1.toJSON() == "{\"a\":\"1\",\"b\":{\"2\":2}}");
+
+        assert(val1 == context.global()["val1"]);
+
+        auto str = val1.toJSON();
+        assert(str == (std::string) context.eval(R"xxx(
+        val1 = new Object();
+        val1["a"] = "1";
+        val1["b"] = new Object();
+        val1["b"][2] = 2;
+        JSON.stringify(val1)
+        )xxx"));
     }
     catch(qjs::exception)
     {

From b18e649912cf670e56cd5abaf451830402515d58 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 18:34:37 +0300
Subject: [PATCH 146/185] don't define traits for uint64_t

---
 quickjspp.hpp        | 4 ++--
 test/conversions.cpp | 2 --
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index de267544a1..cb5f2a26c5 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -81,11 +81,11 @@ struct js_traits<JSValue>
 };
 
 /** Conversion traits for integers.
+ * Intentionally doesn't define traits for uint64_t since it can be typedefed to JSValue. (@see JS_NAN_BOXING)
  */
 template <typename Int>
-struct js_traits<Int, std::enable_if_t<std::is_integral_v<Int> && sizeof(Int) <= sizeof(int64_t)>>
+struct js_traits<Int, std::enable_if_t<std::is_integral_v<Int> && sizeof(Int) <= sizeof(int64_t) && !std::is_same_v<Int, uint64_t>>>
 {
-
     /// @throws exception
     static Int unwrap(JSContext * ctx, JSValueConst v)
     {
diff --git a/test/conversions.cpp b/test/conversions.cpp
index b5af948bd4..0b2c782f98 100644
--- a/test/conversions.cpp
+++ b/test/conversions.cpp
@@ -46,8 +46,6 @@ int main()
         test_conv<int64_t>(context, -(1ll << 52) + 1);
         test_conv<int64_t>(context, (1ll << 52));
         test_conv<int64_t>(context, (1ll << 52) - 1);
-        test_conv<uint64_t>(context, (1ll << 52));
-        test_conv<uint64_t>(context, (1ll << 52) - 1);
 
 
         test_num<double>(context);

From 1115544ccd53653a77dd2307ea6a1d81d1881707 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 18:34:51 +0300
Subject: [PATCH 147/185] update valgrind CI

---
 .github/workflows/valgrind.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/valgrind.yml b/.github/workflows/valgrind.yml
index e73f43a4e3..7589b281d7 100644
--- a/.github/workflows/valgrind.yml
+++ b/.github/workflows/valgrind.yml
@@ -20,3 +20,4 @@ jobs:
         working-directory: build_dir
       - name: logs
         run: cat build_dir/Testing/Temporary/MemoryChecker.*.log
+        if: always()

From 06a1d70b603a08e57a9a848d7658b81b33746ee2 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 23 Nov 2021 19:01:22 +0300
Subject: [PATCH 148/185] fix uninitialized read in JS_GetPropertyValue

---
 .../getpropertyvalue_uninitialized_read_fix.patch   | 13 +++++++++++++
 quickjs/quickjs.c                                   |  2 ++
 2 files changed, 15 insertions(+)
 create mode 100644 quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch

diff --git a/quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch b/quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch
new file mode 100644
index 0000000000..559a1ae8fd
--- /dev/null
+++ b/quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch
@@ -0,0 +1,13 @@
+diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
+index c3f98e2e0..3b59284e6 100644
+--- a/quickjs/quickjs.c
++++ b/quickjs/quickjs.c
+@@ -7858,6 +7858,8 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
+         uint32_t idx, len;
+         /* fast path for array access */
+         p = JS_VALUE_GET_OBJ(this_obj);
++        if (unlikely(!p->fast_array))
++            goto slow_path;
+         idx = JS_VALUE_GET_INT(prop);
+         len = (uint32_t)p->u.array.count;
+         if (unlikely(idx >= len))
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index c3f98e2e06..3b59284e6e 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -7858,6 +7858,8 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
         uint32_t idx, len;
         /* fast path for array access */
         p = JS_VALUE_GET_OBJ(this_obj);
+        if (unlikely(!p->fast_array))
+            goto slow_path;
         idx = JS_VALUE_GET_INT(prop);
         len = (uint32_t)p->u.array.count;
         if (unlikely(idx >= len))

From 54b6fb3d44490ec28994d59defaa872308a06ce7 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 00:19:26 +0000
Subject: [PATCH 149/185] Remove dependency on quickjs-libc

---
 qjs.cpp        |  2 +-
 quickjspp.hpp  | 20 +++++++++++++-------
 test/class.cpp |  1 +
 3 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/qjs.cpp b/qjs.cpp
index 9fec3e2c08..a9251e8768 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -1,5 +1,5 @@
 #include "quickjspp.hpp"
-
+#include "quickjs/quickjs-libc.h"
 
 #include <iostream>
 
diff --git a/quickjspp.hpp b/quickjspp.hpp
index cb5f2a26c5..a0f8389a24 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "quickjs/quickjs.h"
-#include "quickjs/quickjs-libc.h"
 
 #include <vector>
 #include <string_view>
@@ -17,6 +16,9 @@
 #include <optional>
 #include <type_traits>
 #include <unordered_map>
+#include <fstream>
+#include <ios>
+#include <sstream>
 
 
 #if defined(__cpp_rtti)
@@ -1671,12 +1673,7 @@ class Context
 
     Value evalFile(const char * filename, int flags = 0)
     {
-        size_t buf_len;
-        auto deleter = [this](void * p) { js_free(ctx, p); };
-        auto buf = std::unique_ptr<uint8_t, decltype(deleter)>{js_load_file(ctx, &buf_len, filename), deleter};
-        if(!buf)
-            throw std::runtime_error{std::string{"evalFile: can't read file: "} + filename};
-        return eval({reinterpret_cast<char *>(buf.get()), buf_len}, filename, flags);
+        return eval(load_file(filename), filename, flags);
     }
 
     /// @see JS_ParseJSON2
@@ -1694,6 +1691,15 @@ class Context
         assert(ptr);
         return *static_cast<Context *>(ptr);
     }
+
+private:
+    static std::string load_file(const char * filename)
+    {
+        std::ifstream f(filename, std::ios::in | std::ios::binary);
+        std::stringstream sstream;
+        sstream << f.rdbuf();
+        return sstream.str();
+    }
 };
 
 /** Conversion traits for Value.
diff --git a/test/class.cpp b/test/class.cpp
index 94cb1ea8ed..2b68a9d588 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -1,4 +1,5 @@
 #include "quickjspp.hpp"
+#include "quickjs/quickjs-libc.h"
 #include <iostream>
 
 

From eeb2bcec3808879e8fc246904938dc48abe96a23 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 00:26:13 +0000
Subject: [PATCH 150/185] Expose module loader API

---
 quickjspp.hpp          | 66 ++++++++++++++++++++++++++++++++++++++++--
 test/CMakeLists.txt    |  2 +-
 test/module_loader.cpp | 53 +++++++++++++++++++++++++++++++++
 3 files changed, 117 insertions(+), 4 deletions(-)
 create mode 100644 test/module_loader.cpp

diff --git a/quickjspp.hpp b/quickjspp.hpp
index a0f8389a24..b20b757032 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1378,6 +1378,7 @@ class Runtime
             throw std::runtime_error{"qjs: Cannot create runtime"};
 
         JS_SetHostUnhandledPromiseRejectionTracker(rt, promise_unhandled_rejection_tracker, NULL);
+        JS_SetModuleLoaderFunc(rt, nullptr, module_loader, nullptr);
     }
 
     // noncopyable
@@ -1398,6 +1399,9 @@ class Runtime
 private:
     static void promise_unhandled_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                                     JSValueConst reason, JS_BOOL is_handled, void *opaque);
+
+    static JSModuleDef *module_loader(JSContext *ctx,
+                                      const char *module_name, void *opaque);
 };
 
 /** Wrapper over JSContext * ctx
@@ -1628,6 +1632,20 @@ class Context
     /** Callback triggered when a Promise rejection won't ever be handled */
     std::function<void(Value)> onUnhandledPromiseRejection;
 
+    /** Data type returned by the moduleLoader function */
+    struct ModuleData {
+        std::string source, url;
+        ModuleData(std::string source, std::string url = "")
+          : source(std::move(source)), url(std::move(url))
+        {}
+    };
+    using ModuleDataOpt = std::optional<ModuleData>;
+
+    /** Function called to obtain the source of a nodule */
+    std::function<ModuleDataOpt(char const *)> moduleLoader = [](char const * filename){
+        return readFile(filename);
+    };
+
     template <typename Function>
     void enqueueJob(Function && job);
 
@@ -1673,7 +1691,7 @@ class Context
 
     Value evalFile(const char * filename, int flags = 0)
     {
-        return eval(load_file(filename), filename, flags);
+        return eval(readFile(filename), filename, flags);
     }
 
     /// @see JS_ParseJSON2
@@ -1692,8 +1710,7 @@ class Context
         return *static_cast<Context *>(ptr);
     }
 
-private:
-    static std::string load_file(const char * filename)
+    static std::string readFile(const char * filename)
     {
         std::ifstream f(filename, std::ios::in | std::ios::binary);
         std::stringstream sstream;
@@ -1969,6 +1986,49 @@ inline void Runtime::promise_unhandled_rejection_tracker(JSContext *ctx, JSValue
     }
 }
 
+inline JSModuleDef * Runtime::module_loader(JSContext *ctx,
+                                            const char *module_name, void *opaque)
+{
+    Context::ModuleDataOpt data = std::nullopt;
+    auto & context = Context::get(ctx);
+
+    try {
+        if (context.moduleLoader) data = context.moduleLoader(module_name);
+
+        if (!data) {
+            JS_ThrowReferenceError(ctx, "could not load module filename '%s'", module_name);
+            return NULL;
+        }
+
+        if (data->url == "") data->url = module_name;
+
+        // compile the module
+        auto func_val = context.eval(data->source, module_name, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+        JSModuleDef * m = (JSModuleDef *)JS_VALUE_GET_PTR(func_val.v);
+
+        // set import.meta
+        auto meta = context.newValue(JS_GetImportMeta(ctx, m));
+        meta["url"] = data->url;
+        meta["main"] = false;
+
+        return m;
+    }
+    catch(exception)
+    {
+        return NULL;
+    }
+    catch (std::exception const & err)
+    {
+        JS_ThrowInternalError(ctx, "%s", err.what());
+        return NULL;
+    }
+    catch (...)
+    {
+        JS_ThrowInternalError(ctx, "Unknown error");
+        return NULL;
+    }
+}
+
 
 inline Context * Runtime::executePendingJob() {
     JSContext * ctx;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 4a850d4daf..575f1e9588 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -9,7 +9,7 @@ target_link_libraries(${name}-checkjsv quickjspp)
 endmacro()
 
 foreach(test
-        value class exception example multicontext conversions point variant function_call inheritance jobs unhandled_rejection
+        value class exception example multicontext conversions point variant function_call inheritance jobs unhandled_rejection module_loader
         )
 make_test(${test})
 endforeach()
diff --git a/test/module_loader.cpp b/test/module_loader.cpp
new file mode 100644
index 0000000000..2bbc11a76d
--- /dev/null
+++ b/test/module_loader.cpp
@@ -0,0 +1,53 @@
+#include "quickjspp.hpp"
+#include <iostream>
+
+int main()
+{
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+
+    auto simple_module_loader = [](char const * filename) -> qjs::Context::ModuleDataOpt {
+        if (filename == std::string_view("some_module.js")) {
+            return qjs::Context::ModuleData{R"xxx(
+                import "folder/file1.js"
+                log(import.meta.url);
+            )xxx"};
+        }
+        if (filename == std::string_view("folder/file1.js")) {
+            return qjs::Context::ModuleData{R"xxx(
+                import "./file2.js"
+                log(import.meta.url);
+            )xxx"};
+        }
+        if (filename == std::string_view("folder/file2.js")) {
+            return qjs::Context::ModuleData{R"xxx(
+                log(import.meta.url);
+            )xxx"};
+        }
+        return std::nullopt;
+    };
+
+    context.moduleLoader = simple_module_loader;
+    context.global().add("log", [](std::string_view s) {
+        std::cout << s << std::endl;
+    });
+
+    context.eval(R"xxx(
+        import "./some_module.js";
+    )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+
+    try {
+        context.eval(R"xxx(
+            import "./invalid_module.js";
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+        assert(false && "module import should have failed");
+    }
+    catch(qjs::exception e)
+    {
+        auto exc = e.get();
+        assert(exc.isError() && "Exception should be a JS error");
+        assert((std::string)exc == "ReferenceError: could not load module filename 'invalid_module.js'");
+    }
+
+    return 0;
+}

From 8fd55b62955ca617e4e7594f297f0826bef8d2fb Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 09:09:39 +0000
Subject: [PATCH 151/185] Simplify writing a moduleLoader function. Expand test
 cases.

---
 quickjspp.hpp          | 25 +++++++++++++++----------
 test/module_loader.cpp | 32 +++++++++++++++++++++++---------
 2 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index b20b757032..d95cae53d7 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1634,16 +1634,21 @@ class Context
 
     /** Data type returned by the moduleLoader function */
     struct ModuleData {
-        std::string source, url;
-        ModuleData(std::string source, std::string url = "")
+        std::optional<std::string> source, url;
+        ModuleData()
+          : source(std::nullopt), url(std::nullopt)
+        {}
+        ModuleData(std::string source)
+          : source(std::move(source)), url(std::nullopt)
+        {}
+        ModuleData(std::string url, std::string source)
           : source(std::move(source)), url(std::move(url))
         {}
     };
-    using ModuleDataOpt = std::optional<ModuleData>;
 
     /** Function called to obtain the source of a nodule */
-    std::function<ModuleDataOpt(char const *)> moduleLoader = [](char const * filename){
-        return readFile(filename);
+    std::function<ModuleData(std::string_view)> moduleLoader = [](std::string_view filename){
+        return readFile(filename.data());
     };
 
     template <typename Function>
@@ -1989,26 +1994,26 @@ inline void Runtime::promise_unhandled_rejection_tracker(JSContext *ctx, JSValue
 inline JSModuleDef * Runtime::module_loader(JSContext *ctx,
                                             const char *module_name, void *opaque)
 {
-    Context::ModuleDataOpt data = std::nullopt;
+    Context::ModuleData data;
     auto & context = Context::get(ctx);
 
     try {
         if (context.moduleLoader) data = context.moduleLoader(module_name);
 
-        if (!data) {
+        if (!data.source) {
             JS_ThrowReferenceError(ctx, "could not load module filename '%s'", module_name);
             return NULL;
         }
 
-        if (data->url == "") data->url = module_name;
+        if (!data.url) data.url = module_name;
 
         // compile the module
-        auto func_val = context.eval(data->source, module_name, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+        auto func_val = context.eval(*data.source, data.url->c_str(), JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
         JSModuleDef * m = (JSModuleDef *)JS_VALUE_GET_PTR(func_val.v);
 
         // set import.meta
         auto meta = context.newValue(JS_GetImportMeta(ctx, m));
-        meta["url"] = data->url;
+        meta["url"] = *data.url;
         meta["main"] = false;
 
         return m;
diff --git a/test/module_loader.cpp b/test/module_loader.cpp
index 2bbc11a76d..872d7a031b 100644
--- a/test/module_loader.cpp
+++ b/test/module_loader.cpp
@@ -1,30 +1,43 @@
 #include "quickjspp.hpp"
 #include <iostream>
+#include <string_view>
 
 int main()
 {
     qjs::Runtime runtime;
     qjs::Context context(runtime);
 
-    auto simple_module_loader = [](char const * filename) -> qjs::Context::ModuleDataOpt {
-        if (filename == std::string_view("some_module.js")) {
-            return qjs::Context::ModuleData{R"xxx(
+    auto simple_module_loader = [](std::string_view filename) -> qjs::Context::ModuleData {
+        if (filename == "some_module.js") {
+            return {R"xxx(
                 import "folder/file1.js"
                 log(import.meta.url);
             )xxx"};
         }
-        if (filename == std::string_view("folder/file1.js")) {
-            return qjs::Context::ModuleData{R"xxx(
+        if (filename == "folder/file1.js") {
+            return {R"xxx(
                 import "./file2.js"
                 log(import.meta.url);
             )xxx"};
         }
-        if (filename == std::string_view("folder/file2.js")) {
-            return qjs::Context::ModuleData{R"xxx(
+        if (filename == "folder/file2.js") {
+            return {R"xxx(
+                import "http://localhost/script1.js";
                 log(import.meta.url);
             )xxx"};
         }
-        return std::nullopt;
+        if (filename == "http://localhost/script1.js") {
+            return {R"xxx(
+                import "./script2.js";
+                log(import.meta.url);
+            )xxx"};
+        }
+        if (filename == "http://localhost/script2.js") {
+            return {R"xxx(
+                log(import.meta.url);
+            )xxx"};
+        }
+        return {};
     };
 
     context.moduleLoader = simple_module_loader;
@@ -36,7 +49,8 @@ int main()
         import "./some_module.js";
     )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
 
-    try {
+    try
+    {
         context.eval(R"xxx(
             import "./invalid_module.js";
         )xxx", "<eval>", JS_EVAL_TYPE_MODULE);

From e6df68262c4e847afcd6a5a6687bcad9b7f36e2b Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 14:35:02 +0000
Subject: [PATCH 152/185] Add js_traits for functors

---
 quickjspp.hpp          | 35 ++++++++++++++++++++++++++++++++++-
 test/module_loader.cpp |  4 ++--
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d95cae53d7..9e25f3d845 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1746,7 +1746,7 @@ struct js_traits<Value>
  * @tparam Args argument types
  */
 template <typename R, typename... Args>
-struct js_traits<std::function<R(Args...)>>
+struct js_traits<std::function<R(Args...)>, int>
 {
     static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
     {
@@ -1804,6 +1804,39 @@ struct js_traits<std::function<R(Args...)>>
     }
 };
 
+namespace detail {
+
+template<typename T, typename = void>
+struct is_callable : std::is_function<T> { };
+
+template<typename T>
+struct is_callable<T, std::enable_if_t<std::is_same_v<decltype(void(&T::operator())), void>>> : std::true_type { };
+
+template<typename T>
+inline constexpr bool is_callable_v = is_callable<T>::value;
+
+}
+
+template <typename Function>
+struct js_traits<Function, std::enable_if_t<detail::is_callable_v<Function>>> {
+    static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
+    {
+        return js_traits<
+            decltype(std::function{std::declval<Function>()}),
+            int
+        >::unwrap(ctx, fun_obj);
+    }
+
+    template <typename Functor>
+    static JSValue wrap(JSContext * ctx, Functor&& functor)
+    {
+        return js_traits<
+            decltype(std::function{std::declval<Function>()}),
+            int
+        >::wrap(ctx, std::forward<Functor>(functor));
+    }
+};
+
 /** Convert from std::vector<T> to Array and vice-versa. If Array holds objects that are non-convertible to T throws qjs::exception */
 template <class T>
 struct js_traits<std::vector<T>>
diff --git a/test/module_loader.cpp b/test/module_loader.cpp
index 872d7a031b..df80cb5179 100644
--- a/test/module_loader.cpp
+++ b/test/module_loader.cpp
@@ -41,9 +41,9 @@ int main()
     };
 
     context.moduleLoader = simple_module_loader;
-    context.global().add("log", [](std::string_view s) {
+    context.global()["log"] = [](std::string_view s) {
         std::cout << s << std::endl;
-    });
+    };;
 
     context.eval(R"xxx(
         import "./some_module.js";

From a8f49288211eff164940786e57e9d49b24324331 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 17:17:19 +0000
Subject: [PATCH 153/185] Make sure the module's import.meta.url is an uri/url

---
 quickjspp.hpp          | 67 +++++++++++++++++++++++++--------------
 test/module_loader.cpp | 71 +++++++++++++++++++++++++++++-------------
 2 files changed, 92 insertions(+), 46 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d95cae53d7..77fb3e1a91 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -19,6 +19,7 @@
 #include <fstream>
 #include <ios>
 #include <sstream>
+#include <filesystem>
 
 
 #if defined(__cpp_rtti)
@@ -1404,6 +1405,33 @@ class Runtime
                                       const char *module_name, void *opaque);
 };
 
+namespace detail {
+
+inline std::optional<std::string> readFile(std::filesystem::path const & filepath)
+{
+    if (!std::filesystem::exists(filepath)) return std::nullopt;
+    std::ifstream f(filepath, std::ios::in | std::ios::binary);
+    if (!f.is_open()) return std::nullopt;
+    std::stringstream sstream;
+    sstream << f.rdbuf();
+    return sstream.str();
+}
+
+inline std::string toUri(std::string_view filename) {
+    auto fname = std::string{filename};
+    if (fname.find("://") < fname.find("/")) return fname;
+
+    auto fpath = std::filesystem::path(fname);
+    if (!fpath.is_absolute()) {
+        fpath = "." / fpath;
+    }
+    fpath = std::filesystem::weakly_canonical(fpath);
+    fname = "file://" + fpath.generic_string();
+    return fname;
+}
+
+}
+
 /** Wrapper over JSContext * ctx
  * Calls JS_SetContextOpaque(ctx, this); on construction and JS_FreeContext on destruction
  */
@@ -1635,21 +1663,16 @@ class Context
     /** Data type returned by the moduleLoader function */
     struct ModuleData {
         std::optional<std::string> source, url;
-        ModuleData()
-          : source(std::nullopt), url(std::nullopt)
-        {}
-        ModuleData(std::string source)
-          : source(std::move(source)), url(std::nullopt)
-        {}
-        ModuleData(std::string url, std::string source)
-          : source(std::move(source)), url(std::move(url))
-        {}
+        ModuleData() : source(std::nullopt), url(std::nullopt) {}
+        ModuleData(std::optional<std::string> source) : source(std::move(source)), url(std::nullopt) {}
+        ModuleData(std::optional<std::string> url, std::optional<std::string> source) : source(std::move(source)), url(std::move(url)) {}
     };
 
-    /** Function called to obtain the source of a nodule */
-    std::function<ModuleData(std::string_view)> moduleLoader = [](std::string_view filename){
-        return readFile(filename.data());
-    };
+    /** Function called to obtain the source of a module */
+    std::function<ModuleData(std::string_view)> moduleLoader =
+        [](std::string_view filename) -> ModuleData {
+            return ModuleData{ detail::toUri(filename), detail::readFile(filename) };
+        };
 
     template <typename Function>
     void enqueueJob(Function && job);
@@ -1696,7 +1719,10 @@ class Context
 
     Value evalFile(const char * filename, int flags = 0)
     {
-        return eval(readFile(filename), filename, flags);
+        auto buf = detail::readFile(filename);
+        if (!buf)
+            throw std::runtime_error{std::string{"evalFile: can't read file: "} + filename};
+        return eval(*buf, filename, flags);
     }
 
     /// @see JS_ParseJSON2
@@ -1714,14 +1740,6 @@ class Context
         assert(ptr);
         return *static_cast<Context *>(ptr);
     }
-
-    static std::string readFile(const char * filename)
-    {
-        std::ifstream f(filename, std::ios::in | std::ios::binary);
-        std::stringstream sstream;
-        sstream << f.rdbuf();
-        return sstream.str();
-    }
 };
 
 /** Conversion traits for Value.
@@ -2008,8 +2026,9 @@ inline JSModuleDef * Runtime::module_loader(JSContext *ctx,
         if (!data.url) data.url = module_name;
 
         // compile the module
-        auto func_val = context.eval(*data.source, data.url->c_str(), JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-        JSModuleDef * m = (JSModuleDef *)JS_VALUE_GET_PTR(func_val.v);
+        auto func_val = context.eval(*data.source, module_name, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+        assert(JS_VALUE_GET_TAG(func_val.v) == JS_TAG_MODULE);
+        JSModuleDef * m = reinterpret_cast<JSModuleDef *>(JS_VALUE_GET_PTR(func_val.v));
 
         // set import.meta
         auto meta = context.newValue(JS_GetImportMeta(ctx, m));
diff --git a/test/module_loader.cpp b/test/module_loader.cpp
index 872d7a031b..c08b78ebed 100644
--- a/test/module_loader.cpp
+++ b/test/module_loader.cpp
@@ -7,48 +7,75 @@ int main()
     qjs::Runtime runtime;
     qjs::Context context(runtime);
 
-    auto simple_module_loader = [](std::string_view filename) -> qjs::Context::ModuleData {
-        if (filename == "some_module.js") {
-            return {R"xxx(
+    std::unordered_map<std::string_view, std::string> files = {
+        {
+            "some_module.js",
+            R"xxx(
                 import "folder/file1.js"
                 log(import.meta.url);
-            )xxx"};
-        }
-        if (filename == "folder/file1.js") {
-            return {R"xxx(
+            )xxx"
+        },
+        {
+            "folder/file1.js",
+            R"xxx(
                 import "./file2.js"
                 log(import.meta.url);
-            )xxx"};
-        }
-        if (filename == "folder/file2.js") {
-            return {R"xxx(
+            )xxx"
+        },
+        {
+            "folder/file2.js",
+            R"xxx(
                 import "http://localhost/script1.js";
                 log(import.meta.url);
-            )xxx"};
-        }
-        if (filename == "http://localhost/script1.js") {
-            return {R"xxx(
+            )xxx"
+        },
+        {
+            "http://localhost/script1.js",
+            R"xxx(
                 import "./script2.js";
                 log(import.meta.url);
-            )xxx"};
-        }
-        if (filename == "http://localhost/script2.js") {
-            return {R"xxx(
+            )xxx"
+        },
+        {
+            "http://localhost/script2.js",
+            R"xxx(
                 log(import.meta.url);
-            )xxx"};
-        }
+            )xxx"
+        },
+    };
+
+    auto mock_module_loader = [&files](std::string_view filename) -> qjs::Context::ModuleData {
+        if (files.count(filename)) return { qjs::detail::toUri(filename), files.at(filename) };
         return {};
     };
 
-    context.moduleLoader = simple_module_loader;
+    // Test a failing import with the default moduleLoader
+    try
+    {
+        context.eval(R"xxx(
+            import "./invalid_module.js";
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+        assert(false && "module import should have failed");
+    }
+    catch(qjs::exception e)
+    {
+        auto exc = e.get();
+        assert(exc.isError() && "Exception should be a JS error");
+        assert((std::string)exc == "ReferenceError: could not load module filename 'invalid_module.js'");
+    }
+
+    context.moduleLoader = mock_module_loader;
     context.global().add("log", [](std::string_view s) {
         std::cout << s << std::endl;
     });
 
+    // Test a successful import with the mock moduleLoader
+    // It pretends to import things from the filesystem and from URLs
     context.eval(R"xxx(
         import "./some_module.js";
     )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
 
+    // Test a failing import with the mock moduleLoader
     try
     {
         context.eval(R"xxx(

From 95dfe622a93d7ebf372bd9f73a9af4576afcad08 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 21:01:54 +0000
Subject: [PATCH 154/185] clean up qjs.cpp

---
 qjs.cpp | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/qjs.cpp b/qjs.cpp
index a9251e8768..70e215c6f5 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -5,19 +5,15 @@
 
 int main(int argc, char ** argv)
 {
-    JSRuntime * rt;
-    JSContext * ctx;
     using namespace qjs;
 
     Runtime runtime;
-    rt = runtime.rt;
-
     Context context(runtime);
-    ctx = context.ctx;
+
+    auto rt = runtime.rt;
+    auto ctx = context.ctx;
 
     js_std_init_handlers(rt);
-    /* loader for ES6 modules */
-    JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
     js_std_add_helpers(ctx, argc - 1, argv + 1);
 
     /* system modules */
@@ -25,21 +21,21 @@ int main(int argc, char ** argv)
     js_init_module_os(ctx, "os");
 
     /* make 'std' and 'os' visible to non module code */
-    const char * str = "import * as std from 'std';\n"
-                       "import * as os from 'os';\n"
-                       "globalThis.std = std;\n"
-                       "globalThis.os = os;\n";
-    context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
+    context.eval(R"xxx(
+        import * as std from 'std';
+        import * as os from 'os';
+        globalThis.std = std;
+        globalThis.os = os;
+    )xxx", "<input>", JS_EVAL_TYPE_MODULE);
 
     try
     {
         if(argv[1])
             context.evalFile(argv[1], JS_EVAL_TYPE_MODULE);
     }
-    catch(exception)
+    catch(exception & e)
     {
-        //js_std_dump_error(ctx);
-        auto exc = context.getException();
+        auto exc = e.get();
         std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;
         if((bool)exc["stack"])
             std::cerr << (std::string)exc["stack"] << std::endl;

From d6f07d8d911b030072b7e2960cc69c82e6f18fcf Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 21:18:30 +0000
Subject: [PATCH 155/185] Fix Windows and Linux gcc-8 builds. Switch windows
 build from built-in mingw-8 to msys2's mingw. Link agains stdc++fs in gcc8.

---
 .github/workflows/cxx.yml | 48 +++++++++++++++++++++++++++++++++------
 CMakeLists.txt            |  2 +-
 2 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/cxx.yml b/.github/workflows/cxx.yml
index 65d061f852..c8bc1220e4 100644
--- a/.github/workflows/cxx.yml
+++ b/.github/workflows/cxx.yml
@@ -8,7 +8,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        compiler: [linux-gcc,linux-clang,linux-gcc8,linux-gcc10,linux-gcc-ubsan,linux-gcc-asan,linux-gcc-32,linux-gcc-x32,linux-clang11,linux-clang12,windows-gcc,macos-clang]
+        compiler: [linux-gcc,linux-clang,linux-gcc8,linux-gcc10,linux-gcc-ubsan,linux-gcc-asan,linux-gcc-32,linux-gcc-x32,linux-clang11,linux-clang12,macos-clang]
         build_type: [Debug]
         include:
           - compiler: linux-gcc
@@ -21,7 +21,7 @@ jobs:
           - compiler: linux-gcc8
             os: ubuntu-18.04
             preconfigure: sudo apt-get update && sudo apt-get install -y gcc-8 g++-8
-            cmake_opts: -DCMAKE_C_COMPILER=gcc-8 -DCMAKE_CXX_COMPILER=g++-8
+            cmake_opts: -DCMAKE_C_COMPILER=gcc-8 -DCMAKE_CXX_COMPILER=g++-8 -DCMAKE_REQUIRED_LIBRARIES=stdc++fs
 
           - compiler: linux-gcc10
             os: ubuntu-20.04
@@ -58,20 +58,54 @@ jobs:
             cmake_opts: -DCMAKE_C_COMPILER=clang-12 -DCMAKE_CXX_COMPILER=clang++-12
             cflags: -stdlib=libc++
 
-#          - compiler: windows-msvs # not supported
-#            os: windows-latest
+          - compiler: macos-clang
+            os: macos-latest
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: recursive
+    - name: preconfigure
+      run: ${{ matrix.preconfigure }}
+    - name: configure
+      run: cmake -S . -B build_dir -Wdev -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_C_FLAGS="${{ matrix.cflags }}" -DCMAKE_CXX_FLAGS="${{ matrix.cflags }}" -DCMAKE_EXE_LINKER_FLAGS="${{ matrix.cflags }}" ${{ matrix.cmake_opts }}
+    - name: build
+      run: cmake --build build_dir --verbose
+    - name: test
+      run: ctest --extra-verbose
+      working-directory: build_dir
+      env:
+        # extra options for address sanitizer
+        ASAN_OPTIONS: strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1
 
+  build_windows:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [windows-gcc]
+        build_type: [Debug]
+        include:
           - compiler: windows-gcc
             os: windows-2019
-            cmake_opts: -G "MSYS Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
+            cmake_opts: -G "Ninja" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
 
-          - compiler: macos-clang
-            os: macos-latest
+#          - compiler: windows-msvs # not supported
+#            os: windows-latest
+
+    defaults:
+      run:
+        shell: msys2 {0}
 
     steps:
     - uses: actions/checkout@v2
       with:
         submodules: recursive
+    - uses: msys2/setup-msys2@v2
+      with:
+        msystem: MINGW64
+        update: true
+        install: git cmake ninja mingw-w64-x86_64-toolchain mingw-w64-x86_64-dlfcn
     - name: preconfigure
       run: ${{ matrix.preconfigure }}
     - name: configure
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3ccf600fc8..7842bdc798 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,7 @@ endif()
 add_subdirectory(quickjs)
 
 add_library(quickjspp INTERFACE)
-target_link_libraries(quickjspp INTERFACE quickjs)
+target_link_libraries(quickjspp INTERFACE quickjs ${CMAKE_REQUIRED_LIBRARIES})
 target_compile_features(quickjspp INTERFACE cxx_std_17)
 target_include_directories(quickjspp INTERFACE .)
 set_target_properties(quickjspp PROPERTIES PUBLIC_HEADER quickjspp.hpp)

From d430c9323f85d6b5d2a068d5a2f0e4e84f89de69 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Wed, 24 Nov 2021 14:35:02 +0000
Subject: [PATCH 156/185] Add js_traits for functors

---
 quickjspp.hpp          | 35 ++++++++++++++++++++++++++++++++++-
 test/module_loader.cpp |  4 ++--
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 77fb3e1a91..97ba0adb5e 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1764,7 +1764,7 @@ struct js_traits<Value>
  * @tparam Args argument types
  */
 template <typename R, typename... Args>
-struct js_traits<std::function<R(Args...)>>
+struct js_traits<std::function<R(Args...)>, int>
 {
     static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
     {
@@ -1822,6 +1822,39 @@ struct js_traits<std::function<R(Args...)>>
     }
 };
 
+namespace detail {
+
+template<typename T, typename = void>
+struct is_callable : std::is_function<T> { };
+
+template<typename T>
+struct is_callable<T, std::enable_if_t<std::is_same_v<decltype(void(&T::operator())), void>>> : std::true_type { };
+
+template<typename T>
+inline constexpr bool is_callable_v = is_callable<T>::value;
+
+}
+
+template <typename Function>
+struct js_traits<Function, std::enable_if_t<detail::is_callable_v<Function>>> {
+    static auto unwrap(JSContext * ctx, JSValueConst fun_obj)
+    {
+        return js_traits<
+            decltype(std::function{std::declval<Function>()}),
+            int
+        >::unwrap(ctx, fun_obj);
+    }
+
+    template <typename Functor>
+    static JSValue wrap(JSContext * ctx, Functor&& functor)
+    {
+        return js_traits<
+            decltype(std::function{std::declval<Function>()}),
+            int
+        >::wrap(ctx, std::forward<Functor>(functor));
+    }
+};
+
 /** Convert from std::vector<T> to Array and vice-versa. If Array holds objects that are non-convertible to T throws qjs::exception */
 template <class T>
 struct js_traits<std::vector<T>>
diff --git a/test/module_loader.cpp b/test/module_loader.cpp
index c08b78ebed..51b5bc946c 100644
--- a/test/module_loader.cpp
+++ b/test/module_loader.cpp
@@ -65,9 +65,9 @@ int main()
     }
 
     context.moduleLoader = mock_module_loader;
-    context.global().add("log", [](std::string_view s) {
+    context.global()["log"] = [](std::string_view s) {
         std::cout << s << std::endl;
-    });
+    };
 
     // Test a successful import with the mock moduleLoader
     // It pretends to import things from the filesystem and from URLs

From 6d39774da44f6159cef28a559c5db92e7e068b76 Mon Sep 17 00:00:00 2001
From: Jorge Prendes <jorge.prendes@gmail.com>
Date: Thu, 25 Nov 2021 14:20:41 +0000
Subject: [PATCH 157/185] Change usage of  to

---
 quickjspp.hpp                |  2 +-
 test/class.cpp               |  2 +-
 test/exception.cpp           |  3 +--
 test/function_call.cpp       | 12 ++++++------
 test/jobs.cpp                |  8 ++++----
 test/unhandled_rejection.cpp |  4 ++--
 6 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 97ba0adb5e..d4f86418f1 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1544,7 +1544,7 @@ class Context
             template <typename F>
             class_registrar& fun(const char * name, F&& f)
             {
-                prototype.add(name, std::forward<F>(f));
+                prototype[name] = std::forward<F>(f);
                 return *this;
             }
 
diff --git a/test/class.cpp b/test/class.cpp
index 2b68a9d588..16a501f3db 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -119,7 +119,7 @@ int main()
         context.eval(str, "<input>", JS_EVAL_TYPE_MODULE);
 
 
-        context.global().add("assert", [](bool t) { if(!t) std::exit(2); });
+        context.global()["assert"] = [](bool t) { if(!t) std::exit(2); };
 
 
         auto xxx = context.eval("\"use strict\";"
diff --git a/test/exception.cpp b/test/exception.cpp
index 8d2edbe146..cf97eebab7 100644
--- a/test/exception.cpp
+++ b/test/exception.cpp
@@ -18,7 +18,7 @@ int main()
 {
     qjs::Runtime runtime;
     qjs::Context context(runtime);
-    context.global().add("println", [](const std::string& s) { std::cout << s << std::endl; });
+    context.global()["println"] = [](const std::string& s) { std::cout << s << std::endl; };
 
     context.registerClass<A>("A");
     context.registerClass<A>("A");
@@ -47,7 +47,6 @@ int main()
 
     try
     {
-        //context.global().add("emptyf", [](JSValue v) {} );
         auto f = (std::function<void ()>) context.eval("(function() { +Symbol.toPrimitive })");
         f();
         assert(false);
diff --git a/test/function_call.cpp b/test/function_call.cpp
index 15d3fd2f8a..2e1e59db4b 100644
--- a/test/function_call.cpp
+++ b/test/function_call.cpp
@@ -6,9 +6,9 @@
 int test_not_enough_arguments(qjs::Context & ctx) {
     std::string msg;
 
-    ctx.global().add("test_fcn", [](int a, int b, int c) {
+    ctx.global()["test_fcn"] = [](int a, int b, int c) {
         return a + b + c;
-    });
+    };
 
     try
     {
@@ -47,19 +47,19 @@ int test_not_enough_arguments(qjs::Context & ctx) {
 }
 
 int test_call_with_rest_parameters(qjs::Context & ctx) {
-    ctx.global().add("test_fcn_rest", [](int a, qjs::rest<int> args) {
+    ctx.global()["test_fcn_rest"] = [](int a, qjs::rest<int> args) {
         for (auto arg : args) {
             a += arg;
         }
         return a;
-    });
+    };
 
-    ctx.global().add("test_fcn_vec", [](int a, std::vector<int> args) {
+    ctx.global()["test_fcn_vec"] = [](int a, std::vector<int> args) {
         for (auto arg : args) {
             a += arg;
         }
         return a;
-    });
+    };
 
     try
     {
diff --git a/test/jobs.cpp b/test/jobs.cpp
index b462d68f03..afad815e65 100644
--- a/test/jobs.cpp
+++ b/test/jobs.cpp
@@ -7,14 +7,14 @@ int main()
     qjs::Runtime runtime;
     qjs::Context context(runtime);
     
-    context.global().add("nextTick", [&context](std::function<void()> f) {
+    context.global()["nextTick"] = [&context](std::function<void()> f) {
         context.enqueueJob(std::move(f));
-    });
+    };
 
     bool called = false;
-    context.global().add("testFcn", [&called]() {
+    context.global()["testFcn"] = [&called]() {
         called = true;
-    });
+    };
 
     qjs::Value caller = context.eval(R"xxx(
         nextTick(testFcn);
diff --git a/test/unhandled_rejection.cpp b/test/unhandled_rejection.cpp
index 5ff9e85ec7..2c0048f6e6 100644
--- a/test/unhandled_rejection.cpp
+++ b/test/unhandled_rejection.cpp
@@ -7,9 +7,9 @@ int main()
     qjs::Runtime runtime;
     qjs::Context context(runtime);
     
-    context.global().add("nextTick", [&context](std::function<void()> f) {
+    context.global()["nextTick"] = [&context](std::function<void()> f) {
         context.enqueueJob(std::move(f));
-    });
+    };
 
     bool called = false;
     context.onUnhandledPromiseRejection = [&called](qjs::Value reason) {

From 59a3b3f7042ead466fc9f7395b9e66ec83961782 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 27 Nov 2021 18:32:41 +0300
Subject: [PATCH 158/185] speed up getting prototype property

---
 quickjspp.hpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index d4f86418f1..1b71590ecd 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -728,6 +728,16 @@ struct ctor_wrapper
     const char * name = nullptr;
 };
 
+namespace detail {
+/// equivalent to JS_GetPropertyStr(ctx, this_value, "prototype");
+inline JSValue GetPropertyPrototype(JSContext * ctx, JSValueConst this_value)
+{
+    // constant atom: doesn't need to be freed and doesn't change with context
+    static const JSAtom JS_ATOM_prototype = JS_NewAtom(ctx, "prototype");
+    return JS_GetProperty(ctx, this_value, JS_ATOM_prototype);
+}
+} // namespace detail
+
 /** Conversion to JSValue for ctor_wrapper. */
 template <class T, typename... Args>
 struct js_traits<ctor_wrapper<T, Args...>>
@@ -748,7 +758,7 @@ struct js_traits<ctor_wrapper<T, Args...>>
 #endif
             }
 
-            auto proto = JS_GetPropertyStr(ctx, this_value, "prototype");
+            auto proto = detail::GetPropertyPrototype(ctx, this_value);
             if(JS_IsException(proto))
                 return proto;
             auto jsobj = JS_NewObjectProtoClass(ctx, proto, js_traits<std::shared_ptr<T>>::QJSClassId);

From dcfe28cab7805c22a172dc5bd0d4aad353ea3fc9 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 29 Nov 2021 19:19:48 +0300
Subject: [PATCH 159/185] implement GC markers for Value class members

---
 quickjspp.hpp | 38 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 1b71590ecd..f0eddb9d2d 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -866,6 +866,12 @@ struct js_traits<std::shared_ptr<T>>
         ensureCanCastToBase<detail::class_from_member_pointer_t<decltype(M)>>();
     }
 
+    /** Stores offsets to qjs::Value members of T.
+     * These values should be marked by class_registrar::mark for QuickJS garbage collector
+     * so that the cycle removal algorithm can find the other objects referenced by this object.
+     */
+    static inline std::vector<Value T::*> markOffsets;
+
     /** Register class in QuickJS context.
      *
      * @param ctx context
@@ -882,15 +888,32 @@ struct js_traits<std::shared_ptr<T>>
         auto rt = JS_GetRuntime(ctx);
         if(!JS_IsRegisteredClass(rt, QJSClassId))
         {
+            JSClassGCMark * marker = nullptr;
+            if(!markOffsets.empty())
+            {
+                marker = [](JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func) {
+                    auto pptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque(val, QJSClassId));
+                    assert(pptr);
+                    const T * ptr = pptr->get();
+                    assert(ptr);
+                    for(Value T::* member : markOffsets)
+                    {
+                        JS_MarkValue(rt, (*ptr.*member).v, mark_func);
+                    }
+                };
+            }
             JSClassDef def{
                     name,
-                    // destructor
+                    // destructor (finalizer)
                     [](JSRuntime * rt, JSValue obj) noexcept {
                         auto pptr = static_cast<std::shared_ptr<T> *>(JS_GetOpaque(obj, QJSClassId));
                         delete pptr;
                     },
+                    // mark
+                    marker,
+                    // call
                     nullptr,
-                    nullptr,
+                    // exotic
                     nullptr
             };
             int e = JS_NewClass(rt, QJSClassId, &def);
@@ -1616,6 +1639,17 @@ class Context
                 return *this;
             }
 
+            /** All qjs::Value members of T should be marked by mark<> for QuickJS garbage collector
+             * so that the cycle removal algorithm can find the other objects referenced by this object.
+             */
+            template <Value T::* V>
+            class_registrar& mark()
+            {
+                js_traits<std::shared_ptr<T>>::markOffsets.push_back(V);
+                return *this;
+            }
+
+
             ~class_registrar()
             {
                 context.registerClass<T>(name, std::move(prototype));

From 331ca95331590c866205fd6275b702d651273b70 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 30 Nov 2021 19:23:06 +0300
Subject: [PATCH 160/185] Value::evalThis

---
 quickjspp.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f0eddb9d2d..9f9f721ad4 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1395,6 +1395,14 @@ class Value
         return (std::string) Value{ctx, JS_JSONStringify(ctx, v, replacer.v, space.v)};
     }
 
+    /** same as Context::eval() but with this Value as 'this' */
+    Value evalThis(std::string_view buffer, const char * filename = "<evalThis>", int flags = 0)
+    {
+        assert(buffer.data()[buffer.size()] == '\0' && "eval buffer is not null-terminated"); // JS_Eval requirement
+        assert(ctx);
+        return Value{ctx, JS_EvalThis(ctx, JS_DupValue(ctx, v), buffer.data(), buffer.size(), filename, flags)};
+    }
+
 };
 
 /** Thin wrapper over JSRuntime * rt

From 1da8ebf6e23ba6d31b3e1b3119046ae9a5388f5c Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 4 Dec 2021 15:39:34 +0300
Subject: [PATCH 161/185] fix memory leak in Value::evalThis

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 9f9f721ad4..55f06abfa0 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1400,7 +1400,7 @@ class Value
     {
         assert(buffer.data()[buffer.size()] == '\0' && "eval buffer is not null-terminated"); // JS_Eval requirement
         assert(ctx);
-        return Value{ctx, JS_EvalThis(ctx, JS_DupValue(ctx, v), buffer.data(), buffer.size(), filename, flags)};
+        return Value{ctx, JS_EvalThis(ctx, v, buffer.data(), buffer.size(), filename, flags)};
     }
 
 };

From 4b8fa4a89b1c5175383f159982a30a178e2b4cc8 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 4 Dec 2021 18:06:22 +0300
Subject: [PATCH 162/185] minor cleanup

---
 quickjspp.hpp | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 55f06abfa0..47a9c1a3bc 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1823,19 +1823,16 @@ struct js_traits<std::function<R(Args...)>, int>
         const int argc = sizeof...(Args);
         if constexpr(argc == 0)
         {
-            return [ctx, jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}]() -> R {
+            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}]() -> R {
                 JSValue result = JS_Call(jsfun_obj.ctx, jsfun_obj.v, JS_UNDEFINED, 0, nullptr);
                 if(JS_IsException(result))
-                {
-                    JS_FreeValue(jsfun_obj.ctx, result);
-                    throw exception{ctx};
-                }
+                    throw exception{jsfun_obj.ctx};
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
         }
         else
         {
-            return [ctx, jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
+            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
                 const int argc = sizeof...(Args);
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);
@@ -1843,10 +1840,7 @@ struct js_traits<std::function<R(Args...)>, int>
                                          const_cast<JSValueConst *>(argv));
                 for(int i = 0; i < argc; i++) JS_FreeValue(jsfun_obj.ctx, argv[i]);
                 if(JS_IsException(result))
-                {
-                    JS_FreeValue(jsfun_obj.ctx, result);
-                    throw exception{ctx};
-                }
+                    throw exception{jsfun_obj.ctx};
                 return detail::unwrap_free<R>(jsfun_obj.ctx, result);
             };
         }

From b23a60a96219eb3fdba281b8a73ac6fa22df1704 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 4 Dec 2021 18:06:46 +0300
Subject: [PATCH 163/185] catch exception in function:wrap

---
 quickjspp.hpp | 32 +++++++++++++++++++++++---------
 1 file changed, 23 insertions(+), 9 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 47a9c1a3bc..61fc3594d0 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1850,21 +1850,35 @@ struct js_traits<std::function<R(Args...)>, int>
      * Uses detail::function for type-erasure.
      */
     template <typename Functor>
-    static JSValue wrap(JSContext * ctx, Functor&& functor)
+    static JSValue wrap(JSContext * ctx, Functor&& functor) noexcept
     {
         using detail::function;
         assert(js_traits<function>::QJSClassId);
         auto obj = JS_NewObjectClass(ctx, js_traits<function>::QJSClassId);
         if(JS_IsException(obj))
+            return obj;
+        try
+        {
+            auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
+            fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc,
+                               JSValueConst * argv) {
+                assert(self);
+                auto f = reinterpret_cast<std::decay_t<Functor> *>(&self->functor);
+                return detail::wrap_call<R, Args...>(ctx, *f, argc, argv);
+            };
+            JS_SetOpaque(obj, fptr);
+            return obj;
+        }
+        catch(const std::exception& e)
+        {
+            JS_ThrowInternalError(ctx, "%s", e.what());
             return JS_EXCEPTION;
-        auto fptr = function::create(JS_GetRuntime(ctx), std::forward<Functor>(functor));
-        fptr->invoker = [](function * self, JSContext * ctx, JSValueConst this_value, int argc, JSValueConst * argv) {
-            assert(self);
-            auto f = reinterpret_cast<std::decay_t<Functor> *>(&self->functor);
-            return detail::wrap_call<R, Args...>(ctx, *f, argc, argv);
-        };
-        JS_SetOpaque(obj, fptr);
-        return obj;
+        }
+        catch(...)
+        {
+            JS_ThrowInternalError(ctx, "Unknown errror");
+            return JS_EXCEPTION;
+        }
     }
 };
 

From 03b980fd4af2f07c210b658270c897bbb687bac2 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 17 Dec 2021 13:41:03 +0300
Subject: [PATCH 164/185] mark qjs::Value ctors as noexcept

---
 quickjspp.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 61fc3594d0..f85d0a7eee 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1242,21 +1242,21 @@ class Value
             throw exception{ctx};
     }
 
-    Value(JSValue&& v) : v(std::move(v)), ctx(nullptr) {}
+    Value(JSValue&& v) noexcept : v(std::move(v)), ctx(nullptr) {}
 
-    Value(const Value& rhs)
+    Value(const Value& rhs) noexcept
     {
         ctx = rhs.ctx;
         v = JS_DupValue(ctx, rhs.v);
     }
 
-    Value(Value&& rhs)
+    Value(Value&& rhs) noexcept
     {
         std::swap(ctx, rhs.ctx);
         v = rhs.v;
     }
 
-    Value& operator =(Value rhs)
+    Value& operator =(Value rhs) noexcept
     {
         std::swap(ctx, rhs.ctx);
         std::swap(v, rhs.v);
@@ -1298,14 +1298,14 @@ class Value
     template <typename T>
     explicit operator T() const { return as<T>(); }
 
-    JSValue release() // dont call freevalue
+    JSValue release() noexcept// dont call freevalue
     {
         ctx = nullptr;
         return v;
     }
 
     /** Implicit conversion to JSValue (rvalue only). Example: JSValue v = std::move(value); */
-    operator JSValue()&& { return release(); }
+    operator JSValue()&& noexcept { return release(); }
 
 
     /** Access JS properties. Returns proxy type which is implicitly convertible to qjs::Value */

From 02e208217dcebbc784b61474b14db671c24b9765 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 5 Feb 2022 16:54:27 +0300
Subject: [PATCH 165/185] allow passing values between contexts

---
 quickjspp.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f85d0a7eee..f5942a03e9 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1270,11 +1270,10 @@ class Value
 
     bool operator !=(JSValueConst other) const { return !((*this) == other); }
 
-
     /** Returns true if 2 values are the same (equality for arithmetic types or point to the same object) */
     bool operator ==(const Value& rhs) const
     {
-        return ctx == rhs.ctx && (*this == rhs.v);
+        return (*this == rhs.v);
     }
 
     bool operator !=(const Value& rhs) const { return !((*this) == rhs); }
@@ -1806,7 +1805,7 @@ struct js_traits<Value>
 
     static JSValue wrap(JSContext * ctx, Value v) noexcept
     {
-        assert(ctx == v.ctx);
+        assert(JS_GetRuntime(ctx) == JS_GetRuntime(v.ctx));
         return v.release();
     }
 };

From 95c9181436ec8b935cbddb550c8fd61de7fad869 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 5 Feb 2022 16:55:01 +0300
Subject: [PATCH 166/185] allow passing values between contexts: test

---
 test/multicontext.cpp | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/test/multicontext.cpp b/test/multicontext.cpp
index de1cfa8af4..c94a134ba6 100644
--- a/test/multicontext.cpp
+++ b/test/multicontext.cpp
@@ -25,15 +25,23 @@ int main()
     qjs::Runtime runtime;
     qjs::Context context1(runtime);
     qjs::Context context2(runtime);
+    qjs::Value val = JS_UNDEFINED, mc = JS_UNDEFINED;
     try
     {
         // export classes as a module
         glue(context1.addModule("MyModule"));
         // evaluate js code
-        context1.eval("import * as my from 'MyModule'; " "\n"
-                      "(new my.MyClass()).print_context(undefined);" "\n"
-                     , "<eval>", JS_EVAL_TYPE_MODULE
-        );
+        context1.eval(R"xxx(
+            import * as my from 'MyModule';
+            globalThis.mc = new my.MyClass();
+            mc.print_context(undefined);
+        )xxx", "<eval>", JS_EVAL_TYPE_MODULE);
+
+        context1.global()["val"] = context1.fromJSON("{\"a\":\"1\",\"b\":{\"2\":2}}");
+        val = context1.eval("globalThis.val");
+        assert(val["a"].as<int>() == 1);
+
+        mc = context1.eval("mc");
     }
     catch(qjs::exception e)
     {
@@ -50,6 +58,13 @@ int main()
                       "(new my.MyClass()).print_context(undefined);" "\n"
                       ,"<eval>", JS_EVAL_TYPE_MODULE
         );
+        context2.global()["val"] = val;
+        assert(val == context2.eval("globalThis.val"));
+
+        context2.global()["mc"] = mc;
+        // will print the first context even though we call it from second
+        // see js_call_c_function
+        context2.eval("mc.print_context(undefined)");
     }
     catch(qjs::exception e)
     {

From f4d0fd2c3272c0be2086a7dab70b85589dc0c411 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 5 Feb 2022 17:04:36 +0300
Subject: [PATCH 167/185] test: don't compare objects after std::move

---
 test/value.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/value.cpp b/test/value.cpp
index 92b3c342de..12425b9f3b 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -20,8 +20,6 @@ int main()
         assert(val1 == val2);
 
         val1 = std::move(val2);
-        assert(val1 != val2);
-
         assert(val1.as<std::string>() == "123");
 
         assert((double) val1 == 123.0);

From 8efd98903fca507e58144865d26c47c91565bb55 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 18 Dec 2021 13:24:03 +0300
Subject: [PATCH 168/185] update quickjs dll CI

---
 .github/workflows/quickjsdll.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/quickjsdll.yml b/.github/workflows/quickjsdll.yml
index 45f843cd71..a5d5aa7170 100644
--- a/.github/workflows/quickjsdll.yml
+++ b/.github/workflows/quickjsdll.yml
@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        cflags: [ "-flto -O2", "-flto -Os", "-flto -O3" ]
+        cflags: [ "-flto -O2 -DNDEBUG", "-flto -Os -DNDEBUG", "-flto -O3 -DNDEBUG", "-O3 -DNDEBUG", "-g -DDUMP_LEAKS=1" ]
 
     steps:
     - uses: actions/checkout@v2
@@ -27,10 +27,10 @@ jobs:
         # export only symbols with "js" in them
         echo 'EXPORTS' > bin/libquickjs.def
         nm  -D --defined-only -f posix libquickjs.so | grep -i js | awk '{print $1}' >> bin/libquickjs.def
-        i686-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -o bin/libquickjs32.dll  -Wl,--out-implib,bin/libquickjs32.a -pthread -s ${{ matrix.cflags }}
-        x86_64-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -o bin/libquickjs64.dll  -Wl,--out-implib,bin/libquickjs64.a -pthread -s ${{ matrix.cflags }}
+        i686-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -D_GNU_SOURCE=1 -o bin/libquickjs32.dll  -Wl,--out-implib,bin/libquickjs32.a -pthread -s ${{ matrix.cflags }}
+        x86_64-w64-mingw32-gcc -shared -static quickjs/*.c bin/libquickjs.def -DCONFIG_VERSION=\"$(cat quickjs/VERSION)\" -DCONFIG_BIGNUM -D_GNU_SOURCE=1 -o bin/libquickjs64.dll  -Wl,--out-implib,bin/libquickjs64.a -pthread -s ${{ matrix.cflags }}
       shell: bash
-    - uses: actions/upload-artifact@v1
+    - uses: actions/upload-artifact@v2
       with:
         name: dlls ${{matrix.cflags}}
         path: bin
\ No newline at end of file

From 2b3d83572962dce74fb02067b0d03e150089c718 Mon Sep 17 00:00:00 2001
From: Microctar Lecter <microctar@outlook.com>
Date: Fri, 11 Mar 2022 13:44:40 +0800
Subject: [PATCH 169/185] quickjs/quickjs-libc.c: Defined Macro For FreeBSD.

---
 quickjs/quickjs-libc.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index e180dd0cd3..f0c61be66f 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -55,6 +55,13 @@ typedef sig_t sighandler_t;
 #endif
 #endif /* __APPLE__ */
 
+#if defined(__FreeBSD__)
+typedef sig_t sighandler_t;
+__BEGIN_DECLS
+extern char **environ;
+__END_DECLS
+#endif  /* __FreeBSD__ */
+
 #endif
 
 #if !defined(_WIN32)

From 9ac21a7161562d591a2c1222643e51da623ca1e2 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sat, 16 Apr 2022 14:18:30 +0300
Subject: [PATCH 170/185] add freebsd patch file
 https://github.com/ftk/quickjspp/pull/48

---
 quickjs/patches/freebsd.patch | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 quickjs/patches/freebsd.patch

diff --git a/quickjs/patches/freebsd.patch b/quickjs/patches/freebsd.patch
new file mode 100644
index 0000000000..5c3eabd798
--- /dev/null
+++ b/quickjs/patches/freebsd.patch
@@ -0,0 +1,18 @@
+diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
+index e180dd0cd3..f0c61be66f 100644
+--- a/quickjs/quickjs-libc.c
++++ b/quickjs/quickjs-libc.c
+@@ -55,6 +55,13 @@ typedef sig_t sighandler_t;
+ #endif
+ #endif /* __APPLE__ */
+
++#if defined(__FreeBSD__)
++typedef sig_t sighandler_t;
++__BEGIN_DECLS
++extern char **environ;
++__END_DECLS
++#endif  /* __FreeBSD__ */
++
+ #endif
+
+ #if !defined(_WIN32)

From 56129e188a4b9f4687953f7de1d556d62bba9a73 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Tue, 7 Jun 2022 12:11:29 +0300
Subject: [PATCH 171/185] updated quickjs to 2022-03-06

---
 quickjs/libunicode-table.h | 4285 ++++++++++++++++++------------------
 quickjs/quickjs.c          |  157 +-
 2 files changed, 2274 insertions(+), 2168 deletions(-)

diff --git a/quickjs/libunicode-table.h b/quickjs/libunicode-table.h
index 0ef2113560..1727525fb3 100644
--- a/quickjs/libunicode-table.h
+++ b/quickjs/libunicode-table.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-static const uint32_t case_conv_table1[361] = {
+static const uint32_t case_conv_table1[370] = {
     0x00209a30, 0x00309a00, 0x005a8173, 0x00601730,
     0x006c0730, 0x006f81b3, 0x00701700, 0x007c0700,
     0x007f8100, 0x00803040, 0x009801c3, 0x00988190,
@@ -74,8 +74,8 @@ static const uint32_t case_conv_table1[361] = {
     0x0ffb01b2, 0x0ffb81d9, 0x0ffc0230, 0x0ffd0230,
     0x0ffe0162, 0x109301a0, 0x109501a0, 0x109581a0,
     0x10990131, 0x10a70101, 0x10b01031, 0x10b81001,
-    0x10c18240, 0x125b1a31, 0x12681a01, 0x16002f31,
-    0x16182f01, 0x16300240, 0x16310130, 0x16318130,
+    0x10c18240, 0x125b1a31, 0x12681a01, 0x16003031,
+    0x16183001, 0x16300240, 0x16310130, 0x16318130,
     0x16320130, 0x16328100, 0x16330100, 0x16338640,
     0x16368130, 0x16370130, 0x16378130, 0x16380130,
     0x16390240, 0x163a8240, 0x163f0230, 0x16406440,
@@ -85,19 +85,21 @@ static const uint32_t case_conv_table1[361] = {
     0x53c58240, 0x53c68130, 0x53c80440, 0x53ca0101,
     0x53cb1440, 0x53d50130, 0x53d58130, 0x53d60130,
     0x53d68130, 0x53d70130, 0x53d80130, 0x53d88130,
-    0x53d90130, 0x53d98131, 0x53da0c40, 0x53e10240,
-    0x53e20131, 0x53e28130, 0x53e30130, 0x53e38440,
-    0x53fa8240, 0x55a98101, 0x55b85020, 0x7d8001b2,
-    0x7d8081b2, 0x7d8101b2, 0x7d8181da, 0x7d8201da,
-    0x7d8281b3, 0x7d8301b3, 0x7d8981bb, 0x7d8a01bb,
-    0x7d8a81bb, 0x7d8b01bc, 0x7d8b81bb, 0x7f909a31,
-    0x7fa09a01, 0x82002831, 0x82142801, 0x82582431,
-    0x826c2401, 0x86403331, 0x86603301, 0x8c502031,
-    0x8c602001, 0xb7202031, 0xb7302001, 0xf4802231,
-    0xf4912201,
+    0x53d90130, 0x53d98131, 0x53da1040, 0x53e20131,
+    0x53e28130, 0x53e30130, 0x53e38440, 0x53e80240,
+    0x53eb0440, 0x53fa8240, 0x55a98101, 0x55b85020,
+    0x7d8001b2, 0x7d8081b2, 0x7d8101b2, 0x7d8181da,
+    0x7d8201da, 0x7d8281b3, 0x7d8301b3, 0x7d8981bb,
+    0x7d8a01bb, 0x7d8a81bb, 0x7d8b01bc, 0x7d8b81bb,
+    0x7f909a31, 0x7fa09a01, 0x82002831, 0x82142801,
+    0x82582431, 0x826c2401, 0x82b80b31, 0x82be0f31,
+    0x82c60731, 0x82ca0231, 0x82cb8b01, 0x82d18f01,
+    0x82d98701, 0x82dd8201, 0x86403331, 0x86603301,
+    0x8c502031, 0x8c602001, 0xb7202031, 0xb7302001,
+    0xf4802231, 0xf4912201,
 };
 
-static const uint8_t case_conv_table2[361] = {
+static const uint8_t case_conv_table2[370] = {
     0x01, 0x00, 0x9c, 0x06, 0x07, 0x4d, 0x03, 0x04,
     0x10, 0x00, 0x8f, 0x0b, 0x00, 0x00, 0x11, 0x00,
     0x08, 0x00, 0x53, 0x4a, 0x51, 0x00, 0x52, 0x00,
@@ -110,7 +112,7 @@ static const uint8_t case_conv_table2[361] = {
     0x2a, 0x00, 0x13, 0x6b, 0x6d, 0x00, 0x26, 0x24,
     0x27, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x3e, 0x1e,
     0x3f, 0x1f, 0x39, 0x3d, 0x22, 0x21, 0x41, 0x1e,
-    0x40, 0x25, 0x25, 0x26, 0x28, 0x20, 0x2a, 0x49,
+    0x40, 0x25, 0x25, 0x26, 0x28, 0x20, 0x2a, 0x48,
     0x2c, 0x43, 0x2e, 0x4b, 0x30, 0x4c, 0x32, 0x44,
     0x42, 0x99, 0x00, 0x00, 0x95, 0x8f, 0x7d, 0x7e,
     0x83, 0x84, 0x12, 0x80, 0x82, 0x76, 0x77, 0x12,
@@ -119,9 +121,9 @@ static const uint8_t case_conv_table2[361] = {
     0x33, 0x95, 0x00, 0x8e, 0x00, 0x74, 0x99, 0x98,
     0x97, 0x96, 0x00, 0x00, 0x9e, 0x00, 0x9c, 0x00,
     0xa1, 0xa0, 0x15, 0x2e, 0x2f, 0x30, 0xb4, 0xb5,
-    0x4e, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
+    0x4f, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
     0x22, 0x2a, 0x34, 0x35, 0xa6, 0xa7, 0x36, 0x1f,
-    0x4a, 0x00, 0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d,
+    0x49, 0x00, 0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d,
     0x36, 0x05, 0x00, 0xc4, 0xc3, 0xc6, 0xc5, 0xc8,
     0xc7, 0xca, 0xc9, 0xcc, 0xcb, 0xc4, 0xd5, 0x45,
     0xd6, 0x42, 0xd7, 0x46, 0xd8, 0xce, 0xd0, 0xd2,
@@ -137,13 +139,14 @@ static const uint8_t case_conv_table2[361] = {
     0x65, 0x44, 0x47, 0x00, 0x4f, 0x62, 0x4e, 0x50,
     0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0xa3, 0xa4,
     0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0x00,
-    0x00, 0x5a, 0x00, 0x48, 0x00, 0x5b, 0x56, 0x58,
-    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4d, 0x00, 0x00,
-    0x3b, 0x67, 0xb8, 0x00, 0x00, 0x45, 0xa8, 0x8a,
-    0x8b, 0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf, 0x94,
-    0xb0, 0x6f, 0xb2, 0x5c, 0x5b, 0x5e, 0x5d, 0x60,
-    0x5f, 0x62, 0x61, 0x64, 0x63, 0x66, 0x65, 0x68,
-    0x67,
+    0x00, 0x5a, 0x00, 0x47, 0x00, 0x5b, 0x56, 0x58,
+    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4e, 0x00, 0x3b,
+    0x67, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x45, 0xa8,
+    0x8a, 0x8b, 0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf,
+    0x94, 0xb0, 0x6f, 0xb2, 0x5d, 0x5c, 0x5f, 0x5e,
+    0x61, 0x60, 0x66, 0x67, 0x68, 0x69, 0x62, 0x63,
+    0x64, 0x65, 0x6b, 0x6a, 0x6d, 0x6c, 0x6f, 0x6e,
+    0x71, 0x70,
 };
 
 static const uint16_t case_conv_ext[58] = {
@@ -157,7 +160,7 @@ static const uint16_t case_conv_ext[58] = {
     0x006b, 0x00e5,
 };
 
-static const uint8_t unicode_prop_Cased1_table[172] = {
+static const uint8_t unicode_prop_Cased1_table[188] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0xfc, 0x80, 0xd3,
     0x80, 0x8c, 0x80, 0x8d, 0x81, 0x8d, 0x02, 0x80,
     0xe1, 0x80, 0x91, 0x85, 0x9a, 0x01, 0x00, 0x01,
@@ -171,24 +174,26 @@ static const uint8_t unicode_prop_Cased1_table[172] = {
     0x10, 0x11, 0x02, 0x01, 0x18, 0x0b, 0x24, 0x4b,
     0x26, 0x01, 0x01, 0x86, 0xe5, 0x80, 0x60, 0x79,
     0xb6, 0x81, 0x40, 0x91, 0x81, 0xbd, 0x88, 0x94,
-    0x05, 0x80, 0x98, 0x80, 0xc7, 0x82, 0x43, 0x34,
-    0xa2, 0x06, 0x80, 0x8c, 0x61, 0x28, 0x96, 0xd4,
-    0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b,
-    0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80,
-    0x9b, 0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53,
-    0x81, 0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
-    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
-    0x80, 0x9e, 0x80, 0x98, 0x07, 0x59, 0x63, 0x99,
+    0x05, 0x80, 0x98, 0x80, 0xa2, 0x00, 0x80, 0xa1,
+    0x82, 0x43, 0x34, 0xa2, 0x06, 0x80, 0x8c, 0x60,
+    0x5c, 0x16, 0x01, 0x10, 0xa9, 0x80, 0x88, 0x60,
+    0xcc, 0x44, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09,
+    0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03,
+    0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16,
+    0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80,
+    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
+    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07,
+    0x47, 0x33, 0x89, 0x80, 0x93, 0x52, 0x10, 0x99,
     0x85, 0x99, 0x85, 0x99,
 };
 
 static const uint8_t unicode_prop_Cased1_index[18] = {
     0xb9, 0x02, 0xe0, 0xa0, 0x1e, 0x40, 0x9e, 0xa6,
-    0x40, 0xba, 0xd4, 0x01, 0x89, 0xd7, 0x01, 0x8a,
+    0x40, 0x55, 0xd4, 0x61, 0xfb, 0xd6, 0x21, 0x8a,
     0xf1, 0x01,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_table[692] = {
+static const uint8_t unicode_prop_Case_Ignorable_table[720] = {
     0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80,
     0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
     0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40,
@@ -197,61 +202,63 @@ static const uint8_t unicode_prop_Case_Ignorable_table[692] = {
     0x89, 0x8a, 0x00, 0xa2, 0x80, 0x89, 0x94, 0x8f,
     0x80, 0xe4, 0x38, 0x89, 0x03, 0xa0, 0x00, 0x80,
     0x9d, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0x18, 0x08,
-    0x97, 0x97, 0xaa, 0x82, 0xf6, 0xaf, 0xb6, 0x00,
-    0x03, 0x3b, 0x02, 0x86, 0x89, 0x81, 0x8c, 0x80,
-    0x8e, 0x80, 0xb9, 0x03, 0x1f, 0x80, 0x93, 0x81,
-    0x99, 0x01, 0x81, 0xb8, 0x03, 0x0b, 0x09, 0x12,
-    0x80, 0x9d, 0x0a, 0x80, 0x8a, 0x81, 0xb8, 0x03,
-    0x20, 0x0b, 0x80, 0x93, 0x81, 0x95, 0x28, 0x80,
-    0xb9, 0x01, 0x00, 0x1f, 0x06, 0x81, 0x8a, 0x81,
-    0x9d, 0x80, 0xbc, 0x80, 0x8b, 0x80, 0xb1, 0x02,
-    0x80, 0xb8, 0x14, 0x10, 0x1e, 0x81, 0x8a, 0x81,
-    0x9c, 0x80, 0xb9, 0x01, 0x05, 0x04, 0x81, 0x93,
-    0x81, 0x9b, 0x81, 0xb8, 0x0b, 0x1f, 0x80, 0x93,
-    0x81, 0x9c, 0x80, 0xc7, 0x06, 0x10, 0x80, 0xd9,
-    0x01, 0x86, 0x8a, 0x88, 0xe1, 0x01, 0x88, 0x88,
-    0x00, 0x85, 0xc9, 0x81, 0x9a, 0x00, 0x00, 0x80,
-    0xb6, 0x8d, 0x04, 0x01, 0x84, 0x8a, 0x80, 0xa3,
-    0x88, 0x80, 0xe5, 0x18, 0x28, 0x09, 0x81, 0x98,
-    0x0b, 0x82, 0x8f, 0x83, 0x8c, 0x01, 0x0d, 0x80,
-    0x8e, 0x80, 0xdd, 0x80, 0x42, 0x5f, 0x82, 0x43,
-    0xb1, 0x82, 0x9c, 0x82, 0x9c, 0x81, 0x9d, 0x81,
-    0xbf, 0x08, 0x37, 0x01, 0x8a, 0x10, 0x20, 0xac,
-    0x83, 0xb3, 0x80, 0xc0, 0x81, 0xa1, 0x80, 0xf5,
-    0x13, 0x81, 0x88, 0x05, 0x82, 0x40, 0xda, 0x09,
-    0x80, 0xb9, 0x00, 0x30, 0x00, 0x01, 0x3d, 0x89,
-    0x08, 0xa6, 0x07, 0x90, 0xbe, 0x83, 0xaf, 0x00,
-    0x20, 0x04, 0x80, 0xa7, 0x88, 0x8b, 0x81, 0x9f,
-    0x19, 0x08, 0x82, 0xb7, 0x00, 0x0a, 0x00, 0x82,
-    0xb9, 0x39, 0x81, 0xbf, 0x85, 0xd1, 0x10, 0x8c,
-    0x06, 0x18, 0x28, 0x11, 0xb1, 0xbe, 0x8c, 0x80,
-    0xa1, 0xde, 0x04, 0x41, 0xbc, 0x00, 0x82, 0x8a,
-    0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81, 0x8b,
-    0x27, 0x81, 0x89, 0x01, 0x01, 0x84, 0xb0, 0x20,
-    0x89, 0x00, 0x8c, 0x80, 0x8f, 0x8c, 0xb2, 0xa0,
-    0x4b, 0x8a, 0x81, 0xf0, 0x82, 0xfc, 0x80, 0x8e,
-    0x80, 0xdf, 0x9f, 0xae, 0x80, 0x41, 0xd4, 0x80,
-    0xa3, 0x1a, 0x24, 0x80, 0xdc, 0x85, 0xdc, 0x82,
-    0x60, 0x6f, 0x15, 0x80, 0x44, 0xe1, 0x85, 0x41,
-    0x0d, 0x80, 0xe1, 0x18, 0x89, 0x00, 0x9b, 0x83,
-    0xcf, 0x81, 0x8d, 0xa1, 0xcd, 0x80, 0x96, 0x82,
-    0xec, 0x0f, 0x02, 0x03, 0x80, 0x98, 0x0c, 0x80,
-    0x40, 0x96, 0x81, 0x99, 0x91, 0x8c, 0x80, 0xa5,
-    0x87, 0x98, 0x8a, 0xad, 0x82, 0xaf, 0x01, 0x19,
-    0x81, 0x90, 0x80, 0x94, 0x81, 0xc1, 0x29, 0x09,
-    0x81, 0x8b, 0x07, 0x80, 0xa2, 0x80, 0x8a, 0x80,
-    0xb2, 0x00, 0x11, 0x0c, 0x08, 0x80, 0x9a, 0x80,
-    0x8d, 0x0c, 0x08, 0x80, 0xe3, 0x84, 0x88, 0x82,
-    0xf8, 0x01, 0x03, 0x80, 0x60, 0x4f, 0x2f, 0x80,
-    0x40, 0x92, 0x8f, 0x42, 0x3d, 0x8f, 0x10, 0x8b,
-    0x8f, 0xa1, 0x01, 0x80, 0x40, 0xa8, 0x06, 0x05,
-    0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80, 0xae, 0x80,
-    0xac, 0x81, 0xc2, 0x80, 0x94, 0x82, 0x42, 0x00,
-    0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x46,
-    0x85, 0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40,
-    0xa4, 0x81, 0x42, 0x3c, 0x83, 0x41, 0x82, 0x81,
-    0x40, 0x98, 0x8a, 0x40, 0xaf, 0x80, 0xb5, 0x8e,
-    0xb7, 0x82, 0xb0, 0x19, 0x09, 0x80, 0x8e, 0x80,
+    0x97, 0x97, 0xaa, 0x82, 0xab, 0x06, 0x0d, 0x87,
+    0xa8, 0xb9, 0xb6, 0x00, 0x03, 0x3b, 0x02, 0x86,
+    0x89, 0x81, 0x8c, 0x80, 0x8e, 0x80, 0xb9, 0x03,
+    0x1f, 0x80, 0x93, 0x81, 0x99, 0x01, 0x81, 0xb8,
+    0x03, 0x0b, 0x09, 0x12, 0x80, 0x9d, 0x0a, 0x80,
+    0x8a, 0x81, 0xb8, 0x03, 0x20, 0x0b, 0x80, 0x93,
+    0x81, 0x95, 0x28, 0x80, 0xb9, 0x01, 0x00, 0x1f,
+    0x06, 0x81, 0x8a, 0x81, 0x9d, 0x80, 0xbc, 0x80,
+    0x8b, 0x80, 0xb1, 0x02, 0x80, 0xb6, 0x00, 0x14,
+    0x10, 0x1e, 0x81, 0x8a, 0x81, 0x9c, 0x80, 0xb9,
+    0x01, 0x05, 0x04, 0x81, 0x93, 0x81, 0x9b, 0x81,
+    0xb8, 0x0b, 0x1f, 0x80, 0x93, 0x81, 0x9c, 0x80,
+    0xc7, 0x06, 0x10, 0x80, 0xd9, 0x01, 0x86, 0x8a,
+    0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x85, 0xc9,
+    0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d, 0x04,
+    0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe5,
+    0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82, 0x8f,
+    0x83, 0x8c, 0x01, 0x0d, 0x80, 0x8e, 0x80, 0xdd,
+    0x80, 0x42, 0x5f, 0x82, 0x43, 0xb1, 0x82, 0x9c,
+    0x81, 0x9d, 0x81, 0x9d, 0x81, 0xbf, 0x08, 0x37,
+    0x01, 0x8a, 0x10, 0x20, 0xac, 0x84, 0xb2, 0x80,
+    0xc0, 0x81, 0xa1, 0x80, 0xf5, 0x13, 0x81, 0x88,
+    0x05, 0x82, 0x40, 0xda, 0x09, 0x80, 0xb9, 0x00,
+    0x30, 0x00, 0x01, 0x3d, 0x89, 0x08, 0xa6, 0x07,
+    0x9e, 0xb0, 0x83, 0xaf, 0x00, 0x20, 0x04, 0x80,
+    0xa7, 0x88, 0x8b, 0x81, 0x9f, 0x19, 0x08, 0x82,
+    0xb7, 0x00, 0x0a, 0x00, 0x82, 0xb9, 0x39, 0x81,
+    0xbf, 0x85, 0xd1, 0x10, 0x8c, 0x06, 0x18, 0x28,
+    0x11, 0xb1, 0xbe, 0x8c, 0x80, 0xa1, 0xe4, 0x41,
+    0xbc, 0x00, 0x82, 0x8a, 0x82, 0x8c, 0x82, 0x8c,
+    0x82, 0x8c, 0x81, 0x8b, 0x27, 0x81, 0x89, 0x01,
+    0x01, 0x84, 0xb0, 0x20, 0x89, 0x00, 0x8c, 0x80,
+    0x8f, 0x8c, 0xb2, 0xa0, 0x4b, 0x8a, 0x81, 0xf0,
+    0x82, 0xfc, 0x80, 0x8e, 0x80, 0xdf, 0x9f, 0xae,
+    0x80, 0x41, 0xd4, 0x80, 0xa3, 0x1a, 0x24, 0x80,
+    0xdc, 0x85, 0xdc, 0x82, 0x60, 0x6f, 0x15, 0x80,
+    0x44, 0xe1, 0x85, 0x41, 0x0d, 0x80, 0xe1, 0x18,
+    0x89, 0x00, 0x9b, 0x83, 0xcf, 0x81, 0x8d, 0xa1,
+    0xcd, 0x80, 0x96, 0x82, 0xe6, 0x12, 0x0f, 0x02,
+    0x03, 0x80, 0x98, 0x0c, 0x80, 0x40, 0x96, 0x81,
+    0x99, 0x91, 0x8c, 0x80, 0xa5, 0x87, 0x98, 0x8a,
+    0xad, 0x82, 0xaf, 0x01, 0x19, 0x81, 0x90, 0x80,
+    0x94, 0x81, 0xc1, 0x29, 0x09, 0x81, 0x8b, 0x07,
+    0x80, 0xa2, 0x80, 0x8a, 0x80, 0xb2, 0x00, 0x11,
+    0x0c, 0x08, 0x80, 0x9a, 0x80, 0x8d, 0x0c, 0x08,
+    0x80, 0xe3, 0x84, 0x88, 0x82, 0xf8, 0x01, 0x03,
+    0x80, 0x60, 0x4f, 0x2f, 0x80, 0x40, 0x92, 0x90,
+    0x42, 0x3c, 0x8f, 0x10, 0x8b, 0x8f, 0xa1, 0x01,
+    0x80, 0x40, 0xa8, 0x06, 0x05, 0x80, 0x8a, 0x80,
+    0xa2, 0x00, 0x80, 0xae, 0x80, 0xac, 0x81, 0xc2,
+    0x80, 0x94, 0x82, 0x42, 0x00, 0x80, 0x40, 0xe1,
+    0x80, 0x40, 0x94, 0x84, 0x44, 0x04, 0x28, 0xa9,
+    0x80, 0x88, 0x42, 0x45, 0x10, 0x0c, 0x83, 0xa7,
+    0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x83,
+    0x41, 0x82, 0x81, 0x40, 0x98, 0x8a, 0xb0, 0x83,
+    0xfa, 0x80, 0xb5, 0x8e, 0xa8, 0x01, 0x81, 0x89,
+    0x82, 0xb0, 0x19, 0x09, 0x03, 0x80, 0x89, 0x80,
     0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b,
     0x81, 0xb3, 0x88, 0x89, 0x19, 0x80, 0xde, 0x11,
     0x00, 0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94,
@@ -268,29 +275,30 @@ static const uint8_t unicode_prop_Case_Ignorable_table[692] = {
     0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41, 0x5a, 0x81,
     0x55, 0x3a, 0x88, 0x60, 0x36, 0xb6, 0x84, 0xba,
     0x86, 0x88, 0x83, 0x44, 0x0a, 0x80, 0xbe, 0x90,
-    0xbf, 0x08, 0x81, 0x60, 0x4c, 0xb7, 0x08, 0x83,
-    0x54, 0xc2, 0x82, 0x88, 0x8f, 0x0e, 0x9d, 0x83,
-    0x40, 0x93, 0x82, 0x47, 0xba, 0xb6, 0x83, 0xb1,
-    0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f,
-    0x30, 0x90, 0x0e, 0x01, 0x04, 0x41, 0x04, 0x8d,
-    0x41, 0xad, 0x83, 0x45, 0xdf, 0x86, 0xec, 0x87,
-    0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00, 0x80, 0x9d,
-    0xdf, 0xff, 0x40, 0xef,
+    0xbf, 0x08, 0x81, 0x60, 0x40, 0x0a, 0x18, 0x30,
+    0x81, 0x4c, 0x9d, 0x08, 0x83, 0x52, 0x5b, 0xad,
+    0x81, 0x96, 0x42, 0x1f, 0x82, 0x88, 0x8f, 0x0e,
+    0x9d, 0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6,
+    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
+    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x41,
+    0x04, 0x8d, 0x41, 0x6f, 0x80, 0xbc, 0x83, 0x45,
+    0xdf, 0x86, 0xec, 0x87, 0x4a, 0xae, 0x84, 0x6c,
+    0x0c, 0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_index[66] = {
+static const uint8_t unicode_prop_Case_Ignorable_index[69] = {
     0xbe, 0x05, 0x00, 0xfe, 0x07, 0x00, 0x52, 0x0a,
-    0x20, 0x05, 0x0c, 0x20, 0x3b, 0x0e, 0x40, 0x61,
-    0x10, 0x40, 0x0f, 0x18, 0x20, 0x43, 0x1b, 0x60,
-    0x79, 0x1d, 0x00, 0xf1, 0x20, 0x00, 0x0d, 0xa6,
-    0x40, 0x2e, 0xa9, 0x20, 0xde, 0xaa, 0x00, 0x0f,
-    0xff, 0x20, 0xe7, 0x0a, 0x41, 0x82, 0x11, 0x21,
-    0xc4, 0x14, 0x61, 0x44, 0x19, 0x01, 0x48, 0x1d,
-    0x21, 0xa4, 0xbc, 0x01, 0x3e, 0xe1, 0x01, 0xf0,
-    0x01, 0x0e,
+    0xa0, 0xc1, 0x0b, 0x00, 0x82, 0x0d, 0x00, 0x3f,
+    0x10, 0x80, 0xd4, 0x17, 0x40, 0xcf, 0x1a, 0x20,
+    0xf5, 0x1c, 0x00, 0x80, 0x20, 0x00, 0x16, 0xa0,
+    0x00, 0xc6, 0xa8, 0x00, 0xc2, 0xaa, 0x60, 0x56,
+    0xfe, 0x20, 0xb1, 0x07, 0x01, 0x82, 0x10, 0x21,
+    0x02, 0x13, 0x21, 0xb8, 0x16, 0x61, 0x97, 0x1a,
+    0x01, 0x37, 0x6b, 0x21, 0x8c, 0xd1, 0x01, 0xd7,
+    0xe8, 0x41, 0xf0, 0x01, 0x0e,
 };
 
-static const uint8_t unicode_prop_ID_Start_table[1045] = {
+static const uint8_t unicode_prop_ID_Start_table[1079] = {
     0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03,
     0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
     0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20,
@@ -301,109 +309,112 @@ static const uint8_t unicode_prop_ID_Start_table[1045] = {
     0x89, 0x11, 0x80, 0x8f, 0x00, 0x9d, 0x9c, 0xd8,
     0x8a, 0x80, 0x97, 0xa0, 0x88, 0x0b, 0x04, 0x95,
     0x18, 0x88, 0x02, 0x80, 0x96, 0x98, 0x86, 0x8a,
-    0xb4, 0x94, 0x80, 0x91, 0xbb, 0xb5, 0x10, 0x91,
-    0x06, 0x89, 0x8e, 0x8f, 0x1f, 0x09, 0x81, 0x95,
-    0x06, 0x00, 0x13, 0x10, 0x8f, 0x80, 0x8c, 0x08,
-    0x82, 0x8d, 0x81, 0x89, 0x07, 0x2b, 0x09, 0x95,
-    0x06, 0x01, 0x01, 0x01, 0x9e, 0x18, 0x80, 0x92,
-    0x82, 0x8f, 0x88, 0x02, 0x80, 0x95, 0x06, 0x01,
-    0x04, 0x10, 0x91, 0x80, 0x8e, 0x81, 0x96, 0x80,
-    0x8a, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10,
-    0x9d, 0x08, 0x82, 0x8e, 0x80, 0x90, 0x00, 0x2a,
-    0x10, 0x1a, 0x08, 0x00, 0x0a, 0x0a, 0x12, 0x8b,
-    0x95, 0x80, 0xb3, 0x38, 0x10, 0x96, 0x80, 0x8f,
-    0x10, 0x99, 0x14, 0x81, 0x9d, 0x03, 0x38, 0x10,
-    0x96, 0x80, 0x89, 0x04, 0x10, 0x9f, 0x00, 0x81,
-    0x8e, 0x81, 0x90, 0x88, 0x02, 0x80, 0xa8, 0x08,
-    0x8f, 0x04, 0x17, 0x82, 0x97, 0x2c, 0x91, 0x82,
-    0x97, 0x80, 0x88, 0x00, 0x0e, 0xb9, 0xaf, 0x01,
-    0x8b, 0x86, 0xb9, 0x08, 0x00, 0x20, 0x97, 0x00,
-    0x80, 0x89, 0x01, 0x88, 0x01, 0x20, 0x80, 0x94,
-    0x83, 0x9f, 0x80, 0xbe, 0x38, 0xa3, 0x9a, 0x84,
-    0xf2, 0xaa, 0x93, 0x80, 0x8f, 0x2b, 0x1a, 0x02,
-    0x0e, 0x13, 0x8c, 0x8b, 0x80, 0x90, 0xa5, 0x00,
-    0x20, 0x81, 0xaa, 0x80, 0x41, 0x4c, 0x03, 0x0e,
-    0x00, 0x03, 0x81, 0xa8, 0x03, 0x81, 0xa0, 0x03,
-    0x0e, 0x00, 0x03, 0x81, 0x8e, 0x80, 0xb8, 0x03,
-    0x81, 0xc2, 0xa4, 0x8f, 0x8f, 0xd5, 0x0d, 0x82,
-    0x42, 0x6b, 0x81, 0x90, 0x80, 0x99, 0x84, 0xca,
-    0x82, 0x8a, 0x86, 0x8c, 0x03, 0x8d, 0x91, 0x8d,
-    0x91, 0x8d, 0x8c, 0x02, 0x8e, 0xb3, 0xa2, 0x03,
-    0x80, 0xc2, 0xd8, 0x86, 0xa8, 0x00, 0x84, 0xc5,
-    0x89, 0x9e, 0xb0, 0x9d, 0x0c, 0x8a, 0xab, 0x83,
-    0x99, 0xb5, 0x96, 0x88, 0xb4, 0xd1, 0x80, 0xdc,
-    0xae, 0x90, 0x86, 0xb6, 0x9d, 0x8c, 0x81, 0x89,
-    0xab, 0x99, 0xa3, 0xa8, 0x82, 0x89, 0xa3, 0x81,
-    0x88, 0x86, 0xaa, 0x0a, 0xa8, 0x18, 0x28, 0x0a,
-    0x04, 0x40, 0xbf, 0xbf, 0x41, 0x15, 0x0d, 0x81,
-    0xa5, 0x0d, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x9e,
-    0x81, 0xb4, 0x06, 0x00, 0x12, 0x06, 0x13, 0x0d,
-    0x83, 0x8c, 0x22, 0x06, 0xf3, 0x80, 0x8c, 0x80,
-    0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x0d,
-    0x28, 0x00, 0x00, 0x80, 0x8f, 0x0b, 0x24, 0x18,
-    0x90, 0xa8, 0x4a, 0x76, 0xae, 0x80, 0xae, 0x80,
-    0x40, 0x84, 0x2b, 0x11, 0x8b, 0xa5, 0x00, 0x20,
-    0x81, 0xb7, 0x30, 0x8f, 0x96, 0x88, 0x30, 0x30,
-    0x30, 0x30, 0x30, 0x30, 0x30, 0x86, 0x42, 0x25,
-    0x82, 0x98, 0x88, 0x34, 0x0c, 0x83, 0xd5, 0x1c,
-    0x80, 0xd9, 0x03, 0x84, 0xaa, 0x80, 0xdd, 0x90,
-    0x9f, 0xaf, 0x8f, 0x41, 0xff, 0x59, 0xbf, 0xbf,
-    0x60, 0x51, 0xfc, 0x82, 0x44, 0x8c, 0xc2, 0xad,
-    0x81, 0x41, 0x0c, 0x82, 0x8f, 0x89, 0x81, 0x93,
-    0xae, 0x8f, 0x9e, 0x81, 0xcf, 0xa6, 0x88, 0x81,
-    0xe6, 0x81, 0xb4, 0x81, 0x88, 0xa9, 0x8c, 0x02,
-    0x03, 0x80, 0x96, 0x9c, 0xb3, 0x8d, 0xb1, 0xbd,
-    0x2a, 0x00, 0x81, 0x8a, 0x9b, 0x89, 0x96, 0x98,
-    0x9c, 0x86, 0xae, 0x9b, 0x80, 0x8f, 0x20, 0x89,
-    0x89, 0x20, 0xa8, 0x96, 0x10, 0x87, 0x93, 0x96,
-    0x10, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x00,
-    0x97, 0x11, 0x8a, 0x32, 0x8b, 0x29, 0x29, 0x85,
-    0x88, 0x30, 0x30, 0xaa, 0x80, 0x8d, 0x85, 0xf2,
-    0x9c, 0x60, 0x2b, 0xa3, 0x8b, 0x96, 0x83, 0xb0,
-    0x60, 0x21, 0x03, 0x41, 0x6d, 0x81, 0xe9, 0xa5,
-    0x86, 0x8b, 0x24, 0x00, 0x89, 0x80, 0x8c, 0x04,
-    0x00, 0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a,
-    0x91, 0xbf, 0x81, 0xb5, 0xa7, 0x8b, 0xf3, 0x20,
-    0x40, 0x86, 0xa3, 0x99, 0x85, 0x99, 0x8a, 0xd8,
-    0x15, 0x0d, 0x0d, 0x0a, 0xa2, 0x8b, 0x80, 0x99,
-    0x80, 0x92, 0x01, 0x80, 0x8e, 0x81, 0x8d, 0xa1,
-    0xfa, 0xc4, 0xb4, 0x41, 0x0a, 0x9c, 0x82, 0xb0,
-    0xae, 0x9f, 0x8c, 0x9d, 0x84, 0xa5, 0x89, 0x9d,
-    0x81, 0xa3, 0x1f, 0x04, 0xa9, 0x40, 0x9d, 0x91,
-    0xa3, 0x83, 0xa3, 0x83, 0xa7, 0x87, 0xb3, 0x40,
-    0x9b, 0x41, 0x36, 0x88, 0x95, 0x89, 0x87, 0x40,
-    0x97, 0x29, 0x00, 0xab, 0x01, 0x10, 0x81, 0x96,
-    0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92, 0x01, 0x89,
-    0x95, 0x89, 0x99, 0xc5, 0xb7, 0x29, 0xbf, 0x80,
-    0x8e, 0x18, 0x10, 0x9c, 0xa9, 0x9c, 0x82, 0x9c,
-    0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89, 0x95, 0x89,
-    0x92, 0x8c, 0x91, 0xed, 0xc8, 0xb6, 0xb2, 0x8c,
-    0xb2, 0x8c, 0xa3, 0x41, 0x5b, 0xa9, 0x29, 0xcd,
-    0x9c, 0x89, 0x07, 0x95, 0xe9, 0x94, 0x9a, 0x96,
-    0x8b, 0xb4, 0xca, 0xac, 0x9f, 0x98, 0x99, 0xa3,
-    0x9c, 0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d,
-    0x83, 0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98,
-    0xd3, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89, 0x86,
-    0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04,
-    0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d, 0xb4,
-    0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93, 0x08,
-    0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3, 0xaf,
-    0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6, 0x9a,
-    0x40, 0xe4, 0xab, 0xf3, 0xbf, 0x9e, 0x39, 0x01,
-    0x38, 0x08, 0x97, 0x8e, 0x00, 0x80, 0xdd, 0x39,
-    0xa6, 0x8f, 0x00, 0x80, 0x9b, 0x80, 0x89, 0xa7,
-    0x30, 0x94, 0x80, 0x8a, 0xad, 0x92, 0x80, 0xa1,
-    0xb8, 0x41, 0x06, 0x88, 0x80, 0xa4, 0x90, 0x80,
-    0xb0, 0x9d, 0xef, 0x30, 0x08, 0xa5, 0x94, 0x80,
-    0x98, 0x28, 0x08, 0x9f, 0x8d, 0x80, 0x41, 0x46,
-    0x92, 0x40, 0xbc, 0x80, 0xce, 0x43, 0x99, 0xe5,
-    0xee, 0x90, 0x40, 0xc3, 0x4a, 0xbb, 0x44, 0x2e,
-    0x4f, 0xd0, 0x42, 0x46, 0x60, 0x21, 0xb8, 0x42,
-    0x38, 0x86, 0x9e, 0xf0, 0x9d, 0x91, 0xaf, 0x8f,
-    0x83, 0x9e, 0x94, 0x84, 0x92, 0x42, 0xaf, 0xbf,
-    0xff, 0xca, 0x20, 0xc1, 0x8c, 0xbf, 0x08, 0x80,
-    0x9b, 0x57, 0xf7, 0x87, 0x44, 0xd5, 0xa9, 0x88,
-    0x60, 0x22, 0xf6, 0x41, 0x1e, 0xb0, 0x82, 0x90,
+    0x84, 0x97, 0x05, 0x90, 0xa9, 0xb9, 0xb5, 0x10,
+    0x91, 0x06, 0x89, 0x8e, 0x8f, 0x1f, 0x09, 0x81,
+    0x95, 0x06, 0x00, 0x13, 0x10, 0x8f, 0x80, 0x8c,
+    0x08, 0x82, 0x8d, 0x81, 0x89, 0x07, 0x2b, 0x09,
+    0x95, 0x06, 0x01, 0x01, 0x01, 0x9e, 0x18, 0x80,
+    0x92, 0x82, 0x8f, 0x88, 0x02, 0x80, 0x95, 0x06,
+    0x01, 0x04, 0x10, 0x91, 0x80, 0x8e, 0x81, 0x96,
+    0x80, 0x8a, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04,
+    0x10, 0x9d, 0x08, 0x82, 0x8e, 0x80, 0x90, 0x00,
+    0x2a, 0x10, 0x1a, 0x08, 0x00, 0x0a, 0x0a, 0x12,
+    0x8b, 0x95, 0x80, 0xb3, 0x38, 0x10, 0x96, 0x80,
+    0x8f, 0x10, 0x99, 0x11, 0x01, 0x81, 0x9d, 0x03,
+    0x38, 0x10, 0x96, 0x80, 0x89, 0x04, 0x10, 0x9e,
+    0x08, 0x81, 0x8e, 0x81, 0x90, 0x88, 0x02, 0x80,
+    0xa8, 0x08, 0x8f, 0x04, 0x17, 0x82, 0x97, 0x2c,
+    0x91, 0x82, 0x97, 0x80, 0x88, 0x00, 0x0e, 0xb9,
+    0xaf, 0x01, 0x8b, 0x86, 0xb9, 0x08, 0x00, 0x20,
+    0x97, 0x00, 0x80, 0x89, 0x01, 0x88, 0x01, 0x20,
+    0x80, 0x94, 0x83, 0x9f, 0x80, 0xbe, 0x38, 0xa3,
+    0x9a, 0x84, 0xf2, 0xaa, 0x93, 0x80, 0x8f, 0x2b,
+    0x1a, 0x02, 0x0e, 0x13, 0x8c, 0x8b, 0x80, 0x90,
+    0xa5, 0x00, 0x20, 0x81, 0xaa, 0x80, 0x41, 0x4c,
+    0x03, 0x0e, 0x00, 0x03, 0x81, 0xa8, 0x03, 0x81,
+    0xa0, 0x03, 0x0e, 0x00, 0x03, 0x81, 0x8e, 0x80,
+    0xb8, 0x03, 0x81, 0xc2, 0xa4, 0x8f, 0x8f, 0xd5,
+    0x0d, 0x82, 0x42, 0x6b, 0x81, 0x90, 0x80, 0x99,
+    0x84, 0xca, 0x82, 0x8a, 0x86, 0x91, 0x8c, 0x92,
+    0x8d, 0x91, 0x8d, 0x8c, 0x02, 0x8e, 0xb3, 0xa2,
+    0x03, 0x80, 0xc2, 0xd8, 0x86, 0xa8, 0x00, 0x84,
+    0xc5, 0x89, 0x9e, 0xb0, 0x9d, 0x0c, 0x8a, 0xab,
+    0x83, 0x99, 0xb5, 0x96, 0x88, 0xb4, 0xd1, 0x80,
+    0xdc, 0xae, 0x90, 0x87, 0xb5, 0x9d, 0x8c, 0x81,
+    0x89, 0xab, 0x99, 0xa3, 0xa8, 0x82, 0x89, 0xa3,
+    0x81, 0x88, 0x86, 0xaa, 0x0a, 0xa8, 0x18, 0x28,
+    0x0a, 0x04, 0x40, 0xbf, 0xbf, 0x41, 0x15, 0x0d,
+    0x81, 0xa5, 0x0d, 0x0f, 0x00, 0x00, 0x00, 0x80,
+    0x9e, 0x81, 0xb4, 0x06, 0x00, 0x12, 0x06, 0x13,
+    0x0d, 0x83, 0x8c, 0x22, 0x06, 0xf3, 0x80, 0x8c,
+    0x80, 0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00,
+    0x0d, 0x28, 0x00, 0x00, 0x80, 0x8f, 0x0b, 0x24,
+    0x18, 0x90, 0xa8, 0x4a, 0x76, 0x40, 0xe4, 0x2b,
+    0x11, 0x8b, 0xa5, 0x00, 0x20, 0x81, 0xb7, 0x30,
+    0x8f, 0x96, 0x88, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0x30, 0x30, 0x86, 0x42, 0x25, 0x82, 0x98, 0x88,
+    0x34, 0x0c, 0x83, 0xd5, 0x1c, 0x80, 0xd9, 0x03,
+    0x84, 0xaa, 0x80, 0xdd, 0x90, 0x9f, 0xaf, 0x8f,
+    0x41, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x56, 0x8c,
+    0xc2, 0xad, 0x81, 0x41, 0x0c, 0x82, 0x8f, 0x89,
+    0x81, 0x93, 0xae, 0x8f, 0x9e, 0x81, 0xcf, 0xa6,
+    0x88, 0x81, 0xe6, 0x81, 0xbf, 0x21, 0x00, 0x04,
+    0x97, 0x8f, 0x02, 0x03, 0x80, 0x96, 0x9c, 0xb3,
+    0x8d, 0xb1, 0xbd, 0x2a, 0x00, 0x81, 0x8a, 0x9b,
+    0x89, 0x96, 0x98, 0x9c, 0x86, 0xae, 0x9b, 0x80,
+    0x8f, 0x20, 0x89, 0x89, 0x20, 0xa8, 0x96, 0x10,
+    0x87, 0x93, 0x96, 0x10, 0x82, 0xb1, 0x00, 0x11,
+    0x0c, 0x08, 0x00, 0x97, 0x11, 0x8a, 0x32, 0x8b,
+    0x29, 0x29, 0x85, 0x88, 0x30, 0x30, 0xaa, 0x80,
+    0x8d, 0x85, 0xf2, 0x9c, 0x60, 0x2b, 0xa3, 0x8b,
+    0x96, 0x83, 0xb0, 0x60, 0x21, 0x03, 0x41, 0x6d,
+    0x81, 0xe9, 0xa5, 0x86, 0x8b, 0x24, 0x00, 0x89,
+    0x80, 0x8c, 0x04, 0x00, 0x01, 0x01, 0x80, 0xeb,
+    0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5, 0xa7,
+    0x8b, 0xf3, 0x20, 0x40, 0x86, 0xa3, 0x99, 0x85,
+    0x99, 0x8a, 0xd8, 0x15, 0x0d, 0x0d, 0x0a, 0xa2,
+    0x8b, 0x80, 0x99, 0x80, 0x92, 0x01, 0x80, 0x8e,
+    0x81, 0x8d, 0xa1, 0xfa, 0xc4, 0xb4, 0x41, 0x0a,
+    0x9c, 0x82, 0xb0, 0xae, 0x9f, 0x8c, 0x9d, 0x84,
+    0xa5, 0x89, 0x9d, 0x81, 0xa3, 0x1f, 0x04, 0xa9,
+    0x40, 0x9d, 0x91, 0xa3, 0x83, 0xa3, 0x83, 0xa7,
+    0x87, 0xb3, 0x8b, 0x8a, 0x80, 0x8e, 0x06, 0x01,
+    0x80, 0x8a, 0x80, 0x8e, 0x06, 0x01, 0xc2, 0x41,
+    0x36, 0x88, 0x95, 0x89, 0x87, 0x97, 0x28, 0xa9,
+    0x80, 0x88, 0xc4, 0x29, 0x00, 0xab, 0x01, 0x10,
+    0x81, 0x96, 0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92,
+    0x01, 0x89, 0x95, 0x89, 0x99, 0xc5, 0xb7, 0x29,
+    0xbf, 0x80, 0x8e, 0x18, 0x10, 0x9c, 0xa9, 0x9c,
+    0x82, 0x9c, 0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89,
+    0x95, 0x89, 0x92, 0x8c, 0x91, 0xed, 0xc8, 0xb6,
+    0xb2, 0x8c, 0xb2, 0x8c, 0xa3, 0x41, 0x5b, 0xa9,
+    0x29, 0xcd, 0x9c, 0x89, 0x07, 0x95, 0xa9, 0x91,
+    0xad, 0x94, 0x9a, 0x96, 0x8b, 0xb4, 0xb8, 0x09,
+    0x80, 0x8c, 0xac, 0x9f, 0x98, 0x99, 0xa3, 0x9c,
+    0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d, 0x83,
+    0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98, 0xd3,
+    0x30, 0x00, 0x18, 0x8e, 0x80, 0x89, 0x86, 0xae,
+    0xa5, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10,
+    0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d, 0xb4, 0x91,
+    0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93, 0x08, 0x80,
+    0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3, 0xaf, 0x93,
+    0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6, 0x9a, 0xa4,
+    0x86, 0x40, 0xb8, 0xab, 0xf3, 0xbf, 0x9e, 0x39,
+    0x01, 0x38, 0x08, 0x97, 0x8e, 0x00, 0x80, 0xdd,
+    0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b, 0x80, 0x89,
+    0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad, 0x92, 0x80,
+    0x91, 0xc8, 0x41, 0x06, 0x88, 0x80, 0xa4, 0x90,
+    0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08, 0xa5, 0x94,
+    0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d, 0x80, 0x41,
+    0x46, 0x92, 0x40, 0xbc, 0x80, 0xce, 0x43, 0x99,
+    0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0x4b, 0xe0,
+    0x8e, 0x44, 0x2e, 0x4f, 0xd0, 0x42, 0x46, 0x60,
+    0x21, 0xb8, 0x42, 0x38, 0x86, 0x9e, 0x90, 0xce,
+    0x90, 0x9d, 0x91, 0xaf, 0x8f, 0x83, 0x9e, 0x94,
+    0x84, 0x92, 0x42, 0xaf, 0xbf, 0xff, 0xca, 0x20,
+    0xc1, 0x8c, 0xbf, 0x08, 0x80, 0x9b, 0x57, 0xf7,
+    0x87, 0x44, 0xd5, 0xa9, 0x88, 0x60, 0x22, 0xe6,
+    0x18, 0x30, 0x08, 0x41, 0x22, 0xac, 0x82, 0x90,
     0x1f, 0x41, 0x8b, 0x49, 0x03, 0xea, 0x84, 0x8c,
     0x82, 0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80,
     0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00,
@@ -411,131 +422,133 @@ static const uint8_t unicode_prop_ID_Start_table[1045] = {
     0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81,
     0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
     0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x07, 0x49, 0x33, 0xac, 0x89,
-    0x86, 0x8f, 0x80, 0x41, 0x70, 0xab, 0x45, 0x13,
-    0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44, 0xb3, 0x18,
-    0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00,
-    0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b,
-    0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90,
-    0x22, 0x04, 0x80, 0x90, 0x51, 0x43, 0x60, 0xa6,
-    0xdd, 0xa1, 0x50, 0x34, 0x8a, 0x40, 0xdd, 0x81,
-    0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c, 0x1e, 0x42,
-    0x1d, 0x45, 0xe1, 0x53, 0x4a,
+    0x9e, 0x80, 0x98, 0x07, 0x47, 0x33, 0x9e, 0x41,
+    0xe0, 0xac, 0x89, 0x86, 0x8f, 0x80, 0x41, 0x40,
+    0x9d, 0x91, 0xab, 0x44, 0xf3, 0x30, 0x18, 0x08,
+    0x8e, 0x80, 0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44,
+    0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89,
+    0x03, 0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02,
+    0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89,
+    0x80, 0x90, 0x22, 0x04, 0x80, 0x90, 0x51, 0x43,
+    0x60, 0xa6, 0xdf, 0x9f, 0x50, 0x38, 0x86, 0x40,
+    0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c,
+    0x1e, 0x42, 0x1d, 0x45, 0xe1, 0x53, 0x4a,
 };
 
-static const uint8_t unicode_prop_ID_Start_index[99] = {
+static const uint8_t unicode_prop_ID_Start_index[102] = {
     0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xa9, 0x09,
-    0x00, 0xb4, 0x0a, 0x00, 0xba, 0x0b, 0x00, 0x3e,
-    0x0d, 0x00, 0xe0, 0x0e, 0x20, 0x57, 0x12, 0x00,
-    0xeb, 0x16, 0x00, 0xca, 0x19, 0x20, 0xc0, 0x1d,
-    0x60, 0x80, 0x20, 0x00, 0x2e, 0x2d, 0x00, 0xc0,
-    0x31, 0x20, 0x89, 0xa7, 0x20, 0xf0, 0xa9, 0x00,
-    0xe3, 0xab, 0x00, 0x3e, 0xfd, 0x00, 0xfb, 0x00,
-    0x21, 0x37, 0x07, 0x61, 0x01, 0x0a, 0x01, 0x1d,
-    0x0f, 0x21, 0x2c, 0x12, 0x01, 0xc8, 0x14, 0x21,
-    0xd1, 0x19, 0x21, 0x47, 0x1d, 0x01, 0x39, 0x6a,
-    0x21, 0x09, 0x8d, 0x01, 0xbc, 0xd4, 0x01, 0xa9,
-    0xd7, 0x21, 0x3a, 0xee, 0x01, 0xde, 0xa6, 0x22,
-    0x4b, 0x13, 0x03,
+    0x20, 0xb1, 0x0a, 0x00, 0xba, 0x0b, 0x20, 0x3b,
+    0x0d, 0x20, 0xc7, 0x0e, 0x20, 0x49, 0x12, 0x00,
+    0x9b, 0x16, 0x00, 0xac, 0x19, 0x00, 0xc0, 0x1d,
+    0x80, 0x80, 0x20, 0x20, 0x70, 0x2d, 0x00, 0x00,
+    0x32, 0x00, 0xda, 0xa7, 0x00, 0x4c, 0xaa, 0x20,
+    0xc7, 0xd7, 0x20, 0xfc, 0xfd, 0x20, 0x9d, 0x02,
+    0x21, 0x96, 0x05, 0x01, 0xf3, 0x08, 0x01, 0xb3,
+    0x0c, 0x21, 0x73, 0x11, 0x61, 0x3e, 0x13, 0x01,
+    0x47, 0x17, 0x21, 0x9e, 0x1a, 0x01, 0x9a, 0x23,
+    0x01, 0x78, 0x6b, 0x01, 0xfc, 0xb2, 0x61, 0x3a,
+    0xd5, 0x01, 0x2d, 0xe1, 0x41, 0x33, 0xee, 0x01,
+    0xe0, 0xa6, 0x62, 0x4b, 0x13, 0x03,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_table[626] = {
+static const uint8_t unicode_prop_ID_Continue1_table[640] = {
     0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47,
     0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
     0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf,
     0x9e, 0x28, 0xe4, 0x31, 0x29, 0x08, 0x19, 0x89,
     0x96, 0x80, 0x9d, 0x9a, 0xda, 0x8a, 0x8e, 0x89,
     0xa0, 0x88, 0x88, 0x80, 0x97, 0x18, 0x88, 0x02,
-    0x04, 0xaa, 0x82, 0xf6, 0x8e, 0x80, 0xa0, 0xb5,
-    0x10, 0x91, 0x06, 0x89, 0x09, 0x89, 0x90, 0x82,
-    0xb7, 0x00, 0x31, 0x09, 0x82, 0x88, 0x80, 0x89,
-    0x09, 0x89, 0x8d, 0x01, 0x82, 0xb7, 0x00, 0x23,
-    0x09, 0x12, 0x80, 0x93, 0x8b, 0x10, 0x8a, 0x82,
-    0xb7, 0x00, 0x38, 0x10, 0x82, 0x93, 0x09, 0x89,
-    0x89, 0x28, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x16,
-    0x82, 0x89, 0x09, 0x89, 0x91, 0x80, 0xba, 0x22,
-    0x10, 0x83, 0x88, 0x80, 0x8d, 0x89, 0x8f, 0x84,
-    0xb8, 0x30, 0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89,
-    0x90, 0x82, 0xb7, 0x00, 0x30, 0x10, 0x1e, 0x81,
-    0x8a, 0x09, 0x89, 0x8f, 0x83, 0xb6, 0x08, 0x30,
-    0x10, 0x83, 0x88, 0x80, 0x89, 0x09, 0x89, 0x90,
-    0x82, 0xc5, 0x03, 0x28, 0x00, 0x3d, 0x89, 0x09,
-    0xbc, 0x01, 0x86, 0x8b, 0x38, 0x89, 0xd6, 0x01,
-    0x88, 0x8a, 0x29, 0x89, 0xbd, 0x0d, 0x89, 0x8a,
-    0x00, 0x00, 0x03, 0x81, 0xb0, 0x93, 0x01, 0x84,
-    0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe3, 0x93, 0x80,
-    0x89, 0x8b, 0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c,
-    0x8b, 0x80, 0x8e, 0x42, 0xbe, 0x82, 0x88, 0x88,
-    0x43, 0x9f, 0x82, 0x9c, 0x82, 0x9c, 0x81, 0x9d,
-    0x81, 0xbf, 0x9f, 0x88, 0x01, 0x89, 0xa0, 0x11,
-    0x89, 0x40, 0x8e, 0x80, 0xf5, 0x8b, 0x83, 0x8b,
-    0x89, 0x89, 0xff, 0x8a, 0xbb, 0x84, 0xb8, 0x89,
-    0x80, 0x9c, 0x81, 0x8a, 0x85, 0x89, 0x95, 0x8d,
-    0x01, 0xbe, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90,
-    0x88, 0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab,
-    0x8d, 0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5,
-    0x10, 0x94, 0x18, 0x28, 0x0a, 0x40, 0xc5, 0xb9,
-    0x04, 0x42, 0x3e, 0x81, 0x92, 0x80, 0xfa, 0x8c,
-    0x18, 0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c,
-    0x80, 0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81,
-    0x60, 0x75, 0x84, 0x89, 0xc4, 0x03, 0x89, 0x9f,
-    0x81, 0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80,
-    0x96, 0x23, 0x80, 0xd2, 0x81, 0xb1, 0x91, 0x89,
-    0x89, 0x85, 0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98,
-    0x8c, 0xab, 0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a,
-    0x80, 0x89, 0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09,
-    0x89, 0xa0, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08,
-    0x80, 0xa8, 0x24, 0x81, 0x40, 0xeb, 0x38, 0x09,
-    0x89, 0x60, 0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f,
-    0x8f, 0x8f, 0x11, 0x97, 0x82, 0x40, 0xbf, 0x89,
-    0xa4, 0x80, 0x42, 0xbc, 0x80, 0x40, 0xe1, 0x80,
-    0x40, 0x94, 0x84, 0x41, 0x24, 0x89, 0x45, 0x56,
-    0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4,
-    0x81, 0x42, 0x3c, 0x1f, 0x89, 0x41, 0x70, 0x81,
-    0x40, 0x98, 0x8a, 0x40, 0xae, 0x82, 0xb4, 0x8e,
-    0x9e, 0x89, 0x8e, 0x83, 0xac, 0x8a, 0xb4, 0x89,
-    0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21, 0xab, 0x80,
-    0x8b, 0x82, 0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1,
-    0x8b, 0x28, 0x40, 0x9f, 0x8b, 0x84, 0x89, 0x2b,
-    0xb6, 0x08, 0x31, 0x09, 0x82, 0x88, 0x80, 0x89,
-    0x09, 0x32, 0x84, 0x40, 0xbf, 0x91, 0x88, 0x89,
-    0x18, 0xd0, 0x93, 0x8b, 0x89, 0x40, 0xd4, 0x31,
-    0x88, 0x9a, 0x81, 0xd1, 0x90, 0x8e, 0x89, 0xd0,
-    0x8c, 0x87, 0x89, 0xd2, 0x8e, 0x83, 0x89, 0x40,
-    0xf1, 0x8e, 0x40, 0xa4, 0x89, 0xc5, 0x28, 0x09,
-    0x18, 0x00, 0x81, 0x8b, 0x89, 0xf6, 0x31, 0x32,
-    0x80, 0x9b, 0x89, 0xa7, 0x30, 0x1f, 0x80, 0x88,
-    0x8a, 0xad, 0x8f, 0x41, 0x94, 0x38, 0x87, 0x8f,
-    0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00,
-    0x08, 0x30, 0x07, 0x89, 0xaf, 0x20, 0x08, 0x27,
-    0x89, 0x41, 0x48, 0x83, 0x60, 0x4b, 0x68, 0x89,
-    0x40, 0x85, 0x84, 0xba, 0x86, 0x98, 0x89, 0x43,
-    0xf4, 0x00, 0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81,
-    0x60, 0x4c, 0xaa, 0x81, 0x54, 0xc5, 0x22, 0x2f,
-    0x39, 0x86, 0x9d, 0x83, 0x40, 0x93, 0x82, 0x45,
-    0x88, 0xb1, 0x41, 0xff, 0xb6, 0x83, 0xb1, 0x38,
-    0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f, 0x30,
-    0x90, 0x0e, 0x01, 0x04, 0x41, 0x04, 0x86, 0x88,
-    0x89, 0x41, 0xa1, 0x8d, 0x45, 0xd5, 0x86, 0xec,
-    0x34, 0x89, 0x52, 0x95, 0x89, 0x6c, 0x05, 0x05,
-    0x40, 0xef,
+    0x04, 0xaa, 0x82, 0xbb, 0x87, 0xa9, 0x97, 0x80,
+    0xa0, 0xb5, 0x10, 0x91, 0x06, 0x89, 0x09, 0x89,
+    0x90, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x82, 0x88,
+    0x80, 0x89, 0x09, 0x89, 0x8d, 0x01, 0x82, 0xb7,
+    0x00, 0x23, 0x09, 0x12, 0x80, 0x93, 0x8b, 0x10,
+    0x8a, 0x82, 0xb7, 0x00, 0x38, 0x10, 0x82, 0x93,
+    0x09, 0x89, 0x89, 0x28, 0x82, 0xb7, 0x00, 0x31,
+    0x09, 0x16, 0x82, 0x89, 0x09, 0x89, 0x91, 0x80,
+    0xba, 0x22, 0x10, 0x83, 0x88, 0x80, 0x8d, 0x89,
+    0x8f, 0x84, 0xb6, 0x00, 0x30, 0x10, 0x1e, 0x81,
+    0x8a, 0x09, 0x89, 0x90, 0x82, 0xb7, 0x00, 0x30,
+    0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89, 0x8f, 0x83,
+    0xb6, 0x08, 0x30, 0x10, 0x83, 0x88, 0x80, 0x89,
+    0x09, 0x89, 0x90, 0x82, 0xc5, 0x03, 0x28, 0x00,
+    0x3d, 0x89, 0x09, 0xbc, 0x01, 0x86, 0x8b, 0x38,
+    0x89, 0xd6, 0x01, 0x88, 0x8a, 0x29, 0x89, 0xbd,
+    0x0d, 0x89, 0x8a, 0x00, 0x00, 0x03, 0x81, 0xb0,
+    0x93, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80,
+    0xe3, 0x93, 0x80, 0x89, 0x8b, 0x1b, 0x10, 0x11,
+    0x32, 0x83, 0x8c, 0x8b, 0x80, 0x8e, 0x42, 0xbe,
+    0x82, 0x88, 0x88, 0x43, 0x9f, 0x83, 0x9b, 0x82,
+    0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x9f, 0x88, 0x01,
+    0x89, 0xa0, 0x10, 0x8a, 0x40, 0x8e, 0x80, 0xf5,
+    0x8b, 0x83, 0x8b, 0x89, 0x89, 0xff, 0x8a, 0xbb,
+    0x84, 0xb8, 0x89, 0x80, 0x9c, 0x81, 0x8a, 0x85,
+    0x89, 0x95, 0x8d, 0x80, 0x8f, 0xb0, 0x84, 0xae,
+    0x90, 0x8a, 0x89, 0x90, 0x88, 0x8b, 0x82, 0x9d,
+    0x8c, 0x81, 0x89, 0xab, 0x8d, 0xaf, 0x93, 0x87,
+    0x89, 0x85, 0x89, 0xf5, 0x10, 0x94, 0x18, 0x28,
+    0x0a, 0x40, 0xc5, 0xbf, 0x42, 0x3e, 0x81, 0x92,
+    0x80, 0xfa, 0x8c, 0x18, 0x82, 0x8b, 0x4b, 0xfd,
+    0x82, 0x40, 0x8c, 0x80, 0xdf, 0x9f, 0x42, 0x29,
+    0x85, 0xe8, 0x81, 0x60, 0x75, 0x84, 0x89, 0xc4,
+    0x03, 0x89, 0x9f, 0x81, 0xcf, 0x81, 0x41, 0x0f,
+    0x02, 0x03, 0x80, 0x96, 0x23, 0x80, 0xd2, 0x81,
+    0xb1, 0x91, 0x89, 0x89, 0x85, 0x91, 0x8c, 0x8a,
+    0x9b, 0x87, 0x98, 0x8c, 0xab, 0x83, 0xae, 0x8d,
+    0x8e, 0x89, 0x8a, 0x80, 0x89, 0x89, 0xae, 0x8d,
+    0x8b, 0x07, 0x09, 0x89, 0xa0, 0x82, 0xb1, 0x00,
+    0x11, 0x0c, 0x08, 0x80, 0xa8, 0x24, 0x81, 0x40,
+    0xeb, 0x38, 0x09, 0x89, 0x60, 0x4f, 0x23, 0x80,
+    0x42, 0xe0, 0x8f, 0x8f, 0x8f, 0x11, 0x97, 0x82,
+    0x40, 0xbf, 0x89, 0xa4, 0x80, 0x42, 0xbc, 0x80,
+    0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x41, 0x24,
+    0x89, 0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7, 0x13,
+    0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f, 0x89,
+    0x41, 0x70, 0x81, 0x40, 0x98, 0x8a, 0xb0, 0x83,
+    0xf9, 0x82, 0xb4, 0x8e, 0x9e, 0x8a, 0x09, 0x89,
+    0x83, 0xac, 0x8a, 0x30, 0xac, 0x89, 0x2a, 0xa3,
+    0x8d, 0x80, 0x89, 0x21, 0xab, 0x80, 0x8b, 0x82,
+    0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1, 0x8b, 0x28,
+    0x40, 0x9f, 0x8b, 0x84, 0x89, 0x2b, 0xb6, 0x08,
+    0x31, 0x09, 0x82, 0x88, 0x80, 0x89, 0x09, 0x32,
+    0x84, 0x40, 0xbf, 0x91, 0x88, 0x89, 0x18, 0xd0,
+    0x93, 0x8b, 0x89, 0x40, 0xd4, 0x31, 0x88, 0x9a,
+    0x81, 0xd1, 0x90, 0x8e, 0x89, 0xd0, 0x8c, 0x87,
+    0x89, 0xd2, 0x8e, 0x83, 0x89, 0x40, 0xf1, 0x8e,
+    0x40, 0xa4, 0x89, 0xc5, 0x28, 0x09, 0x18, 0x00,
+    0x81, 0x8b, 0x89, 0xf6, 0x31, 0x32, 0x80, 0x9b,
+    0x89, 0xa7, 0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad,
+    0x8f, 0x41, 0x94, 0x38, 0x87, 0x8f, 0x89, 0xb7,
+    0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x30,
+    0x07, 0x89, 0xaf, 0x20, 0x08, 0x27, 0x89, 0x41,
+    0x48, 0x83, 0x60, 0x4b, 0x68, 0x89, 0xd5, 0x89,
+    0xa5, 0x84, 0xba, 0x86, 0x98, 0x89, 0x43, 0xf4,
+    0x00, 0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81, 0x60,
+    0x4c, 0xaa, 0x81, 0x52, 0x60, 0xad, 0x81, 0x96,
+    0x42, 0x1d, 0x22, 0x2f, 0x39, 0x86, 0x9d, 0x83,
+    0x40, 0x93, 0x82, 0x45, 0x88, 0xb1, 0x41, 0xff,
+    0xb6, 0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20,
+    0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04,
+    0x41, 0x04, 0x86, 0x88, 0x89, 0x41, 0x63, 0x80,
+    0xbc, 0x8d, 0x45, 0xd5, 0x86, 0xec, 0x34, 0x89,
+    0x52, 0x95, 0x89, 0x6c, 0x05, 0x05, 0x40, 0xef,
 };
 
 static const uint8_t unicode_prop_ID_Continue1_index[60] = {
-    0xfa, 0x06, 0x00, 0x84, 0x09, 0x00, 0xf0, 0x0a,
-    0x00, 0x70, 0x0c, 0x00, 0xf4, 0x0d, 0x00, 0x4a,
-    0x10, 0x20, 0x1a, 0x18, 0x20, 0x74, 0x1b, 0x20,
-    0xdd, 0x20, 0x00, 0x0c, 0xa8, 0x00, 0x5a, 0xaa,
-    0x20, 0x1a, 0xff, 0x00, 0xad, 0x0e, 0x01, 0x38,
-    0x12, 0x21, 0xc1, 0x15, 0x21, 0xe5, 0x19, 0x21,
-    0xaa, 0x1d, 0x21, 0x8c, 0xd1, 0x41, 0x4a, 0xe1,
+    0xfa, 0x06, 0x00, 0x70, 0x09, 0x00, 0xf0, 0x0a,
+    0x40, 0x57, 0x0c, 0x00, 0xf0, 0x0d, 0x40, 0xc7,
+    0x0f, 0x00, 0xea, 0x17, 0x20, 0x45, 0x1b, 0x20,
+    0x55, 0x20, 0x20, 0x0c, 0xa8, 0x60, 0x37, 0xaa,
+    0x00, 0x50, 0xfe, 0x00, 0x3a, 0x0d, 0x01, 0x83,
+    0x11, 0x01, 0xc4, 0x14, 0x21, 0x44, 0x19, 0x21,
+    0x5a, 0x1d, 0x41, 0x9f, 0xbc, 0x61, 0xb0, 0xda,
     0x21, 0xf0, 0x01, 0x0e,
 };
 
 #ifdef CONFIG_ALL_UNICODE
 
-static const uint8_t unicode_cc_table[851] = {
+static const uint8_t unicode_cc_table[881] = {
     0xb2, 0xcf, 0xd4, 0x00, 0xe8, 0x03, 0xdc, 0x00,
     0xe8, 0x00, 0xd8, 0x04, 0xdc, 0x01, 0xca, 0x03,
     0xdc, 0x01, 0xca, 0x0a, 0xdc, 0x04, 0x01, 0x03,
@@ -559,34 +572,36 @@ static const uint8_t unicode_cc_table[851] = {
     0xc0, 0x00, 0xdc, 0xc0, 0x00, 0xdc, 0xc1, 0xb0,
     0x6f, 0xc6, 0x00, 0xdc, 0xc0, 0x88, 0x00, 0xdc,
     0x97, 0xc3, 0x80, 0xc8, 0x80, 0xc2, 0x80, 0xc4,
-    0xaa, 0x02, 0xdc, 0xb0, 0x46, 0x00, 0xdc, 0xcd,
-    0x80, 0x00, 0xdc, 0xc1, 0x00, 0xdc, 0xc1, 0x00,
-    0xdc, 0xc2, 0x02, 0xdc, 0x42, 0x1b, 0xc2, 0x00,
-    0xdc, 0xc1, 0x01, 0xdc, 0xc4, 0xb0, 0x0b, 0x00,
-    0x07, 0x8f, 0x00, 0x09, 0x82, 0xc0, 0x00, 0xdc,
-    0xc1, 0xb0, 0x36, 0x00, 0x07, 0x8f, 0x00, 0x09,
-    0xaf, 0xc0, 0xb0, 0x0c, 0x00, 0x07, 0x8f, 0x00,
+    0xaa, 0x02, 0xdc, 0xb0, 0x0b, 0xc0, 0x02, 0xdc,
+    0xc3, 0xa9, 0xc4, 0x04, 0xdc, 0xcd, 0x80, 0x00,
+    0xdc, 0xc1, 0x00, 0xdc, 0xc1, 0x00, 0xdc, 0xc2,
+    0x02, 0xdc, 0x42, 0x1b, 0xc2, 0x00, 0xdc, 0xc1,
+    0x01, 0xdc, 0xc4, 0xb0, 0x0b, 0x00, 0x07, 0x8f,
+    0x00, 0x09, 0x82, 0xc0, 0x00, 0xdc, 0xc1, 0xb0,
+    0x36, 0x00, 0x07, 0x8f, 0x00, 0x09, 0xaf, 0xc0,
+    0xb0, 0x0c, 0x00, 0x07, 0x8f, 0x00, 0x09, 0xb0,
+    0x3d, 0x00, 0x07, 0x8f, 0x00, 0x09, 0xb0, 0x3d,
+    0x00, 0x07, 0x8f, 0x00, 0x09, 0xb0, 0x4e, 0x00,
     0x09, 0xb0, 0x3d, 0x00, 0x07, 0x8f, 0x00, 0x09,
-    0xb0, 0x3d, 0x00, 0x07, 0x8f, 0x00, 0x09, 0xb0,
-    0x4e, 0x00, 0x09, 0xb0, 0x4e, 0x00, 0x09, 0x86,
-    0x00, 0x54, 0x00, 0x5b, 0xb0, 0x34, 0x00, 0x07,
-    0x8f, 0x00, 0x09, 0xb0, 0x3c, 0x01, 0x09, 0x8f,
-    0x00, 0x09, 0xb0, 0x4b, 0x00, 0x09, 0xb0, 0x3c,
-    0x01, 0x67, 0x00, 0x09, 0x8c, 0x03, 0x6b, 0xb0,
-    0x3b, 0x01, 0x76, 0x00, 0x09, 0x8c, 0x03, 0x7a,
-    0xb0, 0x1b, 0x01, 0xdc, 0x9a, 0x00, 0xdc, 0x80,
-    0x00, 0xdc, 0x80, 0x00, 0xd8, 0xb0, 0x06, 0x41,
-    0x81, 0x80, 0x00, 0x84, 0x84, 0x03, 0x82, 0x81,
-    0x00, 0x82, 0x80, 0xc1, 0x00, 0x09, 0x80, 0xc1,
-    0xb0, 0x0d, 0x00, 0xdc, 0xb0, 0x3f, 0x00, 0x07,
-    0x80, 0x01, 0x09, 0xb0, 0x21, 0x00, 0xdc, 0xb2,
-    0x9e, 0xc2, 0xb3, 0x83, 0x00, 0x09, 0x9e, 0x00,
-    0x09, 0xb0, 0x6c, 0x00, 0x09, 0x89, 0xc0, 0xb0,
-    0x9a, 0x00, 0xe4, 0xb0, 0x5e, 0x00, 0xde, 0xc0,
-    0x00, 0xdc, 0xb0, 0xaa, 0xc0, 0x00, 0xdc, 0xb0,
-    0x16, 0x00, 0x09, 0x93, 0xc7, 0x81, 0x00, 0xdc,
-    0xaf, 0xc4, 0x05, 0xdc, 0xc1, 0x00, 0xdc, 0x80,
-    0x01, 0xdc, 0xb0, 0x42, 0x00, 0x07, 0x8e, 0x00,
+    0x86, 0x00, 0x54, 0x00, 0x5b, 0xb0, 0x34, 0x00,
+    0x07, 0x8f, 0x00, 0x09, 0xb0, 0x3c, 0x01, 0x09,
+    0x8f, 0x00, 0x09, 0xb0, 0x4b, 0x00, 0x09, 0xb0,
+    0x3c, 0x01, 0x67, 0x00, 0x09, 0x8c, 0x03, 0x6b,
+    0xb0, 0x3b, 0x01, 0x76, 0x00, 0x09, 0x8c, 0x03,
+    0x7a, 0xb0, 0x1b, 0x01, 0xdc, 0x9a, 0x00, 0xdc,
+    0x80, 0x00, 0xdc, 0x80, 0x00, 0xd8, 0xb0, 0x06,
+    0x41, 0x81, 0x80, 0x00, 0x84, 0x84, 0x03, 0x82,
+    0x81, 0x00, 0x82, 0x80, 0xc1, 0x00, 0x09, 0x80,
+    0xc1, 0xb0, 0x0d, 0x00, 0xdc, 0xb0, 0x3f, 0x00,
+    0x07, 0x80, 0x01, 0x09, 0xb0, 0x21, 0x00, 0xdc,
+    0xb2, 0x9e, 0xc2, 0xb3, 0x83, 0x01, 0x09, 0x9d,
+    0x00, 0x09, 0xb0, 0x6c, 0x00, 0x09, 0x89, 0xc0,
+    0xb0, 0x9a, 0x00, 0xe4, 0xb0, 0x5e, 0x00, 0xde,
+    0xc0, 0x00, 0xdc, 0xb0, 0xaa, 0xc0, 0x00, 0xdc,
+    0xb0, 0x16, 0x00, 0x09, 0x93, 0xc7, 0x81, 0x00,
+    0xdc, 0xaf, 0xc4, 0x05, 0xdc, 0xc1, 0x00, 0xdc,
+    0x80, 0x01, 0xdc, 0xc1, 0x01, 0xdc, 0xc4, 0x00,
+    0xdc, 0xc3, 0xb0, 0x34, 0x00, 0x07, 0x8e, 0x00,
     0x09, 0xa5, 0xc0, 0x00, 0xdc, 0xc6, 0xb0, 0x05,
     0x01, 0x09, 0xb0, 0x09, 0x00, 0x07, 0x8a, 0x01,
     0x09, 0xb0, 0x12, 0x00, 0x07, 0xb0, 0x67, 0xc2,
@@ -595,71 +610,73 @@ static const uint8_t unicode_cc_table[851] = {
     0xc0, 0x82, 0xc1, 0xb0, 0x95, 0xc1, 0x00, 0xdc,
     0xc6, 0x00, 0xdc, 0xc1, 0x00, 0xea, 0x00, 0xd6,
     0x00, 0xdc, 0x00, 0xca, 0xe4, 0x00, 0xe8, 0x01,
-    0xe4, 0x00, 0xdc, 0x80, 0xc0, 0x00, 0xe9, 0x00,
-    0xdc, 0xc0, 0x00, 0xdc, 0xb2, 0x9f, 0xc1, 0x01,
-    0x01, 0xc3, 0x02, 0x01, 0xc1, 0x83, 0xc0, 0x82,
-    0x01, 0x01, 0xc0, 0x00, 0xdc, 0xc0, 0x01, 0x01,
-    0x03, 0xdc, 0xc0, 0xb8, 0x03, 0xcd, 0xc2, 0xb0,
-    0x5c, 0x00, 0x09, 0xb0, 0x2f, 0xdf, 0xb1, 0xf9,
-    0x00, 0xda, 0x00, 0xe4, 0x00, 0xe8, 0x00, 0xde,
-    0x01, 0xe0, 0xb0, 0x38, 0x01, 0x08, 0xb8, 0x6d,
-    0xa3, 0xc0, 0x83, 0xc9, 0x9f, 0xc1, 0xb0, 0x1f,
-    0xc1, 0xb0, 0xe3, 0x00, 0x09, 0xa4, 0x00, 0x09,
-    0xb0, 0x66, 0x00, 0x09, 0x9a, 0xd1, 0xb0, 0x08,
-    0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0, 0x2e, 0x00,
-    0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe, 0xc0, 0x80,
-    0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84, 0xc1, 0x80,
-    0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0, 0xc5, 0x00,
-    0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a, 0xb2, 0xd0,
-    0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c, 0x00, 0xdc,
-    0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64, 0xc4, 0xb6,
-    0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0, 0x00,
-    0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0, 0x74,
-    0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1, 0x52,
-    0xc1, 0xb0, 0x68, 0x01, 0xdc, 0xc2, 0x00, 0xdc,
-    0xc0, 0x03, 0xdc, 0xb0, 0xc4, 0x00, 0x09, 0xb0,
-    0x07, 0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00,
-    0x07, 0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0,
-    0x0d, 0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88,
-    0x00, 0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07,
-    0xb0, 0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f,
-    0x01, 0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82,
-    0xc4, 0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07,
-    0x96, 0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07,
-    0xb0, 0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d,
-    0x00, 0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07,
-    0xb0, 0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09,
-    0x00, 0x07, 0xb0, 0xd1, 0x01, 0x09, 0x83, 0x00,
-    0x07, 0xb0, 0x6b, 0x00, 0x09, 0xb0, 0x22, 0x00,
-    0x09, 0x91, 0x00, 0x09, 0xb0, 0x20, 0x00, 0x09,
-    0xb1, 0x74, 0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07,
-    0x80, 0x01, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb8,
-    0x45, 0x27, 0x04, 0x01, 0xb0, 0x0a, 0xc6, 0xb4,
-    0x88, 0x01, 0x06, 0xb8, 0x44, 0x7b, 0x00, 0x01,
-    0xb8, 0x0c, 0x95, 0x01, 0xd8, 0x02, 0x01, 0x82,
-    0x00, 0xe2, 0x04, 0xd8, 0x87, 0x07, 0xdc, 0x81,
-    0xc4, 0x01, 0xdc, 0x9d, 0xc3, 0xb0, 0x63, 0xc2,
-    0xb8, 0x05, 0x8a, 0xc6, 0x80, 0xd0, 0x81, 0xc6,
-    0x80, 0xc1, 0x80, 0xc4, 0xb0, 0xd4, 0xc6, 0xb1,
-    0x84, 0xc3, 0xb5, 0xaf, 0x06, 0xdc, 0xb0, 0x3c,
-    0xc5, 0x00, 0x07,
+    0xe4, 0x00, 0xdc, 0x00, 0xda, 0xc0, 0x00, 0xe9,
+    0x00, 0xdc, 0xc0, 0x00, 0xdc, 0xb2, 0x9f, 0xc1,
+    0x01, 0x01, 0xc3, 0x02, 0x01, 0xc1, 0x83, 0xc0,
+    0x82, 0x01, 0x01, 0xc0, 0x00, 0xdc, 0xc0, 0x01,
+    0x01, 0x03, 0xdc, 0xc0, 0xb8, 0x03, 0xcd, 0xc2,
+    0xb0, 0x5c, 0x00, 0x09, 0xb0, 0x2f, 0xdf, 0xb1,
+    0xf9, 0x00, 0xda, 0x00, 0xe4, 0x00, 0xe8, 0x00,
+    0xde, 0x01, 0xe0, 0xb0, 0x38, 0x01, 0x08, 0xb8,
+    0x6d, 0xa3, 0xc0, 0x83, 0xc9, 0x9f, 0xc1, 0xb0,
+    0x1f, 0xc1, 0xb0, 0xe3, 0x00, 0x09, 0xa4, 0x00,
+    0x09, 0xb0, 0x66, 0x00, 0x09, 0x9a, 0xd1, 0xb0,
+    0x08, 0x02, 0xdc, 0xa4, 0x00, 0x09, 0xb0, 0x2e,
+    0x00, 0x07, 0x8b, 0x00, 0x09, 0xb0, 0xbe, 0xc0,
+    0x80, 0xc1, 0x00, 0xdc, 0x81, 0xc1, 0x84, 0xc1,
+    0x80, 0xc0, 0xb0, 0x03, 0x00, 0x09, 0xb0, 0xc5,
+    0x00, 0x09, 0xb8, 0x46, 0xff, 0x00, 0x1a, 0xb2,
+    0xd0, 0xc6, 0x06, 0xdc, 0xc1, 0xb3, 0x9c, 0x00,
+    0xdc, 0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64, 0xc4,
+    0xb6, 0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0,
+    0x00, 0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0,
+    0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1,
+    0x52, 0xc1, 0xb0, 0x68, 0x01, 0xdc, 0xc2, 0x00,
+    0xdc, 0xc0, 0x03, 0xdc, 0xb0, 0x00, 0xc0, 0x00,
+    0xdc, 0xc0, 0x00, 0xdc, 0xb0, 0x8f, 0x00, 0x09,
+    0xa8, 0x00, 0x09, 0x8d, 0x00, 0x09, 0xb0, 0x08,
+    0x00, 0x09, 0x00, 0x07, 0xb0, 0x14, 0xc2, 0xaf,
+    0x01, 0x09, 0xb0, 0x0d, 0x00, 0x07, 0xb0, 0x1b,
+    0x00, 0x09, 0x88, 0x00, 0x07, 0xb0, 0x39, 0x00,
+    0x09, 0x00, 0x07, 0xb0, 0x81, 0x00, 0x07, 0x00,
+    0x09, 0xb0, 0x1f, 0x01, 0x07, 0x8f, 0x00, 0x09,
+    0x97, 0xc6, 0x82, 0xc4, 0xb0, 0x9c, 0x00, 0x09,
+    0x82, 0x00, 0x07, 0x96, 0xc0, 0xb0, 0x32, 0x00,
+    0x09, 0x00, 0x07, 0xb0, 0xca, 0x00, 0x09, 0x00,
+    0x07, 0xb0, 0x4d, 0x00, 0x09, 0xb0, 0x45, 0x00,
+    0x09, 0x00, 0x07, 0xb0, 0x42, 0x00, 0x09, 0xb0,
+    0xdc, 0x00, 0x09, 0x00, 0x07, 0xb0, 0xd1, 0x01,
+    0x09, 0x83, 0x00, 0x07, 0xb0, 0x6b, 0x00, 0x09,
+    0xb0, 0x22, 0x00, 0x09, 0x91, 0x00, 0x09, 0xb0,
+    0x20, 0x00, 0x09, 0xb1, 0x74, 0x00, 0x09, 0xb0,
+    0xd1, 0x00, 0x07, 0x80, 0x01, 0x09, 0xb0, 0x20,
+    0x00, 0x09, 0xb8, 0x45, 0x27, 0x04, 0x01, 0xb0,
+    0x0a, 0xc6, 0xb4, 0x88, 0x01, 0x06, 0xb8, 0x44,
+    0x7b, 0x00, 0x01, 0xb8, 0x0c, 0x95, 0x01, 0xd8,
+    0x02, 0x01, 0x82, 0x00, 0xe2, 0x04, 0xd8, 0x87,
+    0x07, 0xdc, 0x81, 0xc4, 0x01, 0xdc, 0x9d, 0xc3,
+    0xb0, 0x63, 0xc2, 0xb8, 0x05, 0x8a, 0xc6, 0x80,
+    0xd0, 0x81, 0xc6, 0x80, 0xc1, 0x80, 0xc4, 0xb0,
+    0xd4, 0xc6, 0xb1, 0x46, 0xc0, 0xb0, 0x0c, 0xc3,
+    0xb5, 0xaf, 0x06, 0xdc, 0xb0, 0x3c, 0xc5, 0x00,
+    0x07,
 };
 
-static const uint8_t unicode_cc_index[81] = {
+static const uint8_t unicode_cc_index[84] = {
     0x4d, 0x03, 0x00, 0x97, 0x05, 0x20, 0xc6, 0x05,
-    0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0xe2,
-    0x08, 0x00, 0x53, 0x09, 0x00, 0xcd, 0x0b, 0x20,
-    0x38, 0x0e, 0x00, 0x73, 0x0f, 0x20, 0x5d, 0x13,
-    0x20, 0x60, 0x1a, 0x20, 0xaa, 0x1b, 0x00, 0xf4,
-    0x1c, 0x00, 0xfe, 0x1d, 0x20, 0x7f, 0x2d, 0x20,
-    0xf0, 0xa6, 0x00, 0xb2, 0xaa, 0x00, 0xfe, 0x01,
-    0x01, 0xab, 0x0e, 0x01, 0x73, 0x11, 0x21, 0x70,
-    0x13, 0x01, 0xb8, 0x16, 0x01, 0x9a, 0x1a, 0x01,
-    0x9f, 0xbc, 0x01, 0x22, 0xe0, 0x01, 0x4b, 0xe9,
-    0x01,
+    0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0x9c,
+    0x08, 0x00, 0x4d, 0x09, 0x00, 0x3c, 0x0b, 0x00,
+    0x3d, 0x0d, 0x00, 0x36, 0x0f, 0x00, 0x38, 0x10,
+    0x20, 0x3a, 0x19, 0x00, 0xcb, 0x1a, 0x20, 0xd3,
+    0x1c, 0x00, 0xcf, 0x1d, 0x00, 0xe2, 0x20, 0x00,
+    0x2e, 0x30, 0x20, 0x2b, 0xa9, 0x20, 0xed, 0xab,
+    0x00, 0x39, 0x0a, 0x01, 0x84, 0x0f, 0x21, 0xc0,
+    0x11, 0x01, 0x43, 0x14, 0x01, 0x39, 0x18, 0x21,
+    0x42, 0x1d, 0x21, 0x67, 0xd1, 0x01, 0x30, 0xe1,
+    0x21, 0x4b, 0xe9, 0x01,
 };
 
-static const uint32_t unicode_decomp_table1[690] = {
+static const uint32_t unicode_decomp_table1[693] = {
     0x00280081, 0x002a0097, 0x002a8081, 0x002bc097,
     0x002c8115, 0x002d0097, 0x002d4081, 0x002e0097,
     0x002e4115, 0x002f0199, 0x00302016, 0x00400842,
@@ -786,56 +803,57 @@ static const uint32_t unicode_decomp_table1[690] = {
     0x0cf54119, 0x0cf5c097, 0x0cf6009b, 0x0cf64099,
     0x0cf68217, 0x0cf78119, 0x0cf804a1, 0x0cfa4525,
     0x0cfcc525, 0x0cff4125, 0x0cffc099, 0x29a70103,
-    0x29dc0081, 0x29fe0103, 0x2ad70203, 0x2ada4081,
-    0x3e401482, 0x3e4a7f82, 0x3e6a3f82, 0x3e8aa102,
-    0x3e9b0110, 0x3e9c2f82, 0x3eb3c590, 0x3ec00197,
-    0x3ec0c119, 0x3ec1413f, 0x3ec4c2af, 0x3ec74184,
-    0x3ec804ad, 0x3eca4081, 0x3eca8304, 0x3ecc03a0,
-    0x3ece02a0, 0x3ecf8084, 0x3ed00120, 0x3ed0c120,
-    0x3ed184ae, 0x3ed3c085, 0x3ed4312d, 0x3ef4cbad,
-    0x3efa892f, 0x3eff022d, 0x3f002f2f, 0x3f1782a5,
-    0x3f18c0b1, 0x3f1907af, 0x3f1cffaf, 0x3f3c81a5,
-    0x3f3d64af, 0x3f542031, 0x3f649b31, 0x3f7c0131,
-    0x3f7c83b3, 0x3f7e40b1, 0x3f7e80bd, 0x3f7ec0bb,
-    0x3f7f00b3, 0x3f840503, 0x3f8c01ad, 0x3f8cc315,
-    0x3f8e462d, 0x3f91cc03, 0x3f97c695, 0x3f9c01af,
-    0x3f9d0085, 0x3f9d852f, 0x3fa03aad, 0x3fbd442f,
-    0x3fc06f1f, 0x3fd7c11f, 0x3fd85fad, 0x3fe80081,
-    0x3fe84f1f, 0x3ff0831f, 0x3ff2831f, 0x3ff4831f,
-    0x3ff6819f, 0x3ff80783, 0x44268192, 0x442ac092,
-    0x444b8112, 0x44d2c112, 0x452ec212, 0x456e8112,
-    0x464e0092, 0x74578392, 0x746ec312, 0x75000d1f,
-    0x75068d1f, 0x750d0d1f, 0x7513839f, 0x7515891f,
-    0x751a0d1f, 0x75208d1f, 0x75271015, 0x752f439f,
-    0x7531459f, 0x75340d1f, 0x753a8d1f, 0x75410395,
-    0x7543441f, 0x7545839f, 0x75478d1f, 0x754e0795,
-    0x7552839f, 0x75548d1f, 0x755b0d1f, 0x75618d1f,
-    0x75680d1f, 0x756e8d1f, 0x75750d1f, 0x757b8d1f,
-    0x75820d1f, 0x75888d1f, 0x758f0d1f, 0x75958d1f,
-    0x759c0d1f, 0x75a28d1f, 0x75a90103, 0x75aa089f,
-    0x75ae4081, 0x75ae839f, 0x75b04081, 0x75b08c9f,
-    0x75b6c081, 0x75b7032d, 0x75b8889f, 0x75bcc081,
-    0x75bd039f, 0x75bec081, 0x75bf0c9f, 0x75c54081,
-    0x75c5832d, 0x75c7089f, 0x75cb4081, 0x75cb839f,
-    0x75cd4081, 0x75cd8c9f, 0x75d3c081, 0x75d4032d,
-    0x75d5889f, 0x75d9c081, 0x75da039f, 0x75dbc081,
-    0x75dc0c9f, 0x75e24081, 0x75e2832d, 0x75e4089f,
-    0x75e84081, 0x75e8839f, 0x75ea4081, 0x75ea8c9f,
-    0x75f0c081, 0x75f1042d, 0x75f3851f, 0x75f6051f,
-    0x75f8851f, 0x75fb051f, 0x75fd851f, 0x7b80022d,
-    0x7b814dad, 0x7b884203, 0x7b89c081, 0x7b8a452d,
-    0x7b8d0403, 0x7b908081, 0x7b91dc03, 0x7ba0052d,
-    0x7ba2c8ad, 0x7ba84483, 0x7baac8ad, 0x7c400097,
-    0x7c404521, 0x7c440d25, 0x7c4a8087, 0x7c4ac115,
-    0x7c4b4117, 0x7c4c0d1f, 0x7c528217, 0x7c538099,
-    0x7c53c097, 0x7c5a8197, 0x7c640097, 0x7c80012f,
-    0x7c808081, 0x7c841603, 0x7c9004c1, 0x7c940103,
-    0x7efc051f, 0xbe0001ac, 0xbe00d110, 0xbe0947ac,
-    0xbe0d3910, 0xbe29872c, 0xbe2d022c, 0xbe2e3790,
-    0xbe49ff90, 0xbe69bc10,
+    0x29dc0081, 0x29fc8195, 0x29fe0103, 0x2ad70203,
+    0x2ada4081, 0x3e401482, 0x3e4a7f82, 0x3e6a3f82,
+    0x3e8aa102, 0x3e9b0110, 0x3e9c2f82, 0x3eb3c590,
+    0x3ec00197, 0x3ec0c119, 0x3ec1413f, 0x3ec4c2af,
+    0x3ec74184, 0x3ec804ad, 0x3eca4081, 0x3eca8304,
+    0x3ecc03a0, 0x3ece02a0, 0x3ecf8084, 0x3ed00120,
+    0x3ed0c120, 0x3ed184ae, 0x3ed3c085, 0x3ed4312d,
+    0x3ef4cbad, 0x3efa892f, 0x3eff022d, 0x3f002f2f,
+    0x3f1782a5, 0x3f18c0b1, 0x3f1907af, 0x3f1cffaf,
+    0x3f3c81a5, 0x3f3d64af, 0x3f542031, 0x3f649b31,
+    0x3f7c0131, 0x3f7c83b3, 0x3f7e40b1, 0x3f7e80bd,
+    0x3f7ec0bb, 0x3f7f00b3, 0x3f840503, 0x3f8c01ad,
+    0x3f8cc315, 0x3f8e462d, 0x3f91cc03, 0x3f97c695,
+    0x3f9c01af, 0x3f9d0085, 0x3f9d852f, 0x3fa03aad,
+    0x3fbd442f, 0x3fc06f1f, 0x3fd7c11f, 0x3fd85fad,
+    0x3fe80081, 0x3fe84f1f, 0x3ff0831f, 0x3ff2831f,
+    0x3ff4831f, 0x3ff6819f, 0x3ff80783, 0x41e04d83,
+    0x41e70f91, 0x44268192, 0x442ac092, 0x444b8112,
+    0x44d2c112, 0x452ec212, 0x456e8112, 0x464e0092,
+    0x74578392, 0x746ec312, 0x75000d1f, 0x75068d1f,
+    0x750d0d1f, 0x7513839f, 0x7515891f, 0x751a0d1f,
+    0x75208d1f, 0x75271015, 0x752f439f, 0x7531459f,
+    0x75340d1f, 0x753a8d1f, 0x75410395, 0x7543441f,
+    0x7545839f, 0x75478d1f, 0x754e0795, 0x7552839f,
+    0x75548d1f, 0x755b0d1f, 0x75618d1f, 0x75680d1f,
+    0x756e8d1f, 0x75750d1f, 0x757b8d1f, 0x75820d1f,
+    0x75888d1f, 0x758f0d1f, 0x75958d1f, 0x759c0d1f,
+    0x75a28d1f, 0x75a90103, 0x75aa089f, 0x75ae4081,
+    0x75ae839f, 0x75b04081, 0x75b08c9f, 0x75b6c081,
+    0x75b7032d, 0x75b8889f, 0x75bcc081, 0x75bd039f,
+    0x75bec081, 0x75bf0c9f, 0x75c54081, 0x75c5832d,
+    0x75c7089f, 0x75cb4081, 0x75cb839f, 0x75cd4081,
+    0x75cd8c9f, 0x75d3c081, 0x75d4032d, 0x75d5889f,
+    0x75d9c081, 0x75da039f, 0x75dbc081, 0x75dc0c9f,
+    0x75e24081, 0x75e2832d, 0x75e4089f, 0x75e84081,
+    0x75e8839f, 0x75ea4081, 0x75ea8c9f, 0x75f0c081,
+    0x75f1042d, 0x75f3851f, 0x75f6051f, 0x75f8851f,
+    0x75fb051f, 0x75fd851f, 0x7b80022d, 0x7b814dad,
+    0x7b884203, 0x7b89c081, 0x7b8a452d, 0x7b8d0403,
+    0x7b908081, 0x7b91dc03, 0x7ba0052d, 0x7ba2c8ad,
+    0x7ba84483, 0x7baac8ad, 0x7c400097, 0x7c404521,
+    0x7c440d25, 0x7c4a8087, 0x7c4ac115, 0x7c4b4117,
+    0x7c4c0d1f, 0x7c528217, 0x7c538099, 0x7c53c097,
+    0x7c5a8197, 0x7c640097, 0x7c80012f, 0x7c808081,
+    0x7c841603, 0x7c9004c1, 0x7c940103, 0x7efc051f,
+    0xbe0001ac, 0xbe00d110, 0xbe0947ac, 0xbe0d3910,
+    0xbe29872c, 0xbe2d022c, 0xbe2e3790, 0xbe49ff90,
+    0xbe69bc10,
 };
 
-static const uint16_t unicode_decomp_table2[690] = {
+static const uint16_t unicode_decomp_table2[693] = {
     0x0020, 0x0000, 0x0061, 0x0002, 0x0004, 0x0006, 0x03bc, 0x0008,
     0x000a, 0x000c, 0x0015, 0x0095, 0x00a5, 0x00b9, 0x00c1, 0x00c3,
     0x00c7, 0x00cb, 0x00d1, 0x00d7, 0x00dd, 0x00e0, 0x00e6, 0x00f8,
@@ -899,33 +917,33 @@ static const uint16_t unicode_decomp_table2[690] = {
     0x10f4, 0x1100, 0x1105, 0x1111, 0x1141, 0x1149, 0x114d, 0x1153,
     0x1157, 0x115a, 0x116e, 0x1171, 0x1175, 0x117b, 0x117d, 0x1181,
     0x1184, 0x118c, 0x1192, 0x1196, 0x119c, 0x11a2, 0x11a8, 0x11ab,
-    0xa76f, 0x11af, 0x11b3, 0x028d, 0x11bb, 0x120d, 0x130b, 0x1409,
-    0x148d, 0x1492, 0x1550, 0x1569, 0x156f, 0x1575, 0x157b, 0x1587,
-    0x1593, 0x002b, 0x159e, 0x15b6, 0x15ba, 0x15be, 0x15c2, 0x15c6,
-    0x15ca, 0x15de, 0x15e2, 0x1646, 0x165f, 0x1685, 0x168b, 0x1749,
-    0x174f, 0x1754, 0x1774, 0x1874, 0x187a, 0x190e, 0x19d0, 0x1a74,
-    0x1a7c, 0x1a9a, 0x1a9f, 0x1ab3, 0x1abd, 0x1ac3, 0x1ad7, 0x1adc,
-    0x1ae2, 0x1af0, 0x1b20, 0x1b2d, 0x1b35, 0x1b39, 0x1b4f, 0x1bc6,
-    0x1bd8, 0x1bda, 0x1bdc, 0x3164, 0x1c1d, 0x1c1f, 0x1c21, 0x1c23,
-    0x1c25, 0x1c27, 0x1c45, 0x1c53, 0x1c58, 0x1c61, 0x1c6a, 0x1c7c,
-    0x1c85, 0x1c8a, 0x1caa, 0x1cc5, 0x1cc7, 0x1cc9, 0x1ccb, 0x1ccd,
-    0x1ccf, 0x1cd1, 0x1cd3, 0x1cf3, 0x1cf5, 0x1cf7, 0x1cf9, 0x1cfb,
-    0x1d02, 0x1d04, 0x1d06, 0x1d08, 0x1d17, 0x1d19, 0x1d1b, 0x1d1d,
-    0x1d1f, 0x1d21, 0x1d23, 0x1d25, 0x1d27, 0x1d29, 0x1d2b, 0x1d2d,
-    0x1d2f, 0x1d31, 0x1d33, 0x1d37, 0x03f4, 0x1d39, 0x2207, 0x1d3b,
-    0x2202, 0x1d3d, 0x1d45, 0x03f4, 0x1d47, 0x2207, 0x1d49, 0x2202,
-    0x1d4b, 0x1d53, 0x03f4, 0x1d55, 0x2207, 0x1d57, 0x2202, 0x1d59,
-    0x1d61, 0x03f4, 0x1d63, 0x2207, 0x1d65, 0x2202, 0x1d67, 0x1d6f,
-    0x03f4, 0x1d71, 0x2207, 0x1d73, 0x2202, 0x1d75, 0x1d7f, 0x1d81,
-    0x1d83, 0x1d85, 0x1d87, 0x1d89, 0x1d8f, 0x1dac, 0x062d, 0x1db4,
-    0x1dc0, 0x062c, 0x1dd0, 0x1e40, 0x1e4c, 0x1e5f, 0x1e71, 0x1e84,
-    0x1e86, 0x1e8a, 0x1e90, 0x1e96, 0x1e98, 0x1e9c, 0x1e9e, 0x1ea6,
-    0x1ea9, 0x1eab, 0x1eb1, 0x1eb3, 0x30b5, 0x1eb9, 0x1f11, 0x1f27,
-    0x1f2b, 0x1f2d, 0x1f32, 0x1f7f, 0x1f90, 0x2091, 0x20a1, 0x20a7,
-    0x21a1, 0x22bf,
+    0xa76f, 0x11af, 0x11b2, 0x11b6, 0x028d, 0x11be, 0x1210, 0x130e,
+    0x140c, 0x1490, 0x1495, 0x1553, 0x156c, 0x1572, 0x1578, 0x157e,
+    0x158a, 0x1596, 0x002b, 0x15a1, 0x15b9, 0x15bd, 0x15c1, 0x15c5,
+    0x15c9, 0x15cd, 0x15e1, 0x15e5, 0x1649, 0x1662, 0x1688, 0x168e,
+    0x174c, 0x1752, 0x1757, 0x1777, 0x1877, 0x187d, 0x1911, 0x19d3,
+    0x1a77, 0x1a7f, 0x1a9d, 0x1aa2, 0x1ab6, 0x1ac0, 0x1ac6, 0x1ada,
+    0x1adf, 0x1ae5, 0x1af3, 0x1b23, 0x1b30, 0x1b38, 0x1b3c, 0x1b52,
+    0x1bc9, 0x1bdb, 0x1bdd, 0x1bdf, 0x3164, 0x1c20, 0x1c22, 0x1c24,
+    0x1c26, 0x1c28, 0x1c2a, 0x1c48, 0x1c7e, 0x1cc4, 0x1cd2, 0x1cd7,
+    0x1ce0, 0x1ce9, 0x1cfb, 0x1d04, 0x1d09, 0x1d29, 0x1d44, 0x1d46,
+    0x1d48, 0x1d4a, 0x1d4c, 0x1d4e, 0x1d50, 0x1d52, 0x1d72, 0x1d74,
+    0x1d76, 0x1d78, 0x1d7a, 0x1d81, 0x1d83, 0x1d85, 0x1d87, 0x1d96,
+    0x1d98, 0x1d9a, 0x1d9c, 0x1d9e, 0x1da0, 0x1da2, 0x1da4, 0x1da6,
+    0x1da8, 0x1daa, 0x1dac, 0x1dae, 0x1db0, 0x1db2, 0x1db6, 0x03f4,
+    0x1db8, 0x2207, 0x1dba, 0x2202, 0x1dbc, 0x1dc4, 0x03f4, 0x1dc6,
+    0x2207, 0x1dc8, 0x2202, 0x1dca, 0x1dd2, 0x03f4, 0x1dd4, 0x2207,
+    0x1dd6, 0x2202, 0x1dd8, 0x1de0, 0x03f4, 0x1de2, 0x2207, 0x1de4,
+    0x2202, 0x1de6, 0x1dee, 0x03f4, 0x1df0, 0x2207, 0x1df2, 0x2202,
+    0x1df4, 0x1dfe, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 0x1e0e,
+    0x1e2b, 0x062d, 0x1e33, 0x1e3f, 0x062c, 0x1e4f, 0x1ebf, 0x1ecb,
+    0x1ede, 0x1ef0, 0x1f03, 0x1f05, 0x1f09, 0x1f0f, 0x1f15, 0x1f17,
+    0x1f1b, 0x1f1d, 0x1f25, 0x1f28, 0x1f2a, 0x1f30, 0x1f32, 0x30b5,
+    0x1f38, 0x1f90, 0x1fa6, 0x1faa, 0x1fac, 0x1fb1, 0x1ffe, 0x200f,
+    0x2110, 0x2120, 0x2126, 0x2220, 0x233e,
 };
 
-static const uint8_t unicode_decomp_data[9165] = {
+static const uint8_t unicode_decomp_data[9292] = {
     0x20, 0x88, 0x20, 0x84, 0x32, 0x33, 0x20, 0x81,
     0x20, 0xa7, 0x31, 0x6f, 0x31, 0xd0, 0x34, 0x31,
     0xd0, 0x32, 0x33, 0xd0, 0x34, 0x41, 0x80, 0x41,
@@ -1491,587 +1509,603 @@ static const uint8_t unicode_decomp_data[9165] = {
     0xd1, 0x6d, 0x31, 0x00, 0xe5, 0x65, 0x31, 0x00,
     0x30, 0x00, 0xe5, 0x65, 0x32, 0x00, 0x30, 0x00,
     0xe5, 0x65, 0x33, 0x00, 0x30, 0x00, 0xe5, 0x65,
-    0x67, 0x61, 0x6c, 0x4a, 0x04, 0x4c, 0x04, 0x26,
-    0x01, 0x53, 0x01, 0x27, 0xa7, 0x37, 0xab, 0x6b,
-    0x02, 0x52, 0xab, 0x48, 0x8c, 0xf4, 0x66, 0xca,
-    0x8e, 0xc8, 0x8c, 0xd1, 0x6e, 0x32, 0x4e, 0xe5,
-    0x53, 0x9c, 0x9f, 0x9c, 0x9f, 0x51, 0x59, 0xd1,
-    0x91, 0x87, 0x55, 0x48, 0x59, 0xf6, 0x61, 0x69,
-    0x76, 0x85, 0x7f, 0x3f, 0x86, 0xba, 0x87, 0xf8,
-    0x88, 0x8f, 0x90, 0x02, 0x6a, 0x1b, 0x6d, 0xd9,
-    0x70, 0xde, 0x73, 0x3d, 0x84, 0x6a, 0x91, 0xf1,
-    0x99, 0x82, 0x4e, 0x75, 0x53, 0x04, 0x6b, 0x1b,
-    0x72, 0x2d, 0x86, 0x1e, 0x9e, 0x50, 0x5d, 0xeb,
-    0x6f, 0xcd, 0x85, 0x64, 0x89, 0xc9, 0x62, 0xd8,
-    0x81, 0x1f, 0x88, 0xca, 0x5e, 0x17, 0x67, 0x6a,
-    0x6d, 0xfc, 0x72, 0xce, 0x90, 0x86, 0x4f, 0xb7,
-    0x51, 0xde, 0x52, 0xc4, 0x64, 0xd3, 0x6a, 0x10,
-    0x72, 0xe7, 0x76, 0x01, 0x80, 0x06, 0x86, 0x5c,
-    0x86, 0xef, 0x8d, 0x32, 0x97, 0x6f, 0x9b, 0xfa,
-    0x9d, 0x8c, 0x78, 0x7f, 0x79, 0xa0, 0x7d, 0xc9,
-    0x83, 0x04, 0x93, 0x7f, 0x9e, 0xd6, 0x8a, 0xdf,
-    0x58, 0x04, 0x5f, 0x60, 0x7c, 0x7e, 0x80, 0x62,
-    0x72, 0xca, 0x78, 0xc2, 0x8c, 0xf7, 0x96, 0xd8,
-    0x58, 0x62, 0x5c, 0x13, 0x6a, 0xda, 0x6d, 0x0f,
-    0x6f, 0x2f, 0x7d, 0x37, 0x7e, 0x4b, 0x96, 0xd2,
-    0x52, 0x8b, 0x80, 0xdc, 0x51, 0xcc, 0x51, 0x1c,
-    0x7a, 0xbe, 0x7d, 0xf1, 0x83, 0x75, 0x96, 0x80,
-    0x8b, 0xcf, 0x62, 0x02, 0x6a, 0xfe, 0x8a, 0x39,
-    0x4e, 0xe7, 0x5b, 0x12, 0x60, 0x87, 0x73, 0x70,
-    0x75, 0x17, 0x53, 0xfb, 0x78, 0xbf, 0x4f, 0xa9,
-    0x5f, 0x0d, 0x4e, 0xcc, 0x6c, 0x78, 0x65, 0x22,
-    0x7d, 0xc3, 0x53, 0x5e, 0x58, 0x01, 0x77, 0x49,
-    0x84, 0xaa, 0x8a, 0xba, 0x6b, 0xb0, 0x8f, 0x88,
-    0x6c, 0xfe, 0x62, 0xe5, 0x82, 0xa0, 0x63, 0x65,
-    0x75, 0xae, 0x4e, 0x69, 0x51, 0xc9, 0x51, 0x81,
-    0x68, 0xe7, 0x7c, 0x6f, 0x82, 0xd2, 0x8a, 0xcf,
-    0x91, 0xf5, 0x52, 0x42, 0x54, 0x73, 0x59, 0xec,
-    0x5e, 0xc5, 0x65, 0xfe, 0x6f, 0x2a, 0x79, 0xad,
-    0x95, 0x6a, 0x9a, 0x97, 0x9e, 0xce, 0x9e, 0x9b,
-    0x52, 0xc6, 0x66, 0x77, 0x6b, 0x62, 0x8f, 0x74,
-    0x5e, 0x90, 0x61, 0x00, 0x62, 0x9a, 0x64, 0x23,
-    0x6f, 0x49, 0x71, 0x89, 0x74, 0xca, 0x79, 0xf4,
-    0x7d, 0x6f, 0x80, 0x26, 0x8f, 0xee, 0x84, 0x23,
-    0x90, 0x4a, 0x93, 0x17, 0x52, 0xa3, 0x52, 0xbd,
-    0x54, 0xc8, 0x70, 0xc2, 0x88, 0xaa, 0x8a, 0xc9,
-    0x5e, 0xf5, 0x5f, 0x7b, 0x63, 0xae, 0x6b, 0x3e,
-    0x7c, 0x75, 0x73, 0xe4, 0x4e, 0xf9, 0x56, 0xe7,
-    0x5b, 0xba, 0x5d, 0x1c, 0x60, 0xb2, 0x73, 0x69,
-    0x74, 0x9a, 0x7f, 0x46, 0x80, 0x34, 0x92, 0xf6,
-    0x96, 0x48, 0x97, 0x18, 0x98, 0x8b, 0x4f, 0xae,
-    0x79, 0xb4, 0x91, 0xb8, 0x96, 0xe1, 0x60, 0x86,
-    0x4e, 0xda, 0x50, 0xee, 0x5b, 0x3f, 0x5c, 0x99,
-    0x65, 0x02, 0x6a, 0xce, 0x71, 0x42, 0x76, 0xfc,
-    0x84, 0x7c, 0x90, 0x8d, 0x9f, 0x88, 0x66, 0x2e,
-    0x96, 0x89, 0x52, 0x7b, 0x67, 0xf3, 0x67, 0x41,
-    0x6d, 0x9c, 0x6e, 0x09, 0x74, 0x59, 0x75, 0x6b,
-    0x78, 0x10, 0x7d, 0x5e, 0x98, 0x6d, 0x51, 0x2e,
-    0x62, 0x78, 0x96, 0x2b, 0x50, 0x19, 0x5d, 0xea,
-    0x6d, 0x2a, 0x8f, 0x8b, 0x5f, 0x44, 0x61, 0x17,
-    0x68, 0x87, 0x73, 0x86, 0x96, 0x29, 0x52, 0x0f,
-    0x54, 0x65, 0x5c, 0x13, 0x66, 0x4e, 0x67, 0xa8,
-    0x68, 0xe5, 0x6c, 0x06, 0x74, 0xe2, 0x75, 0x79,
-    0x7f, 0xcf, 0x88, 0xe1, 0x88, 0xcc, 0x91, 0xe2,
-    0x96, 0x3f, 0x53, 0xba, 0x6e, 0x1d, 0x54, 0xd0,
-    0x71, 0x98, 0x74, 0xfa, 0x85, 0xa3, 0x96, 0x57,
-    0x9c, 0x9f, 0x9e, 0x97, 0x67, 0xcb, 0x6d, 0xe8,
-    0x81, 0xcb, 0x7a, 0x20, 0x7b, 0x92, 0x7c, 0xc0,
-    0x72, 0x99, 0x70, 0x58, 0x8b, 0xc0, 0x4e, 0x36,
-    0x83, 0x3a, 0x52, 0x07, 0x52, 0xa6, 0x5e, 0xd3,
-    0x62, 0xd6, 0x7c, 0x85, 0x5b, 0x1e, 0x6d, 0xb4,
-    0x66, 0x3b, 0x8f, 0x4c, 0x88, 0x4d, 0x96, 0x8b,
-    0x89, 0xd3, 0x5e, 0x40, 0x51, 0xc0, 0x55, 0x00,
-    0x00, 0x00, 0x00, 0x5a, 0x58, 0x00, 0x00, 0x74,
-    0x66, 0x00, 0x00, 0x00, 0x00, 0xde, 0x51, 0x2a,
-    0x73, 0xca, 0x76, 0x3c, 0x79, 0x5e, 0x79, 0x65,
-    0x79, 0x8f, 0x79, 0x56, 0x97, 0xbe, 0x7c, 0xbd,
-    0x7f, 0x00, 0x00, 0x12, 0x86, 0x00, 0x00, 0xf8,
-    0x8a, 0x00, 0x00, 0x00, 0x00, 0x38, 0x90, 0xfd,
-    0x90, 0xef, 0x98, 0xfc, 0x98, 0x28, 0x99, 0xb4,
-    0x9d, 0xde, 0x90, 0xb7, 0x96, 0xae, 0x4f, 0xe7,
-    0x50, 0x4d, 0x51, 0xc9, 0x52, 0xe4, 0x52, 0x51,
-    0x53, 0x9d, 0x55, 0x06, 0x56, 0x68, 0x56, 0x40,
-    0x58, 0xa8, 0x58, 0x64, 0x5c, 0x6e, 0x5c, 0x94,
-    0x60, 0x68, 0x61, 0x8e, 0x61, 0xf2, 0x61, 0x4f,
-    0x65, 0xe2, 0x65, 0x91, 0x66, 0x85, 0x68, 0x77,
-    0x6d, 0x1a, 0x6e, 0x22, 0x6f, 0x6e, 0x71, 0x2b,
-    0x72, 0x22, 0x74, 0x91, 0x78, 0x3e, 0x79, 0x49,
-    0x79, 0x48, 0x79, 0x50, 0x79, 0x56, 0x79, 0x5d,
-    0x79, 0x8d, 0x79, 0x8e, 0x79, 0x40, 0x7a, 0x81,
-    0x7a, 0xc0, 0x7b, 0xf4, 0x7d, 0x09, 0x7e, 0x41,
-    0x7e, 0x72, 0x7f, 0x05, 0x80, 0xed, 0x81, 0x79,
-    0x82, 0x79, 0x82, 0x57, 0x84, 0x10, 0x89, 0x96,
-    0x89, 0x01, 0x8b, 0x39, 0x8b, 0xd3, 0x8c, 0x08,
-    0x8d, 0xb6, 0x8f, 0x38, 0x90, 0xe3, 0x96, 0xff,
-    0x97, 0x3b, 0x98, 0x75, 0x60, 0xee, 0x42, 0x18,
-    0x82, 0x02, 0x26, 0x4e, 0xb5, 0x51, 0x68, 0x51,
-    0x80, 0x4f, 0x45, 0x51, 0x80, 0x51, 0xc7, 0x52,
-    0xfa, 0x52, 0x9d, 0x55, 0x55, 0x55, 0x99, 0x55,
-    0xe2, 0x55, 0x5a, 0x58, 0xb3, 0x58, 0x44, 0x59,
-    0x54, 0x59, 0x62, 0x5a, 0x28, 0x5b, 0xd2, 0x5e,
-    0xd9, 0x5e, 0x69, 0x5f, 0xad, 0x5f, 0xd8, 0x60,
-    0x4e, 0x61, 0x08, 0x61, 0x8e, 0x61, 0x60, 0x61,
-    0xf2, 0x61, 0x34, 0x62, 0xc4, 0x63, 0x1c, 0x64,
-    0x52, 0x64, 0x56, 0x65, 0x74, 0x66, 0x17, 0x67,
-    0x1b, 0x67, 0x56, 0x67, 0x79, 0x6b, 0xba, 0x6b,
-    0x41, 0x6d, 0xdb, 0x6e, 0xcb, 0x6e, 0x22, 0x6f,
-    0x1e, 0x70, 0x6e, 0x71, 0xa7, 0x77, 0x35, 0x72,
-    0xaf, 0x72, 0x2a, 0x73, 0x71, 0x74, 0x06, 0x75,
-    0x3b, 0x75, 0x1d, 0x76, 0x1f, 0x76, 0xca, 0x76,
-    0xdb, 0x76, 0xf4, 0x76, 0x4a, 0x77, 0x40, 0x77,
-    0xcc, 0x78, 0xb1, 0x7a, 0xc0, 0x7b, 0x7b, 0x7c,
-    0x5b, 0x7d, 0xf4, 0x7d, 0x3e, 0x7f, 0x05, 0x80,
-    0x52, 0x83, 0xef, 0x83, 0x79, 0x87, 0x41, 0x89,
-    0x86, 0x89, 0x96, 0x89, 0xbf, 0x8a, 0xf8, 0x8a,
-    0xcb, 0x8a, 0x01, 0x8b, 0xfe, 0x8a, 0xed, 0x8a,
-    0x39, 0x8b, 0x8a, 0x8b, 0x08, 0x8d, 0x38, 0x8f,
-    0x72, 0x90, 0x99, 0x91, 0x76, 0x92, 0x7c, 0x96,
-    0xe3, 0x96, 0x56, 0x97, 0xdb, 0x97, 0xff, 0x97,
-    0x0b, 0x98, 0x3b, 0x98, 0x12, 0x9b, 0x9c, 0x9f,
-    0x4a, 0x28, 0x44, 0x28, 0xd5, 0x33, 0x9d, 0x3b,
-    0x18, 0x40, 0x39, 0x40, 0x49, 0x52, 0xd0, 0x5c,
-    0xd3, 0x7e, 0x43, 0x9f, 0x8e, 0x9f, 0x2a, 0xa0,
-    0x02, 0x66, 0x66, 0x66, 0x69, 0x66, 0x6c, 0x66,
-    0x66, 0x69, 0x66, 0x66, 0x6c, 0x7f, 0x01, 0x74,
-    0x73, 0x00, 0x74, 0x65, 0x05, 0x0f, 0x11, 0x0f,
-    0x00, 0x0f, 0x06, 0x19, 0x11, 0x0f, 0x08, 0xd9,
-    0x05, 0xb4, 0x05, 0x00, 0x00, 0x00, 0x00, 0xf2,
-    0x05, 0xb7, 0x05, 0xd0, 0x05, 0x12, 0x00, 0x03,
-    0x04, 0x0b, 0x0c, 0x0d, 0x18, 0x1a, 0xe9, 0x05,
-    0xc1, 0x05, 0xe9, 0x05, 0xc2, 0x05, 0x49, 0xfb,
-    0xc1, 0x05, 0x49, 0xfb, 0xc2, 0x05, 0xd0, 0x05,
-    0xb7, 0x05, 0xd0, 0x05, 0xb8, 0x05, 0xd0, 0x05,
-    0xbc, 0x05, 0xd8, 0x05, 0xbc, 0x05, 0xde, 0x05,
-    0xbc, 0x05, 0xe0, 0x05, 0xbc, 0x05, 0xe3, 0x05,
-    0xbc, 0x05, 0xb9, 0x05, 0x2d, 0x03, 0x2e, 0x03,
-    0x2f, 0x03, 0x30, 0x03, 0x31, 0x03, 0x1c, 0x00,
-    0x18, 0x06, 0x22, 0x06, 0x2b, 0x06, 0xd0, 0x05,
-    0xdc, 0x05, 0x71, 0x06, 0x00, 0x00, 0x0a, 0x0a,
-    0x0a, 0x0a, 0x0d, 0x0d, 0x0d, 0x0d, 0x0f, 0x0f,
-    0x0f, 0x0f, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x0e,
-    0x0e, 0x0e, 0x08, 0x08, 0x08, 0x08, 0x33, 0x33,
-    0x33, 0x33, 0x35, 0x35, 0x35, 0x35, 0x13, 0x13,
-    0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x15, 0x15,
-    0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x1c, 0x1c,
-    0x1b, 0x1b, 0x1d, 0x1d, 0x17, 0x17, 0x27, 0x27,
-    0x20, 0x20, 0x38, 0x38, 0x38, 0x38, 0x3e, 0x3e,
-    0x3e, 0x3e, 0x42, 0x42, 0x42, 0x42, 0x40, 0x40,
-    0x40, 0x40, 0x49, 0x49, 0x4a, 0x4a, 0x4a, 0x4a,
-    0x4f, 0x4f, 0x50, 0x50, 0x50, 0x50, 0x4d, 0x4d,
-    0x4d, 0x4d, 0x61, 0x61, 0x62, 0x62, 0x49, 0x06,
-    0x64, 0x64, 0x64, 0x64, 0x7e, 0x7e, 0x7d, 0x7d,
-    0x7f, 0x7f, 0x2e, 0x82, 0x82, 0x7c, 0x7c, 0x80,
-    0x80, 0x87, 0x87, 0x87, 0x87, 0x00, 0x00, 0x26,
-    0x06, 0x00, 0x01, 0x00, 0x01, 0x00, 0xaf, 0x00,
-    0xaf, 0x00, 0x22, 0x00, 0x22, 0x00, 0xa1, 0x00,
-    0xa1, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa2, 0x00,
-    0xa2, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
-    0x23, 0x00, 0x23, 0x00, 0x23, 0xcc, 0x06, 0x00,
-    0x00, 0x00, 0x00, 0x26, 0x06, 0x00, 0x06, 0x00,
-    0x07, 0x00, 0x1f, 0x00, 0x23, 0x00, 0x24, 0x02,
-    0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x1f, 0x02,
-    0x23, 0x02, 0x24, 0x04, 0x06, 0x04, 0x07, 0x04,
-    0x08, 0x04, 0x1f, 0x04, 0x23, 0x04, 0x24, 0x05,
-    0x06, 0x05, 0x1f, 0x05, 0x23, 0x05, 0x24, 0x06,
-    0x07, 0x06, 0x1f, 0x07, 0x06, 0x07, 0x1f, 0x08,
-    0x06, 0x08, 0x07, 0x08, 0x1f, 0x0d, 0x06, 0x0d,
+    0x67, 0x61, 0x6c, 0x4a, 0x04, 0x4c, 0x04, 0x43,
+    0x46, 0x51, 0x26, 0x01, 0x53, 0x01, 0x27, 0xa7,
+    0x37, 0xab, 0x6b, 0x02, 0x52, 0xab, 0x48, 0x8c,
+    0xf4, 0x66, 0xca, 0x8e, 0xc8, 0x8c, 0xd1, 0x6e,
+    0x32, 0x4e, 0xe5, 0x53, 0x9c, 0x9f, 0x9c, 0x9f,
+    0x51, 0x59, 0xd1, 0x91, 0x87, 0x55, 0x48, 0x59,
+    0xf6, 0x61, 0x69, 0x76, 0x85, 0x7f, 0x3f, 0x86,
+    0xba, 0x87, 0xf8, 0x88, 0x8f, 0x90, 0x02, 0x6a,
+    0x1b, 0x6d, 0xd9, 0x70, 0xde, 0x73, 0x3d, 0x84,
+    0x6a, 0x91, 0xf1, 0x99, 0x82, 0x4e, 0x75, 0x53,
+    0x04, 0x6b, 0x1b, 0x72, 0x2d, 0x86, 0x1e, 0x9e,
+    0x50, 0x5d, 0xeb, 0x6f, 0xcd, 0x85, 0x64, 0x89,
+    0xc9, 0x62, 0xd8, 0x81, 0x1f, 0x88, 0xca, 0x5e,
+    0x17, 0x67, 0x6a, 0x6d, 0xfc, 0x72, 0xce, 0x90,
+    0x86, 0x4f, 0xb7, 0x51, 0xde, 0x52, 0xc4, 0x64,
+    0xd3, 0x6a, 0x10, 0x72, 0xe7, 0x76, 0x01, 0x80,
+    0x06, 0x86, 0x5c, 0x86, 0xef, 0x8d, 0x32, 0x97,
+    0x6f, 0x9b, 0xfa, 0x9d, 0x8c, 0x78, 0x7f, 0x79,
+    0xa0, 0x7d, 0xc9, 0x83, 0x04, 0x93, 0x7f, 0x9e,
+    0xd6, 0x8a, 0xdf, 0x58, 0x04, 0x5f, 0x60, 0x7c,
+    0x7e, 0x80, 0x62, 0x72, 0xca, 0x78, 0xc2, 0x8c,
+    0xf7, 0x96, 0xd8, 0x58, 0x62, 0x5c, 0x13, 0x6a,
+    0xda, 0x6d, 0x0f, 0x6f, 0x2f, 0x7d, 0x37, 0x7e,
+    0x4b, 0x96, 0xd2, 0x52, 0x8b, 0x80, 0xdc, 0x51,
+    0xcc, 0x51, 0x1c, 0x7a, 0xbe, 0x7d, 0xf1, 0x83,
+    0x75, 0x96, 0x80, 0x8b, 0xcf, 0x62, 0x02, 0x6a,
+    0xfe, 0x8a, 0x39, 0x4e, 0xe7, 0x5b, 0x12, 0x60,
+    0x87, 0x73, 0x70, 0x75, 0x17, 0x53, 0xfb, 0x78,
+    0xbf, 0x4f, 0xa9, 0x5f, 0x0d, 0x4e, 0xcc, 0x6c,
+    0x78, 0x65, 0x22, 0x7d, 0xc3, 0x53, 0x5e, 0x58,
+    0x01, 0x77, 0x49, 0x84, 0xaa, 0x8a, 0xba, 0x6b,
+    0xb0, 0x8f, 0x88, 0x6c, 0xfe, 0x62, 0xe5, 0x82,
+    0xa0, 0x63, 0x65, 0x75, 0xae, 0x4e, 0x69, 0x51,
+    0xc9, 0x51, 0x81, 0x68, 0xe7, 0x7c, 0x6f, 0x82,
+    0xd2, 0x8a, 0xcf, 0x91, 0xf5, 0x52, 0x42, 0x54,
+    0x73, 0x59, 0xec, 0x5e, 0xc5, 0x65, 0xfe, 0x6f,
+    0x2a, 0x79, 0xad, 0x95, 0x6a, 0x9a, 0x97, 0x9e,
+    0xce, 0x9e, 0x9b, 0x52, 0xc6, 0x66, 0x77, 0x6b,
+    0x62, 0x8f, 0x74, 0x5e, 0x90, 0x61, 0x00, 0x62,
+    0x9a, 0x64, 0x23, 0x6f, 0x49, 0x71, 0x89, 0x74,
+    0xca, 0x79, 0xf4, 0x7d, 0x6f, 0x80, 0x26, 0x8f,
+    0xee, 0x84, 0x23, 0x90, 0x4a, 0x93, 0x17, 0x52,
+    0xa3, 0x52, 0xbd, 0x54, 0xc8, 0x70, 0xc2, 0x88,
+    0xaa, 0x8a, 0xc9, 0x5e, 0xf5, 0x5f, 0x7b, 0x63,
+    0xae, 0x6b, 0x3e, 0x7c, 0x75, 0x73, 0xe4, 0x4e,
+    0xf9, 0x56, 0xe7, 0x5b, 0xba, 0x5d, 0x1c, 0x60,
+    0xb2, 0x73, 0x69, 0x74, 0x9a, 0x7f, 0x46, 0x80,
+    0x34, 0x92, 0xf6, 0x96, 0x48, 0x97, 0x18, 0x98,
+    0x8b, 0x4f, 0xae, 0x79, 0xb4, 0x91, 0xb8, 0x96,
+    0xe1, 0x60, 0x86, 0x4e, 0xda, 0x50, 0xee, 0x5b,
+    0x3f, 0x5c, 0x99, 0x65, 0x02, 0x6a, 0xce, 0x71,
+    0x42, 0x76, 0xfc, 0x84, 0x7c, 0x90, 0x8d, 0x9f,
+    0x88, 0x66, 0x2e, 0x96, 0x89, 0x52, 0x7b, 0x67,
+    0xf3, 0x67, 0x41, 0x6d, 0x9c, 0x6e, 0x09, 0x74,
+    0x59, 0x75, 0x6b, 0x78, 0x10, 0x7d, 0x5e, 0x98,
+    0x6d, 0x51, 0x2e, 0x62, 0x78, 0x96, 0x2b, 0x50,
+    0x19, 0x5d, 0xea, 0x6d, 0x2a, 0x8f, 0x8b, 0x5f,
+    0x44, 0x61, 0x17, 0x68, 0x87, 0x73, 0x86, 0x96,
+    0x29, 0x52, 0x0f, 0x54, 0x65, 0x5c, 0x13, 0x66,
+    0x4e, 0x67, 0xa8, 0x68, 0xe5, 0x6c, 0x06, 0x74,
+    0xe2, 0x75, 0x79, 0x7f, 0xcf, 0x88, 0xe1, 0x88,
+    0xcc, 0x91, 0xe2, 0x96, 0x3f, 0x53, 0xba, 0x6e,
+    0x1d, 0x54, 0xd0, 0x71, 0x98, 0x74, 0xfa, 0x85,
+    0xa3, 0x96, 0x57, 0x9c, 0x9f, 0x9e, 0x97, 0x67,
+    0xcb, 0x6d, 0xe8, 0x81, 0xcb, 0x7a, 0x20, 0x7b,
+    0x92, 0x7c, 0xc0, 0x72, 0x99, 0x70, 0x58, 0x8b,
+    0xc0, 0x4e, 0x36, 0x83, 0x3a, 0x52, 0x07, 0x52,
+    0xa6, 0x5e, 0xd3, 0x62, 0xd6, 0x7c, 0x85, 0x5b,
+    0x1e, 0x6d, 0xb4, 0x66, 0x3b, 0x8f, 0x4c, 0x88,
+    0x4d, 0x96, 0x8b, 0x89, 0xd3, 0x5e, 0x40, 0x51,
+    0xc0, 0x55, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x58,
+    0x00, 0x00, 0x74, 0x66, 0x00, 0x00, 0x00, 0x00,
+    0xde, 0x51, 0x2a, 0x73, 0xca, 0x76, 0x3c, 0x79,
+    0x5e, 0x79, 0x65, 0x79, 0x8f, 0x79, 0x56, 0x97,
+    0xbe, 0x7c, 0xbd, 0x7f, 0x00, 0x00, 0x12, 0x86,
+    0x00, 0x00, 0xf8, 0x8a, 0x00, 0x00, 0x00, 0x00,
+    0x38, 0x90, 0xfd, 0x90, 0xef, 0x98, 0xfc, 0x98,
+    0x28, 0x99, 0xb4, 0x9d, 0xde, 0x90, 0xb7, 0x96,
+    0xae, 0x4f, 0xe7, 0x50, 0x4d, 0x51, 0xc9, 0x52,
+    0xe4, 0x52, 0x51, 0x53, 0x9d, 0x55, 0x06, 0x56,
+    0x68, 0x56, 0x40, 0x58, 0xa8, 0x58, 0x64, 0x5c,
+    0x6e, 0x5c, 0x94, 0x60, 0x68, 0x61, 0x8e, 0x61,
+    0xf2, 0x61, 0x4f, 0x65, 0xe2, 0x65, 0x91, 0x66,
+    0x85, 0x68, 0x77, 0x6d, 0x1a, 0x6e, 0x22, 0x6f,
+    0x6e, 0x71, 0x2b, 0x72, 0x22, 0x74, 0x91, 0x78,
+    0x3e, 0x79, 0x49, 0x79, 0x48, 0x79, 0x50, 0x79,
+    0x56, 0x79, 0x5d, 0x79, 0x8d, 0x79, 0x8e, 0x79,
+    0x40, 0x7a, 0x81, 0x7a, 0xc0, 0x7b, 0xf4, 0x7d,
+    0x09, 0x7e, 0x41, 0x7e, 0x72, 0x7f, 0x05, 0x80,
+    0xed, 0x81, 0x79, 0x82, 0x79, 0x82, 0x57, 0x84,
+    0x10, 0x89, 0x96, 0x89, 0x01, 0x8b, 0x39, 0x8b,
+    0xd3, 0x8c, 0x08, 0x8d, 0xb6, 0x8f, 0x38, 0x90,
+    0xe3, 0x96, 0xff, 0x97, 0x3b, 0x98, 0x75, 0x60,
+    0xee, 0x42, 0x18, 0x82, 0x02, 0x26, 0x4e, 0xb5,
+    0x51, 0x68, 0x51, 0x80, 0x4f, 0x45, 0x51, 0x80,
+    0x51, 0xc7, 0x52, 0xfa, 0x52, 0x9d, 0x55, 0x55,
+    0x55, 0x99, 0x55, 0xe2, 0x55, 0x5a, 0x58, 0xb3,
+    0x58, 0x44, 0x59, 0x54, 0x59, 0x62, 0x5a, 0x28,
+    0x5b, 0xd2, 0x5e, 0xd9, 0x5e, 0x69, 0x5f, 0xad,
+    0x5f, 0xd8, 0x60, 0x4e, 0x61, 0x08, 0x61, 0x8e,
+    0x61, 0x60, 0x61, 0xf2, 0x61, 0x34, 0x62, 0xc4,
+    0x63, 0x1c, 0x64, 0x52, 0x64, 0x56, 0x65, 0x74,
+    0x66, 0x17, 0x67, 0x1b, 0x67, 0x56, 0x67, 0x79,
+    0x6b, 0xba, 0x6b, 0x41, 0x6d, 0xdb, 0x6e, 0xcb,
+    0x6e, 0x22, 0x6f, 0x1e, 0x70, 0x6e, 0x71, 0xa7,
+    0x77, 0x35, 0x72, 0xaf, 0x72, 0x2a, 0x73, 0x71,
+    0x74, 0x06, 0x75, 0x3b, 0x75, 0x1d, 0x76, 0x1f,
+    0x76, 0xca, 0x76, 0xdb, 0x76, 0xf4, 0x76, 0x4a,
+    0x77, 0x40, 0x77, 0xcc, 0x78, 0xb1, 0x7a, 0xc0,
+    0x7b, 0x7b, 0x7c, 0x5b, 0x7d, 0xf4, 0x7d, 0x3e,
+    0x7f, 0x05, 0x80, 0x52, 0x83, 0xef, 0x83, 0x79,
+    0x87, 0x41, 0x89, 0x86, 0x89, 0x96, 0x89, 0xbf,
+    0x8a, 0xf8, 0x8a, 0xcb, 0x8a, 0x01, 0x8b, 0xfe,
+    0x8a, 0xed, 0x8a, 0x39, 0x8b, 0x8a, 0x8b, 0x08,
+    0x8d, 0x38, 0x8f, 0x72, 0x90, 0x99, 0x91, 0x76,
+    0x92, 0x7c, 0x96, 0xe3, 0x96, 0x56, 0x97, 0xdb,
+    0x97, 0xff, 0x97, 0x0b, 0x98, 0x3b, 0x98, 0x12,
+    0x9b, 0x9c, 0x9f, 0x4a, 0x28, 0x44, 0x28, 0xd5,
+    0x33, 0x9d, 0x3b, 0x18, 0x40, 0x39, 0x40, 0x49,
+    0x52, 0xd0, 0x5c, 0xd3, 0x7e, 0x43, 0x9f, 0x8e,
+    0x9f, 0x2a, 0xa0, 0x02, 0x66, 0x66, 0x66, 0x69,
+    0x66, 0x6c, 0x66, 0x66, 0x69, 0x66, 0x66, 0x6c,
+    0x7f, 0x01, 0x74, 0x73, 0x00, 0x74, 0x65, 0x05,
+    0x0f, 0x11, 0x0f, 0x00, 0x0f, 0x06, 0x19, 0x11,
+    0x0f, 0x08, 0xd9, 0x05, 0xb4, 0x05, 0x00, 0x00,
+    0x00, 0x00, 0xf2, 0x05, 0xb7, 0x05, 0xd0, 0x05,
+    0x12, 0x00, 0x03, 0x04, 0x0b, 0x0c, 0x0d, 0x18,
+    0x1a, 0xe9, 0x05, 0xc1, 0x05, 0xe9, 0x05, 0xc2,
+    0x05, 0x49, 0xfb, 0xc1, 0x05, 0x49, 0xfb, 0xc2,
+    0x05, 0xd0, 0x05, 0xb7, 0x05, 0xd0, 0x05, 0xb8,
+    0x05, 0xd0, 0x05, 0xbc, 0x05, 0xd8, 0x05, 0xbc,
+    0x05, 0xde, 0x05, 0xbc, 0x05, 0xe0, 0x05, 0xbc,
+    0x05, 0xe3, 0x05, 0xbc, 0x05, 0xb9, 0x05, 0x2d,
+    0x03, 0x2e, 0x03, 0x2f, 0x03, 0x30, 0x03, 0x31,
+    0x03, 0x1c, 0x00, 0x18, 0x06, 0x22, 0x06, 0x2b,
+    0x06, 0xd0, 0x05, 0xdc, 0x05, 0x71, 0x06, 0x00,
+    0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0d, 0x0d, 0x0d,
+    0x0d, 0x0f, 0x0f, 0x0f, 0x0f, 0x09, 0x09, 0x09,
+    0x09, 0x0e, 0x0e, 0x0e, 0x0e, 0x08, 0x08, 0x08,
+    0x08, 0x33, 0x33, 0x33, 0x33, 0x35, 0x35, 0x35,
+    0x35, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12,
+    0x12, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16,
+    0x16, 0x1c, 0x1c, 0x1b, 0x1b, 0x1d, 0x1d, 0x17,
+    0x17, 0x27, 0x27, 0x20, 0x20, 0x38, 0x38, 0x38,
+    0x38, 0x3e, 0x3e, 0x3e, 0x3e, 0x42, 0x42, 0x42,
+    0x42, 0x40, 0x40, 0x40, 0x40, 0x49, 0x49, 0x4a,
+    0x4a, 0x4a, 0x4a, 0x4f, 0x4f, 0x50, 0x50, 0x50,
+    0x50, 0x4d, 0x4d, 0x4d, 0x4d, 0x61, 0x61, 0x62,
+    0x62, 0x49, 0x06, 0x64, 0x64, 0x64, 0x64, 0x7e,
+    0x7e, 0x7d, 0x7d, 0x7f, 0x7f, 0x2e, 0x82, 0x82,
+    0x7c, 0x7c, 0x80, 0x80, 0x87, 0x87, 0x87, 0x87,
+    0x00, 0x00, 0x26, 0x06, 0x00, 0x01, 0x00, 0x01,
+    0x00, 0xaf, 0x00, 0xaf, 0x00, 0x22, 0x00, 0x22,
+    0x00, 0xa1, 0x00, 0xa1, 0x00, 0xa0, 0x00, 0xa0,
+    0x00, 0xa2, 0x00, 0xa2, 0x00, 0xaa, 0x00, 0xaa,
+    0x00, 0xaa, 0x00, 0x23, 0x00, 0x23, 0x00, 0x23,
+    0xcc, 0x06, 0x00, 0x00, 0x00, 0x00, 0x26, 0x06,
+    0x00, 0x06, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x23,
+    0x00, 0x24, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08,
+    0x02, 0x1f, 0x02, 0x23, 0x02, 0x24, 0x04, 0x06,
+    0x04, 0x07, 0x04, 0x08, 0x04, 0x1f, 0x04, 0x23,
+    0x04, 0x24, 0x05, 0x06, 0x05, 0x1f, 0x05, 0x23,
+    0x05, 0x24, 0x06, 0x07, 0x06, 0x1f, 0x07, 0x06,
+    0x07, 0x1f, 0x08, 0x06, 0x08, 0x07, 0x08, 0x1f,
+    0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x08, 0x0d, 0x1f,
+    0x0f, 0x07, 0x0f, 0x1f, 0x10, 0x06, 0x10, 0x07,
+    0x10, 0x08, 0x10, 0x1f, 0x11, 0x07, 0x11, 0x1f,
+    0x12, 0x1f, 0x13, 0x06, 0x13, 0x1f, 0x14, 0x06,
+    0x14, 0x1f, 0x1b, 0x06, 0x1b, 0x07, 0x1b, 0x08,
+    0x1b, 0x1f, 0x1b, 0x23, 0x1b, 0x24, 0x1c, 0x07,
+    0x1c, 0x1f, 0x1c, 0x23, 0x1c, 0x24, 0x1d, 0x01,
+    0x1d, 0x06, 0x1d, 0x07, 0x1d, 0x08, 0x1d, 0x1e,
+    0x1d, 0x1f, 0x1d, 0x23, 0x1d, 0x24, 0x1e, 0x06,
+    0x1e, 0x07, 0x1e, 0x08, 0x1e, 0x1f, 0x1e, 0x23,
+    0x1e, 0x24, 0x1f, 0x06, 0x1f, 0x07, 0x1f, 0x08,
+    0x1f, 0x1f, 0x1f, 0x23, 0x1f, 0x24, 0x20, 0x06,
+    0x20, 0x07, 0x20, 0x08, 0x20, 0x1f, 0x20, 0x23,
+    0x20, 0x24, 0x21, 0x06, 0x21, 0x1f, 0x21, 0x23,
+    0x21, 0x24, 0x24, 0x06, 0x24, 0x07, 0x24, 0x08,
+    0x24, 0x1f, 0x24, 0x23, 0x24, 0x24, 0x0a, 0x4a,
+    0x0b, 0x4a, 0x23, 0x4a, 0x20, 0x00, 0x4c, 0x06,
+    0x51, 0x06, 0x51, 0x06, 0xff, 0x00, 0x1f, 0x26,
+    0x06, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x1f, 0x00,
+    0x20, 0x00, 0x23, 0x00, 0x24, 0x02, 0x0b, 0x02,
+    0x0c, 0x02, 0x1f, 0x02, 0x20, 0x02, 0x23, 0x02,
+    0x24, 0x04, 0x0b, 0x04, 0x0c, 0x04, 0x1f, 0x26,
+    0x06, 0x04, 0x20, 0x04, 0x23, 0x04, 0x24, 0x05,
+    0x0b, 0x05, 0x0c, 0x05, 0x1f, 0x05, 0x20, 0x05,
+    0x23, 0x05, 0x24, 0x1b, 0x23, 0x1b, 0x24, 0x1c,
+    0x23, 0x1c, 0x24, 0x1d, 0x01, 0x1d, 0x1e, 0x1d,
+    0x1f, 0x1d, 0x23, 0x1d, 0x24, 0x1e, 0x1f, 0x1e,
+    0x23, 0x1e, 0x24, 0x1f, 0x01, 0x1f, 0x1f, 0x20,
+    0x0b, 0x20, 0x0c, 0x20, 0x1f, 0x20, 0x20, 0x20,
+    0x23, 0x20, 0x24, 0x23, 0x4a, 0x24, 0x0b, 0x24,
+    0x0c, 0x24, 0x1f, 0x24, 0x20, 0x24, 0x23, 0x24,
+    0x24, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00,
+    0x1f, 0x00, 0x21, 0x02, 0x06, 0x02, 0x07, 0x02,
+    0x08, 0x02, 0x1f, 0x02, 0x21, 0x04, 0x06, 0x04,
+    0x07, 0x04, 0x08, 0x04, 0x1f, 0x04, 0x21, 0x05,
+    0x1f, 0x06, 0x07, 0x06, 0x1f, 0x07, 0x06, 0x07,
+    0x1f, 0x08, 0x06, 0x08, 0x1f, 0x0d, 0x06, 0x0d,
     0x07, 0x0d, 0x08, 0x0d, 0x1f, 0x0f, 0x07, 0x0f,
-    0x1f, 0x10, 0x06, 0x10, 0x07, 0x10, 0x08, 0x10,
-    0x1f, 0x11, 0x07, 0x11, 0x1f, 0x12, 0x1f, 0x13,
+    0x08, 0x0f, 0x1f, 0x10, 0x06, 0x10, 0x07, 0x10,
+    0x08, 0x10, 0x1f, 0x11, 0x07, 0x12, 0x1f, 0x13,
     0x06, 0x13, 0x1f, 0x14, 0x06, 0x14, 0x1f, 0x1b,
-    0x06, 0x1b, 0x07, 0x1b, 0x08, 0x1b, 0x1f, 0x1b,
-    0x23, 0x1b, 0x24, 0x1c, 0x07, 0x1c, 0x1f, 0x1c,
-    0x23, 0x1c, 0x24, 0x1d, 0x01, 0x1d, 0x06, 0x1d,
-    0x07, 0x1d, 0x08, 0x1d, 0x1e, 0x1d, 0x1f, 0x1d,
-    0x23, 0x1d, 0x24, 0x1e, 0x06, 0x1e, 0x07, 0x1e,
-    0x08, 0x1e, 0x1f, 0x1e, 0x23, 0x1e, 0x24, 0x1f,
-    0x06, 0x1f, 0x07, 0x1f, 0x08, 0x1f, 0x1f, 0x1f,
-    0x23, 0x1f, 0x24, 0x20, 0x06, 0x20, 0x07, 0x20,
-    0x08, 0x20, 0x1f, 0x20, 0x23, 0x20, 0x24, 0x21,
-    0x06, 0x21, 0x1f, 0x21, 0x23, 0x21, 0x24, 0x24,
+    0x06, 0x1b, 0x07, 0x1b, 0x08, 0x1b, 0x1f, 0x1c,
+    0x07, 0x1c, 0x1f, 0x1d, 0x06, 0x1d, 0x07, 0x1d,
+    0x08, 0x1d, 0x1e, 0x1d, 0x1f, 0x1e, 0x06, 0x1e,
+    0x07, 0x1e, 0x08, 0x1e, 0x1f, 0x1e, 0x21, 0x1f,
+    0x06, 0x1f, 0x07, 0x1f, 0x08, 0x1f, 0x1f, 0x20,
+    0x06, 0x20, 0x07, 0x20, 0x08, 0x20, 0x1f, 0x20,
+    0x21, 0x21, 0x06, 0x21, 0x1f, 0x21, 0x4a, 0x24,
     0x06, 0x24, 0x07, 0x24, 0x08, 0x24, 0x1f, 0x24,
-    0x23, 0x24, 0x24, 0x0a, 0x4a, 0x0b, 0x4a, 0x23,
-    0x4a, 0x20, 0x00, 0x4c, 0x06, 0x51, 0x06, 0x51,
-    0x06, 0xff, 0x00, 0x1f, 0x26, 0x06, 0x00, 0x0b,
-    0x00, 0x0c, 0x00, 0x1f, 0x00, 0x20, 0x00, 0x23,
-    0x00, 0x24, 0x02, 0x0b, 0x02, 0x0c, 0x02, 0x1f,
-    0x02, 0x20, 0x02, 0x23, 0x02, 0x24, 0x04, 0x0b,
-    0x04, 0x0c, 0x04, 0x1f, 0x26, 0x06, 0x04, 0x20,
-    0x04, 0x23, 0x04, 0x24, 0x05, 0x0b, 0x05, 0x0c,
-    0x05, 0x1f, 0x05, 0x20, 0x05, 0x23, 0x05, 0x24,
-    0x1b, 0x23, 0x1b, 0x24, 0x1c, 0x23, 0x1c, 0x24,
-    0x1d, 0x01, 0x1d, 0x1e, 0x1d, 0x1f, 0x1d, 0x23,
-    0x1d, 0x24, 0x1e, 0x1f, 0x1e, 0x23, 0x1e, 0x24,
-    0x1f, 0x01, 0x1f, 0x1f, 0x20, 0x0b, 0x20, 0x0c,
-    0x20, 0x1f, 0x20, 0x20, 0x20, 0x23, 0x20, 0x24,
-    0x23, 0x4a, 0x24, 0x0b, 0x24, 0x0c, 0x24, 0x1f,
-    0x24, 0x20, 0x24, 0x23, 0x24, 0x24, 0x00, 0x06,
-    0x00, 0x07, 0x00, 0x08, 0x00, 0x1f, 0x00, 0x21,
-    0x02, 0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x1f,
-    0x02, 0x21, 0x04, 0x06, 0x04, 0x07, 0x04, 0x08,
-    0x04, 0x1f, 0x04, 0x21, 0x05, 0x1f, 0x06, 0x07,
-    0x06, 0x1f, 0x07, 0x06, 0x07, 0x1f, 0x08, 0x06,
-    0x08, 0x1f, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x08,
-    0x0d, 0x1f, 0x0f, 0x07, 0x0f, 0x08, 0x0f, 0x1f,
-    0x10, 0x06, 0x10, 0x07, 0x10, 0x08, 0x10, 0x1f,
-    0x11, 0x07, 0x12, 0x1f, 0x13, 0x06, 0x13, 0x1f,
-    0x14, 0x06, 0x14, 0x1f, 0x1b, 0x06, 0x1b, 0x07,
-    0x1b, 0x08, 0x1b, 0x1f, 0x1c, 0x07, 0x1c, 0x1f,
-    0x1d, 0x06, 0x1d, 0x07, 0x1d, 0x08, 0x1d, 0x1e,
-    0x1d, 0x1f, 0x1e, 0x06, 0x1e, 0x07, 0x1e, 0x08,
-    0x1e, 0x1f, 0x1e, 0x21, 0x1f, 0x06, 0x1f, 0x07,
-    0x1f, 0x08, 0x1f, 0x1f, 0x20, 0x06, 0x20, 0x07,
-    0x20, 0x08, 0x20, 0x1f, 0x20, 0x21, 0x21, 0x06,
-    0x21, 0x1f, 0x21, 0x4a, 0x24, 0x06, 0x24, 0x07,
-    0x24, 0x08, 0x24, 0x1f, 0x24, 0x21, 0x00, 0x1f,
-    0x00, 0x21, 0x02, 0x1f, 0x02, 0x21, 0x04, 0x1f,
-    0x04, 0x21, 0x05, 0x1f, 0x05, 0x21, 0x0d, 0x1f,
-    0x0d, 0x21, 0x0e, 0x1f, 0x0e, 0x21, 0x1d, 0x1e,
-    0x1d, 0x1f, 0x1e, 0x1f, 0x20, 0x1f, 0x20, 0x21,
-    0x24, 0x1f, 0x24, 0x21, 0x40, 0x06, 0x4e, 0x06,
-    0x51, 0x06, 0x27, 0x06, 0x10, 0x22, 0x10, 0x23,
-    0x12, 0x22, 0x12, 0x23, 0x13, 0x22, 0x13, 0x23,
-    0x0c, 0x22, 0x0c, 0x23, 0x0d, 0x22, 0x0d, 0x23,
-    0x06, 0x22, 0x06, 0x23, 0x05, 0x22, 0x05, 0x23,
-    0x07, 0x22, 0x07, 0x23, 0x0e, 0x22, 0x0e, 0x23,
-    0x0f, 0x22, 0x0f, 0x23, 0x0d, 0x05, 0x0d, 0x06,
-    0x0d, 0x07, 0x0d, 0x1e, 0x0d, 0x0a, 0x0c, 0x0a,
-    0x0e, 0x0a, 0x0f, 0x0a, 0x10, 0x22, 0x10, 0x23,
-    0x12, 0x22, 0x12, 0x23, 0x13, 0x22, 0x13, 0x23,
-    0x0c, 0x22, 0x0c, 0x23, 0x0d, 0x22, 0x0d, 0x23,
-    0x06, 0x22, 0x06, 0x23, 0x05, 0x22, 0x05, 0x23,
-    0x07, 0x22, 0x07, 0x23, 0x0e, 0x22, 0x0e, 0x23,
-    0x0f, 0x22, 0x0f, 0x23, 0x0d, 0x05, 0x0d, 0x06,
-    0x0d, 0x07, 0x0d, 0x1e, 0x0d, 0x0a, 0x0c, 0x0a,
-    0x0e, 0x0a, 0x0f, 0x0a, 0x0d, 0x05, 0x0d, 0x06,
-    0x0d, 0x07, 0x0d, 0x1e, 0x0c, 0x20, 0x0d, 0x20,
-    0x10, 0x1e, 0x0c, 0x05, 0x0c, 0x06, 0x0c, 0x07,
-    0x0d, 0x05, 0x0d, 0x06, 0x0d, 0x07, 0x10, 0x1e,
-    0x11, 0x1e, 0x00, 0x24, 0x00, 0x24, 0x2a, 0x06,
-    0x00, 0x02, 0x1b, 0x00, 0x03, 0x02, 0x00, 0x03,
-    0x02, 0x00, 0x03, 0x1b, 0x00, 0x04, 0x1b, 0x00,
-    0x1b, 0x02, 0x00, 0x1b, 0x03, 0x00, 0x1b, 0x04,
-    0x02, 0x1b, 0x03, 0x02, 0x1b, 0x03, 0x03, 0x1b,
-    0x20, 0x03, 0x1b, 0x1f, 0x09, 0x03, 0x02, 0x09,
-    0x02, 0x03, 0x09, 0x02, 0x1f, 0x09, 0x1b, 0x03,
-    0x09, 0x1b, 0x03, 0x09, 0x1b, 0x02, 0x09, 0x1b,
-    0x1b, 0x09, 0x1b, 0x1b, 0x0b, 0x03, 0x03, 0x0b,
-    0x03, 0x03, 0x0b, 0x1b, 0x1b, 0x0a, 0x03, 0x1b,
-    0x0a, 0x03, 0x1b, 0x0a, 0x02, 0x20, 0x0a, 0x1b,
-    0x04, 0x0a, 0x1b, 0x04, 0x0a, 0x1b, 0x1b, 0x0a,
-    0x1b, 0x1b, 0x0c, 0x03, 0x1f, 0x0c, 0x04, 0x1b,
-    0x0c, 0x04, 0x1b, 0x0d, 0x1b, 0x03, 0x0d, 0x1b,
-    0x03, 0x0d, 0x1b, 0x1b, 0x0d, 0x1b, 0x20, 0x0f,
-    0x02, 0x1b, 0x0f, 0x1b, 0x1b, 0x0f, 0x1b, 0x1b,
-    0x0f, 0x1b, 0x1f, 0x10, 0x1b, 0x1b, 0x10, 0x1b,
-    0x20, 0x10, 0x1b, 0x1f, 0x17, 0x04, 0x1b, 0x17,
-    0x04, 0x1b, 0x18, 0x1b, 0x03, 0x18, 0x1b, 0x1b,
-    0x1a, 0x03, 0x1b, 0x1a, 0x03, 0x20, 0x1a, 0x03,
-    0x1f, 0x1a, 0x02, 0x02, 0x1a, 0x02, 0x02, 0x1a,
-    0x04, 0x1b, 0x1a, 0x04, 0x1b, 0x1a, 0x1b, 0x03,
-    0x1a, 0x1b, 0x03, 0x1b, 0x03, 0x02, 0x1b, 0x03,
-    0x1b, 0x1b, 0x03, 0x20, 0x1b, 0x02, 0x03, 0x1b,
-    0x02, 0x1b, 0x1b, 0x04, 0x02, 0x1b, 0x04, 0x1b,
-    0x28, 0x06, 0x1d, 0x04, 0x06, 0x1f, 0x1d, 0x04,
-    0x1f, 0x1d, 0x1d, 0x1e, 0x05, 0x1d, 0x1e, 0x05,
-    0x21, 0x1e, 0x04, 0x1d, 0x1e, 0x04, 0x1d, 0x1e,
-    0x04, 0x21, 0x1e, 0x1d, 0x22, 0x1e, 0x1d, 0x21,
-    0x22, 0x1d, 0x1d, 0x22, 0x1d, 0x1d, 0x00, 0x06,
-    0x22, 0x02, 0x04, 0x22, 0x02, 0x04, 0x21, 0x02,
-    0x06, 0x22, 0x02, 0x06, 0x21, 0x02, 0x1d, 0x22,
-    0x02, 0x1d, 0x21, 0x04, 0x1d, 0x22, 0x04, 0x05,
-    0x21, 0x04, 0x1d, 0x21, 0x0b, 0x06, 0x21, 0x0d,
-    0x05, 0x22, 0x0c, 0x05, 0x22, 0x0e, 0x05, 0x22,
-    0x1c, 0x04, 0x22, 0x1c, 0x1d, 0x22, 0x22, 0x05,
-    0x22, 0x22, 0x04, 0x22, 0x22, 0x1d, 0x22, 0x1d,
-    0x1d, 0x22, 0x1a, 0x1d, 0x22, 0x1e, 0x05, 0x22,
-    0x1a, 0x1d, 0x05, 0x1c, 0x05, 0x1d, 0x11, 0x1d,
-    0x22, 0x1b, 0x1d, 0x22, 0x1e, 0x04, 0x05, 0x1d,
-    0x06, 0x22, 0x1c, 0x04, 0x1d, 0x1b, 0x1d, 0x1d,
-    0x1c, 0x04, 0x1d, 0x1e, 0x04, 0x05, 0x04, 0x05,
-    0x22, 0x05, 0x04, 0x22, 0x1d, 0x04, 0x22, 0x19,
-    0x1d, 0x22, 0x00, 0x05, 0x22, 0x1b, 0x1d, 0x1d,
-    0x11, 0x04, 0x1d, 0x0d, 0x1d, 0x1d, 0x0b, 0x06,
-    0x22, 0x1e, 0x04, 0x22, 0x35, 0x06, 0x00, 0x0f,
-    0x9d, 0x0d, 0x0f, 0x9d, 0x27, 0x06, 0x00, 0x1d,
-    0x1d, 0x20, 0x00, 0x1c, 0x01, 0x0a, 0x1e, 0x06,
-    0x1e, 0x08, 0x0e, 0x1d, 0x12, 0x1e, 0x0a, 0x0c,
-    0x21, 0x1d, 0x12, 0x1d, 0x23, 0x20, 0x21, 0x0c,
-    0x1d, 0x1e, 0x35, 0x06, 0x00, 0x0f, 0x14, 0x27,
-    0x06, 0x0e, 0x1d, 0x22, 0xff, 0x00, 0x1d, 0x1d,
-    0x20, 0xff, 0x12, 0x1d, 0x23, 0x20, 0xff, 0x21,
-    0x0c, 0x1d, 0x1e, 0x27, 0x06, 0x05, 0x1d, 0xff,
-    0x05, 0x1d, 0x00, 0x1d, 0x20, 0x27, 0x06, 0x0a,
-    0xa5, 0x00, 0x1d, 0x2c, 0x00, 0x01, 0x30, 0x02,
-    0x30, 0x3a, 0x00, 0x3b, 0x00, 0x21, 0x00, 0x3f,
-    0x00, 0x16, 0x30, 0x17, 0x30, 0x26, 0x20, 0x13,
-    0x20, 0x12, 0x01, 0x00, 0x5f, 0x5f, 0x28, 0x29,
-    0x7b, 0x7d, 0x08, 0x30, 0x0c, 0x0d, 0x08, 0x09,
-    0x02, 0x03, 0x00, 0x01, 0x04, 0x05, 0x06, 0x07,
-    0x5b, 0x00, 0x5d, 0x00, 0x3e, 0x20, 0x3e, 0x20,
-    0x3e, 0x20, 0x3e, 0x20, 0x5f, 0x00, 0x5f, 0x00,
-    0x5f, 0x00, 0x2c, 0x00, 0x01, 0x30, 0x2e, 0x00,
-    0x00, 0x00, 0x3b, 0x00, 0x3a, 0x00, 0x3f, 0x00,
-    0x21, 0x00, 0x14, 0x20, 0x28, 0x00, 0x29, 0x00,
-    0x7b, 0x00, 0x7d, 0x00, 0x14, 0x30, 0x15, 0x30,
-    0x23, 0x26, 0x2a, 0x2b, 0x2d, 0x3c, 0x3e, 0x3d,
-    0x00, 0x5c, 0x24, 0x25, 0x40, 0x40, 0x06, 0xff,
-    0x0b, 0x00, 0x0b, 0xff, 0x0c, 0x20, 0x00, 0x4d,
-    0x06, 0x40, 0x06, 0xff, 0x0e, 0x00, 0x0e, 0xff,
-    0x0f, 0x00, 0x0f, 0xff, 0x10, 0x00, 0x10, 0xff,
-    0x11, 0x00, 0x11, 0xff, 0x12, 0x00, 0x12, 0x21,
-    0x06, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03,
-    0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06,
-    0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09,
-    0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b,
-    0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d,
-    0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10,
-    0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13,
-    0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15,
-    0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17,
-    0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19,
-    0x19, 0x19, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21,
-    0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23,
-    0x23, 0x23, 0x24, 0x24, 0x24, 0x24, 0x25, 0x25,
-    0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27,
-    0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x22, 0x06,
-    0x22, 0x00, 0x22, 0x00, 0x22, 0x01, 0x22, 0x01,
-    0x22, 0x03, 0x22, 0x03, 0x22, 0x05, 0x22, 0x05,
-    0x21, 0x00, 0x85, 0x29, 0x01, 0x30, 0x01, 0x0b,
-    0x0c, 0x00, 0xfa, 0xf1, 0xa0, 0xa2, 0xa4, 0xa6,
-    0xa8, 0xe2, 0xe4, 0xe6, 0xc2, 0xfb, 0xa1, 0xa3,
-    0xa5, 0xa7, 0xa9, 0xaa, 0xac, 0xae, 0xb0, 0xb2,
-    0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0, 0xc3,
-    0xc5, 0xc7, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
-    0xd1, 0xd4, 0xd7, 0xda, 0xdd, 0xde, 0xdf, 0xe0,
-    0xe1, 0xe3, 0xe5, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
-    0xec, 0xee, 0xf2, 0x98, 0x99, 0x31, 0x31, 0x4f,
-    0x31, 0x55, 0x31, 0x5b, 0x31, 0x61, 0x31, 0xa2,
-    0x00, 0xa3, 0x00, 0xac, 0x00, 0xaf, 0x00, 0xa6,
-    0x00, 0xa5, 0x00, 0xa9, 0x20, 0x00, 0x00, 0x02,
-    0x25, 0x90, 0x21, 0x91, 0x21, 0x92, 0x21, 0x93,
-    0x21, 0xa0, 0x25, 0xcb, 0x25, 0x99, 0x10, 0xba,
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x9b, 0x10, 0xba,
-    0x10, 0x05, 0x05, 0xa5, 0x10, 0xba, 0x10, 0x05,
-    0x31, 0x11, 0x27, 0x11, 0x32, 0x11, 0x27, 0x11,
-    0x55, 0x47, 0x13, 0x3e, 0x13, 0x47, 0x13, 0x57,
-    0x13, 0x55, 0xb9, 0x14, 0xba, 0x14, 0xb9, 0x14,
-    0xb0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x14,
-    0xbd, 0x14, 0x55, 0x50, 0xb8, 0x15, 0xaf, 0x15,
-    0xb9, 0x15, 0xaf, 0x15, 0x55, 0x35, 0x19, 0x30,
-    0x19, 0x05, 0x57, 0xd1, 0x65, 0xd1, 0x58, 0xd1,
-    0x65, 0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f, 0xd1,
-    0x6f, 0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f, 0xd1,
-    0x71, 0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55, 0x55,
-    0x55, 0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba, 0xd1,
-    0x65, 0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc, 0xd1,
-    0x6e, 0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc, 0xd1,
-    0x6f, 0xd1, 0x55, 0x55, 0x55, 0x41, 0x00, 0x61,
-    0x00, 0x41, 0x00, 0x61, 0x00, 0x69, 0x00, 0x41,
-    0x00, 0x61, 0x00, 0x41, 0x00, 0x43, 0x44, 0x00,
-    0x00, 0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00, 0x00,
-    0x4e, 0x4f, 0x50, 0x51, 0x00, 0x53, 0x54, 0x55,
-    0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63,
-    0x64, 0x00, 0x66, 0x68, 0x00, 0x70, 0x00, 0x41,
-    0x00, 0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45,
-    0x46, 0x47, 0x4a, 0x00, 0x53, 0x00, 0x61, 0x00,
-    0x41, 0x42, 0x00, 0x44, 0x45, 0x46, 0x47, 0x00,
-    0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f, 0x53,
-    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
-    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
-    0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41,
-    0x00, 0x61, 0x00, 0x31, 0x01, 0x37, 0x02, 0x91,
-    0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24,
-    0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3,
-    0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f,
-    0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1,
-    0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20,
-    0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1,
-    0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91,
-    0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24,
-    0x00, 0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30,
-    0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30,
-    0x00, 0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x2a,
-    0x06, 0x1e, 0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a,
-    0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07,
-    0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10,
-    0x44, 0x90, 0x77, 0x45, 0x28, 0x06, 0x2c, 0x06,
-    0x00, 0x00, 0x47, 0x06, 0x33, 0x06, 0x17, 0x10,
-    0x11, 0x12, 0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f,
-    0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06,
-    0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06,
-    0x2d, 0x06, 0x00, 0x00, 0x4a, 0x06, 0x00, 0x00,
-    0x44, 0x06, 0x00, 0x00, 0x46, 0x06, 0x33, 0x06,
-    0x39, 0x06, 0x00, 0x00, 0x35, 0x06, 0x42, 0x06,
-    0x00, 0x00, 0x34, 0x06, 0x00, 0x00, 0x00, 0x00,
-    0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00,
-    0x3a, 0x06, 0x00, 0x00, 0xba, 0x06, 0x00, 0x00,
-    0x6f, 0x06, 0x00, 0x00, 0x28, 0x06, 0x2c, 0x06,
-    0x00, 0x00, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00,
-    0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06, 0x43, 0x06,
-    0x00, 0x00, 0x45, 0x06, 0x46, 0x06, 0x33, 0x06,
-    0x39, 0x06, 0x41, 0x06, 0x35, 0x06, 0x42, 0x06,
-    0x00, 0x00, 0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06,
-    0x2e, 0x06, 0x00, 0x00, 0x36, 0x06, 0x38, 0x06,
-    0x3a, 0x06, 0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06,
-    0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x20, 0x21,
-    0x0b, 0x06, 0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b,
+    0x21, 0x00, 0x1f, 0x00, 0x21, 0x02, 0x1f, 0x02,
+    0x21, 0x04, 0x1f, 0x04, 0x21, 0x05, 0x1f, 0x05,
+    0x21, 0x0d, 0x1f, 0x0d, 0x21, 0x0e, 0x1f, 0x0e,
+    0x21, 0x1d, 0x1e, 0x1d, 0x1f, 0x1e, 0x1f, 0x20,
+    0x1f, 0x20, 0x21, 0x24, 0x1f, 0x24, 0x21, 0x40,
+    0x06, 0x4e, 0x06, 0x51, 0x06, 0x27, 0x06, 0x10,
+    0x22, 0x10, 0x23, 0x12, 0x22, 0x12, 0x23, 0x13,
+    0x22, 0x13, 0x23, 0x0c, 0x22, 0x0c, 0x23, 0x0d,
+    0x22, 0x0d, 0x23, 0x06, 0x22, 0x06, 0x23, 0x05,
+    0x22, 0x05, 0x23, 0x07, 0x22, 0x07, 0x23, 0x0e,
+    0x22, 0x0e, 0x23, 0x0f, 0x22, 0x0f, 0x23, 0x0d,
+    0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e, 0x0d,
+    0x0a, 0x0c, 0x0a, 0x0e, 0x0a, 0x0f, 0x0a, 0x10,
+    0x22, 0x10, 0x23, 0x12, 0x22, 0x12, 0x23, 0x13,
+    0x22, 0x13, 0x23, 0x0c, 0x22, 0x0c, 0x23, 0x0d,
+    0x22, 0x0d, 0x23, 0x06, 0x22, 0x06, 0x23, 0x05,
+    0x22, 0x05, 0x23, 0x07, 0x22, 0x07, 0x23, 0x0e,
+    0x22, 0x0e, 0x23, 0x0f, 0x22, 0x0f, 0x23, 0x0d,
+    0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e, 0x0d,
+    0x0a, 0x0c, 0x0a, 0x0e, 0x0a, 0x0f, 0x0a, 0x0d,
+    0x05, 0x0d, 0x06, 0x0d, 0x07, 0x0d, 0x1e, 0x0c,
+    0x20, 0x0d, 0x20, 0x10, 0x1e, 0x0c, 0x05, 0x0c,
+    0x06, 0x0c, 0x07, 0x0d, 0x05, 0x0d, 0x06, 0x0d,
+    0x07, 0x10, 0x1e, 0x11, 0x1e, 0x00, 0x24, 0x00,
+    0x24, 0x2a, 0x06, 0x00, 0x02, 0x1b, 0x00, 0x03,
+    0x02, 0x00, 0x03, 0x02, 0x00, 0x03, 0x1b, 0x00,
+    0x04, 0x1b, 0x00, 0x1b, 0x02, 0x00, 0x1b, 0x03,
+    0x00, 0x1b, 0x04, 0x02, 0x1b, 0x03, 0x02, 0x1b,
+    0x03, 0x03, 0x1b, 0x20, 0x03, 0x1b, 0x1f, 0x09,
+    0x03, 0x02, 0x09, 0x02, 0x03, 0x09, 0x02, 0x1f,
+    0x09, 0x1b, 0x03, 0x09, 0x1b, 0x03, 0x09, 0x1b,
+    0x02, 0x09, 0x1b, 0x1b, 0x09, 0x1b, 0x1b, 0x0b,
+    0x03, 0x03, 0x0b, 0x03, 0x03, 0x0b, 0x1b, 0x1b,
+    0x0a, 0x03, 0x1b, 0x0a, 0x03, 0x1b, 0x0a, 0x02,
+    0x20, 0x0a, 0x1b, 0x04, 0x0a, 0x1b, 0x04, 0x0a,
+    0x1b, 0x1b, 0x0a, 0x1b, 0x1b, 0x0c, 0x03, 0x1f,
+    0x0c, 0x04, 0x1b, 0x0c, 0x04, 0x1b, 0x0d, 0x1b,
+    0x03, 0x0d, 0x1b, 0x03, 0x0d, 0x1b, 0x1b, 0x0d,
+    0x1b, 0x20, 0x0f, 0x02, 0x1b, 0x0f, 0x1b, 0x1b,
+    0x0f, 0x1b, 0x1b, 0x0f, 0x1b, 0x1f, 0x10, 0x1b,
+    0x1b, 0x10, 0x1b, 0x20, 0x10, 0x1b, 0x1f, 0x17,
+    0x04, 0x1b, 0x17, 0x04, 0x1b, 0x18, 0x1b, 0x03,
+    0x18, 0x1b, 0x1b, 0x1a, 0x03, 0x1b, 0x1a, 0x03,
+    0x20, 0x1a, 0x03, 0x1f, 0x1a, 0x02, 0x02, 0x1a,
+    0x02, 0x02, 0x1a, 0x04, 0x1b, 0x1a, 0x04, 0x1b,
+    0x1a, 0x1b, 0x03, 0x1a, 0x1b, 0x03, 0x1b, 0x03,
+    0x02, 0x1b, 0x03, 0x1b, 0x1b, 0x03, 0x20, 0x1b,
+    0x02, 0x03, 0x1b, 0x02, 0x1b, 0x1b, 0x04, 0x02,
+    0x1b, 0x04, 0x1b, 0x28, 0x06, 0x1d, 0x04, 0x06,
+    0x1f, 0x1d, 0x04, 0x1f, 0x1d, 0x1d, 0x1e, 0x05,
+    0x1d, 0x1e, 0x05, 0x21, 0x1e, 0x04, 0x1d, 0x1e,
+    0x04, 0x1d, 0x1e, 0x04, 0x21, 0x1e, 0x1d, 0x22,
+    0x1e, 0x1d, 0x21, 0x22, 0x1d, 0x1d, 0x22, 0x1d,
+    0x1d, 0x00, 0x06, 0x22, 0x02, 0x04, 0x22, 0x02,
+    0x04, 0x21, 0x02, 0x06, 0x22, 0x02, 0x06, 0x21,
+    0x02, 0x1d, 0x22, 0x02, 0x1d, 0x21, 0x04, 0x1d,
+    0x22, 0x04, 0x05, 0x21, 0x04, 0x1d, 0x21, 0x0b,
+    0x06, 0x21, 0x0d, 0x05, 0x22, 0x0c, 0x05, 0x22,
+    0x0e, 0x05, 0x22, 0x1c, 0x04, 0x22, 0x1c, 0x1d,
+    0x22, 0x22, 0x05, 0x22, 0x22, 0x04, 0x22, 0x22,
+    0x1d, 0x22, 0x1d, 0x1d, 0x22, 0x1a, 0x1d, 0x22,
+    0x1e, 0x05, 0x22, 0x1a, 0x1d, 0x05, 0x1c, 0x05,
+    0x1d, 0x11, 0x1d, 0x22, 0x1b, 0x1d, 0x22, 0x1e,
+    0x04, 0x05, 0x1d, 0x06, 0x22, 0x1c, 0x04, 0x1d,
+    0x1b, 0x1d, 0x1d, 0x1c, 0x04, 0x1d, 0x1e, 0x04,
+    0x05, 0x04, 0x05, 0x22, 0x05, 0x04, 0x22, 0x1d,
+    0x04, 0x22, 0x19, 0x1d, 0x22, 0x00, 0x05, 0x22,
+    0x1b, 0x1d, 0x1d, 0x11, 0x04, 0x1d, 0x0d, 0x1d,
+    0x1d, 0x0b, 0x06, 0x22, 0x1e, 0x04, 0x22, 0x35,
+    0x06, 0x00, 0x0f, 0x9d, 0x0d, 0x0f, 0x9d, 0x27,
+    0x06, 0x00, 0x1d, 0x1d, 0x20, 0x00, 0x1c, 0x01,
+    0x0a, 0x1e, 0x06, 0x1e, 0x08, 0x0e, 0x1d, 0x12,
+    0x1e, 0x0a, 0x0c, 0x21, 0x1d, 0x12, 0x1d, 0x23,
+    0x20, 0x21, 0x0c, 0x1d, 0x1e, 0x35, 0x06, 0x00,
+    0x0f, 0x14, 0x27, 0x06, 0x0e, 0x1d, 0x22, 0xff,
+    0x00, 0x1d, 0x1d, 0x20, 0xff, 0x12, 0x1d, 0x23,
+    0x20, 0xff, 0x21, 0x0c, 0x1d, 0x1e, 0x27, 0x06,
+    0x05, 0x1d, 0xff, 0x05, 0x1d, 0x00, 0x1d, 0x20,
+    0x27, 0x06, 0x0a, 0xa5, 0x00, 0x1d, 0x2c, 0x00,
+    0x01, 0x30, 0x02, 0x30, 0x3a, 0x00, 0x3b, 0x00,
+    0x21, 0x00, 0x3f, 0x00, 0x16, 0x30, 0x17, 0x30,
+    0x26, 0x20, 0x13, 0x20, 0x12, 0x01, 0x00, 0x5f,
+    0x5f, 0x28, 0x29, 0x7b, 0x7d, 0x08, 0x30, 0x0c,
+    0x0d, 0x08, 0x09, 0x02, 0x03, 0x00, 0x01, 0x04,
+    0x05, 0x06, 0x07, 0x5b, 0x00, 0x5d, 0x00, 0x3e,
+    0x20, 0x3e, 0x20, 0x3e, 0x20, 0x3e, 0x20, 0x5f,
+    0x00, 0x5f, 0x00, 0x5f, 0x00, 0x2c, 0x00, 0x01,
+    0x30, 0x2e, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x3a,
+    0x00, 0x3f, 0x00, 0x21, 0x00, 0x14, 0x20, 0x28,
+    0x00, 0x29, 0x00, 0x7b, 0x00, 0x7d, 0x00, 0x14,
+    0x30, 0x15, 0x30, 0x23, 0x26, 0x2a, 0x2b, 0x2d,
+    0x3c, 0x3e, 0x3d, 0x00, 0x5c, 0x24, 0x25, 0x40,
+    0x40, 0x06, 0xff, 0x0b, 0x00, 0x0b, 0xff, 0x0c,
+    0x20, 0x00, 0x4d, 0x06, 0x40, 0x06, 0xff, 0x0e,
+    0x00, 0x0e, 0xff, 0x0f, 0x00, 0x0f, 0xff, 0x10,
+    0x00, 0x10, 0xff, 0x11, 0x00, 0x11, 0xff, 0x12,
+    0x00, 0x12, 0x21, 0x06, 0x00, 0x01, 0x01, 0x02,
+    0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05,
+    0x05, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08,
+    0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a,
+    0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c,
+    0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0f,
+    0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x12,
+    0x12, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14,
+    0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16,
+    0x16, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18,
+    0x18, 0x19, 0x19, 0x19, 0x19, 0x20, 0x20, 0x20,
+    0x20, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22, 0x22,
+    0x22, 0x23, 0x23, 0x23, 0x23, 0x24, 0x24, 0x24,
+    0x24, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26,
+    0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29, 0x29,
+    0x29, 0x22, 0x06, 0x22, 0x00, 0x22, 0x00, 0x22,
+    0x01, 0x22, 0x01, 0x22, 0x03, 0x22, 0x03, 0x22,
+    0x05, 0x22, 0x05, 0x21, 0x00, 0x85, 0x29, 0x01,
+    0x30, 0x01, 0x0b, 0x0c, 0x00, 0xfa, 0xf1, 0xa0,
+    0xa2, 0xa4, 0xa6, 0xa8, 0xe2, 0xe4, 0xe6, 0xc2,
+    0xfb, 0xa1, 0xa3, 0xa5, 0xa7, 0xa9, 0xaa, 0xac,
+    0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc,
+    0xbe, 0xc0, 0xc3, 0xc5, 0xc7, 0xc9, 0xca, 0xcb,
+    0xcc, 0xcd, 0xce, 0xd1, 0xd4, 0xd7, 0xda, 0xdd,
+    0xde, 0xdf, 0xe0, 0xe1, 0xe3, 0xe5, 0xe7, 0xe8,
+    0xe9, 0xea, 0xeb, 0xec, 0xee, 0xf2, 0x98, 0x99,
+    0x31, 0x31, 0x4f, 0x31, 0x55, 0x31, 0x5b, 0x31,
+    0x61, 0x31, 0xa2, 0x00, 0xa3, 0x00, 0xac, 0x00,
+    0xaf, 0x00, 0xa6, 0x00, 0xa5, 0x00, 0xa9, 0x20,
+    0x00, 0x00, 0x02, 0x25, 0x90, 0x21, 0x91, 0x21,
+    0x92, 0x21, 0x93, 0x21, 0xa0, 0x25, 0xcb, 0x25,
+    0xd0, 0x02, 0xd1, 0x02, 0xe6, 0x00, 0x99, 0x02,
+    0x53, 0x02, 0x00, 0x00, 0xa3, 0x02, 0x66, 0xab,
+    0xa5, 0x02, 0xa4, 0x02, 0x56, 0x02, 0x57, 0x02,
+    0x91, 0x1d, 0x58, 0x02, 0x5e, 0x02, 0xa9, 0x02,
+    0x64, 0x02, 0x62, 0x02, 0x60, 0x02, 0x9b, 0x02,
+    0x27, 0x01, 0x9c, 0x02, 0x67, 0x02, 0x84, 0x02,
+    0xaa, 0x02, 0xab, 0x02, 0x6c, 0x02, 0x04, 0xdf,
+    0x8e, 0xa7, 0x6e, 0x02, 0x05, 0xdf, 0x8e, 0x02,
+    0x06, 0xdf, 0xf8, 0x00, 0x76, 0x02, 0x77, 0x02,
+    0x71, 0x00, 0x7a, 0x02, 0x08, 0xdf, 0x7d, 0x02,
+    0x7e, 0x02, 0x80, 0x02, 0xa8, 0x02, 0xa6, 0x02,
+    0x67, 0xab, 0xa7, 0x02, 0x88, 0x02, 0x71, 0x2c,
+    0x00, 0x00, 0x8f, 0x02, 0xa1, 0x02, 0xa2, 0x02,
+    0x98, 0x02, 0xc0, 0x01, 0xc1, 0x01, 0xc2, 0x01,
+    0x0a, 0xdf, 0x1e, 0xdf, 0x41, 0x04, 0x40, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x99, 0x10, 0xba, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x9b, 0x10, 0xba, 0x10,
+    0x05, 0x05, 0xa5, 0x10, 0xba, 0x10, 0x05, 0x31,
+    0x11, 0x27, 0x11, 0x32, 0x11, 0x27, 0x11, 0x55,
+    0x47, 0x13, 0x3e, 0x13, 0x47, 0x13, 0x57, 0x13,
+    0x55, 0xb9, 0x14, 0xba, 0x14, 0xb9, 0x14, 0xb0,
+    0x14, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x14, 0xbd,
+    0x14, 0x55, 0x50, 0xb8, 0x15, 0xaf, 0x15, 0xb9,
+    0x15, 0xaf, 0x15, 0x55, 0x35, 0x19, 0x30, 0x19,
+    0x05, 0x57, 0xd1, 0x65, 0xd1, 0x58, 0xd1, 0x65,
+    0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f, 0xd1, 0x6f,
+    0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f, 0xd1, 0x71,
+    0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55, 0x55, 0x55,
+    0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba, 0xd1, 0x65,
+    0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc, 0xd1, 0x6e,
+    0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc, 0xd1, 0x6f,
+    0xd1, 0x55, 0x55, 0x55, 0x41, 0x00, 0x61, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x69, 0x00, 0x41, 0x00,
+    0x61, 0x00, 0x41, 0x00, 0x43, 0x44, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00, 0x00, 0x4e,
+    0x4f, 0x50, 0x51, 0x00, 0x53, 0x54, 0x55, 0x56,
+    0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
+    0x00, 0x66, 0x68, 0x00, 0x70, 0x00, 0x41, 0x00,
+    0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45, 0x46,
+    0x47, 0x4a, 0x00, 0x53, 0x00, 0x61, 0x00, 0x41,
+    0x42, 0x00, 0x44, 0x45, 0x46, 0x47, 0x00, 0x49,
+    0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f, 0x53, 0x00,
+    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
+    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
+    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
+    0x61, 0x00, 0x31, 0x01, 0x37, 0x02, 0x91, 0x03,
+    0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
+    0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03,
+    0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04,
+    0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
+    0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
+    0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
+    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
+    0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
+    0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30, 0x00,
+    0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
+    0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x2a, 0x06,
+    0x1e, 0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a, 0x1b,
     0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a,
-    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28,
-    0x06, 0x2c, 0x06, 0x2f, 0x06, 0x00, 0x00, 0x48,
-    0x06, 0x32, 0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a,
-    0x06, 0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f,
-    0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04,
-    0x06, 0x0c, 0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00,
-    0x2c, 0x00, 0x28, 0x00, 0x41, 0x00, 0x29, 0x00,
-    0x14, 0x30, 0x53, 0x00, 0x15, 0x30, 0x43, 0x52,
-    0x43, 0x44, 0x57, 0x5a, 0x41, 0x00, 0x48, 0x56,
-    0x4d, 0x56, 0x53, 0x44, 0x53, 0x53, 0x50, 0x50,
-    0x56, 0x57, 0x43, 0x4d, 0x43, 0x4d, 0x44, 0x4d,
-    0x52, 0x44, 0x4a, 0x4b, 0x30, 0x30, 0x00, 0x68,
-    0x68, 0x4b, 0x62, 0x57, 0x5b, 0xcc, 0x53, 0xc7,
-    0x30, 0x8c, 0x4e, 0x1a, 0x59, 0xe3, 0x89, 0x29,
-    0x59, 0xa4, 0x4e, 0x20, 0x66, 0x21, 0x71, 0x99,
-    0x65, 0x4d, 0x52, 0x8c, 0x5f, 0x8d, 0x51, 0xb0,
-    0x65, 0x1d, 0x52, 0x42, 0x7d, 0x1f, 0x75, 0xa9,
-    0x8c, 0xf0, 0x58, 0x39, 0x54, 0x14, 0x6f, 0x95,
-    0x62, 0x55, 0x63, 0x00, 0x4e, 0x09, 0x4e, 0x4a,
-    0x90, 0xe6, 0x5d, 0x2d, 0x4e, 0xf3, 0x53, 0x07,
-    0x63, 0x70, 0x8d, 0x53, 0x62, 0x81, 0x79, 0x7a,
-    0x7a, 0x08, 0x54, 0x80, 0x6e, 0x09, 0x67, 0x08,
-    0x67, 0x33, 0x75, 0x72, 0x52, 0xb6, 0x55, 0x4d,
-    0x91, 0x14, 0x30, 0x15, 0x30, 0x2c, 0x67, 0x09,
-    0x4e, 0x8c, 0x4e, 0x89, 0x5b, 0xb9, 0x70, 0x53,
-    0x62, 0xd7, 0x76, 0xdd, 0x52, 0x57, 0x65, 0x97,
-    0x5f, 0xef, 0x53, 0x30, 0x00, 0x38, 0x4e, 0x05,
-    0x00, 0x09, 0x22, 0x01, 0x60, 0x4f, 0xae, 0x4f,
-    0xbb, 0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99, 0x50,
-    0xe7, 0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a, 0x06,
-    0x4d, 0x51, 0x54, 0x51, 0x64, 0x51, 0x77, 0x51,
-    0x1c, 0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d, 0x51,
-    0x4b, 0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc, 0x4e,
-    0xac, 0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5, 0x51,
-    0x03, 0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46, 0x52,
-    0x72, 0x52, 0x77, 0x52, 0x15, 0x35, 0x02, 0x00,
-    0x20, 0x80, 0x80, 0x00, 0x08, 0x00, 0x00, 0xc7,
-    0x52, 0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f, 0x50,
-    0x82, 0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8, 0xb8,
-    0x2c, 0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf, 0x53,
-    0x63, 0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06, 0x54,
-    0x9e, 0x54, 0x38, 0x54, 0x48, 0x54, 0x68, 0x54,
-    0xa2, 0x54, 0xf6, 0x54, 0x10, 0x55, 0x53, 0x55,
-    0x63, 0x55, 0x84, 0x55, 0x84, 0x55, 0x99, 0x55,
-    0xab, 0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16, 0x57,
-    0x06, 0x56, 0x17, 0x57, 0x51, 0x56, 0x74, 0x56,
-    0x07, 0x52, 0xee, 0x58, 0xce, 0x57, 0xf4, 0x57,
-    0x0d, 0x58, 0x8b, 0x57, 0x32, 0x58, 0x31, 0x58,
-    0xac, 0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7, 0x58,
-    0x06, 0x59, 0x1a, 0x59, 0x22, 0x59, 0x62, 0x59,
-    0xa8, 0x16, 0xea, 0x16, 0xec, 0x59, 0x1b, 0x5a,
-    0x27, 0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee, 0x36,
-    0xfc, 0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e, 0x5b,
-    0xc8, 0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7, 0x5b,
-    0xf3, 0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06, 0x5c,
-    0x53, 0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60, 0x5c,
-    0x6e, 0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4, 0x1d,
-    0x43, 0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b, 0x5d,
-    0x7c, 0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f, 0x38,
-    0xfd, 0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69, 0x5e,
-    0x62, 0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0, 0x5e,
-    0xb3, 0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92, 0xa3,
-    0xfe, 0x5e, 0x31, 0x23, 0x31, 0x23, 0x01, 0x82,
-    0x22, 0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8, 0x32,
-    0xda, 0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3, 0x38,
-    0x9a, 0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9, 0x5f,
-    0x81, 0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94, 0x60,
-    0xd4, 0x26, 0xc7, 0x60, 0x02, 0x02, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a,
-    0x00, 0x00, 0x02, 0x08, 0x00, 0x80, 0x08, 0x00,
-    0x00, 0x08, 0x80, 0x28, 0x80, 0x02, 0x00, 0x00,
-    0x02, 0x48, 0x61, 0x00, 0x04, 0x06, 0x04, 0x32,
-    0x46, 0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae, 0xc8,
-    0xd3, 0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3, 0x0c,
-    0x2b, 0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63, 0x83,
-    0x63, 0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64, 0xc5,
-    0x63, 0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64, 0x7e,
-    0x64, 0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a, 0x4f,
-    0x65, 0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65, 0xf8,
-    0x66, 0x49, 0x66, 0x19, 0x3b, 0x91, 0x66, 0x08,
-    0x3b, 0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51, 0x00,
-    0x67, 0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43, 0x17,
-    0x67, 0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67, 0x53,
-    0x67, 0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67, 0x85,
-    0x67, 0x52, 0x68, 0x85, 0x68, 0x6d, 0x34, 0x8e,
-    0x68, 0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b, 0x42,
-    0x69, 0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a, 0xa3,
-    0x36, 0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b, 0xa7,
-    0x38, 0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b, 0x9f,
-    0x6b, 0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a, 0x0b,
-    0x1d, 0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c, 0xbf,
-    0x6c, 0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d, 0x3e,
-    0x6d, 0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d, 0x78,
-    0x6d, 0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d, 0x2f,
-    0x6e, 0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e, 0xc7,
-    0x6e, 0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f, 0x5e,
-    0x3f, 0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70, 0x1e,
-    0x70, 0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70, 0x7d,
-    0x70, 0x77, 0x70, 0xad, 0x70, 0x25, 0x05, 0x45,
-    0x71, 0x63, 0x42, 0x9c, 0x71, 0xab, 0x43, 0x28,
-    0x72, 0x35, 0x72, 0x50, 0x72, 0x08, 0x46, 0x80,
-    0x72, 0x95, 0x72, 0x35, 0x47, 0x02, 0x20, 0x00,
-    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80,
-    0x00, 0x00, 0x02, 0x02, 0x80, 0x8a, 0x00, 0x00,
-    0x20, 0x00, 0x08, 0x0a, 0x00, 0x80, 0x88, 0x80,
-    0x20, 0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73, 0xac,
-    0x3e, 0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e, 0x47,
-    0x74, 0x5c, 0x74, 0x71, 0x74, 0x85, 0x74, 0xca,
-    0x74, 0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c, 0x3e,
-    0x75, 0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21, 0x10,
-    0x76, 0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50, 0xfc,
-    0x3f, 0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50, 0xf2,
-    0x50, 0x19, 0x51, 0x33, 0x51, 0x1e, 0x77, 0x1f,
-    0x77, 0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40, 0x8b,
-    0x77, 0x46, 0x40, 0x96, 0x40, 0x1d, 0x54, 0x4e,
-    0x78, 0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40, 0x26,
-    0x56, 0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56, 0x8f,
-    0x79, 0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a, 0x4a,
-    0x7a, 0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a, 0xa7,
-    0x5a, 0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b, 0xc6,
-    0x7b, 0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c, 0xd2,
-    0x7c, 0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c, 0x00,
-    0x7d, 0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43, 0xc7,
-    0x7d, 0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43, 0x28,
-    0x62, 0x47, 0x62, 0x59, 0x43, 0xd9, 0x62, 0x7a,
-    0x7f, 0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f, 0x05,
-    0x80, 0xda, 0x64, 0x23, 0x65, 0x60, 0x80, 0xa8,
-    0x65, 0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43, 0xb2,
-    0x80, 0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81, 0xb5,
-    0x5a, 0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33, 0x9c,
-    0x33, 0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f, 0x6b,
-    0x44, 0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82, 0xb3,
-    0x52, 0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82, 0xe6,
-    0x82, 0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83, 0x63,
-    0x83, 0xad, 0x83, 0x23, 0x83, 0xbd, 0x83, 0xe7,
-    0x83, 0x57, 0x84, 0x53, 0x83, 0xca, 0x83, 0xcc,
-    0x83, 0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d, 0x02,
-    0x00, 0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a, 0x00,
-    0x20, 0x80, 0x28, 0x00, 0xa8, 0x20, 0x20, 0x00,
-    0x02, 0x80, 0x22, 0x02, 0x8a, 0x08, 0x00, 0xaa,
-    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x28, 0xd5,
-    0x6c, 0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84, 0x16,
-    0x85, 0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f, 0x5d,
-    0x45, 0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70, 0x6b,
-    0x45, 0x50, 0x86, 0x5c, 0x86, 0x67, 0x86, 0x69,
-    0x86, 0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87, 0xe2,
-    0x86, 0x79, 0x87, 0x28, 0x87, 0x6b, 0x87, 0x86,
-    0x87, 0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88, 0xf9,
-    0x45, 0x60, 0x88, 0x63, 0x88, 0x67, 0x76, 0xd7,
-    0x88, 0xde, 0x88, 0x35, 0x46, 0xfa, 0x88, 0xbb,
-    0x34, 0xae, 0x78, 0x66, 0x79, 0xbe, 0x46, 0xc7,
-    0x46, 0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b, 0x55,
-    0x8c, 0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c, 0x1b,
-    0x8d, 0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08, 0xcb,
-    0x8d, 0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08, 0xd4,
-    0x8e, 0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85, 0x94,
-    0x90, 0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87, 0x1b,
-    0x91, 0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92, 0x7c,
-    0x92, 0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b, 0x8b,
-    0x95, 0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d, 0xe6,
-    0x49, 0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97, 0x45,
-    0x91, 0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a, 0xe0,
-    0x97, 0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94, 0x0b,
-    0x98, 0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95, 0xe2,
-    0x98, 0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99, 0xc2,
-    0x99, 0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b, 0x12,
-    0x9b, 0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c, 0xed,
-    0x4c, 0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c, 0x05,
-    0xa1, 0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e, 0x56,
-    0x4d, 0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f, 0x0f,
-    0x9f, 0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6, 0x02,
-    0x88, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
-    0x28, 0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80, 0x00,
-    0x80, 0x80, 0x00, 0x0a, 0x88, 0x80, 0x00, 0x80,
-    0x00, 0x20, 0x2a, 0x00, 0x80,
+    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x44,
+    0x90, 0x77, 0x45, 0x28, 0x06, 0x2c, 0x06, 0x00,
+    0x00, 0x47, 0x06, 0x33, 0x06, 0x17, 0x10, 0x11,
+    0x12, 0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f, 0x34,
+    0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00,
+    0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x2d,
+    0x06, 0x00, 0x00, 0x4a, 0x06, 0x00, 0x00, 0x44,
+    0x06, 0x00, 0x00, 0x46, 0x06, 0x33, 0x06, 0x39,
+    0x06, 0x00, 0x00, 0x35, 0x06, 0x42, 0x06, 0x00,
+    0x00, 0x34, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2e,
+    0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a,
+    0x06, 0x00, 0x00, 0xba, 0x06, 0x00, 0x00, 0x6f,
+    0x06, 0x00, 0x00, 0x28, 0x06, 0x2c, 0x06, 0x00,
+    0x00, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2d,
+    0x06, 0x37, 0x06, 0x4a, 0x06, 0x43, 0x06, 0x00,
+    0x00, 0x45, 0x06, 0x46, 0x06, 0x33, 0x06, 0x39,
+    0x06, 0x41, 0x06, 0x35, 0x06, 0x42, 0x06, 0x00,
+    0x00, 0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e,
+    0x06, 0x00, 0x00, 0x36, 0x06, 0x38, 0x06, 0x3a,
+    0x06, 0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06, 0x27,
+    0x06, 0x00, 0x01, 0x05, 0x08, 0x20, 0x21, 0x0b,
+    0x06, 0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b, 0x1c,
+    0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00,
+    0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28, 0x06,
+    0x2c, 0x06, 0x2f, 0x06, 0x00, 0x00, 0x48, 0x06,
+    0x32, 0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06,
+    0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
+    0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06,
+    0x0c, 0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00, 0x2c,
+    0x00, 0x28, 0x00, 0x41, 0x00, 0x29, 0x00, 0x14,
+    0x30, 0x53, 0x00, 0x15, 0x30, 0x43, 0x52, 0x43,
+    0x44, 0x57, 0x5a, 0x41, 0x00, 0x48, 0x56, 0x4d,
+    0x56, 0x53, 0x44, 0x53, 0x53, 0x50, 0x50, 0x56,
+    0x57, 0x43, 0x4d, 0x43, 0x4d, 0x44, 0x4d, 0x52,
+    0x44, 0x4a, 0x4b, 0x30, 0x30, 0x00, 0x68, 0x68,
+    0x4b, 0x62, 0x57, 0x5b, 0xcc, 0x53, 0xc7, 0x30,
+    0x8c, 0x4e, 0x1a, 0x59, 0xe3, 0x89, 0x29, 0x59,
+    0xa4, 0x4e, 0x20, 0x66, 0x21, 0x71, 0x99, 0x65,
+    0x4d, 0x52, 0x8c, 0x5f, 0x8d, 0x51, 0xb0, 0x65,
+    0x1d, 0x52, 0x42, 0x7d, 0x1f, 0x75, 0xa9, 0x8c,
+    0xf0, 0x58, 0x39, 0x54, 0x14, 0x6f, 0x95, 0x62,
+    0x55, 0x63, 0x00, 0x4e, 0x09, 0x4e, 0x4a, 0x90,
+    0xe6, 0x5d, 0x2d, 0x4e, 0xf3, 0x53, 0x07, 0x63,
+    0x70, 0x8d, 0x53, 0x62, 0x81, 0x79, 0x7a, 0x7a,
+    0x08, 0x54, 0x80, 0x6e, 0x09, 0x67, 0x08, 0x67,
+    0x33, 0x75, 0x72, 0x52, 0xb6, 0x55, 0x4d, 0x91,
+    0x14, 0x30, 0x15, 0x30, 0x2c, 0x67, 0x09, 0x4e,
+    0x8c, 0x4e, 0x89, 0x5b, 0xb9, 0x70, 0x53, 0x62,
+    0xd7, 0x76, 0xdd, 0x52, 0x57, 0x65, 0x97, 0x5f,
+    0xef, 0x53, 0x30, 0x00, 0x38, 0x4e, 0x05, 0x00,
+    0x09, 0x22, 0x01, 0x60, 0x4f, 0xae, 0x4f, 0xbb,
+    0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99, 0x50, 0xe7,
+    0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a, 0x06, 0x4d,
+    0x51, 0x54, 0x51, 0x64, 0x51, 0x77, 0x51, 0x1c,
+    0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d, 0x51, 0x4b,
+    0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc, 0x4e, 0xac,
+    0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5, 0x51, 0x03,
+    0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46, 0x52, 0x72,
+    0x52, 0x77, 0x52, 0x15, 0x35, 0x02, 0x00, 0x20,
+    0x80, 0x80, 0x00, 0x08, 0x00, 0x00, 0xc7, 0x52,
+    0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f, 0x50, 0x82,
+    0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8, 0xb8, 0x2c,
+    0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf, 0x53, 0x63,
+    0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06, 0x54, 0x9e,
+    0x54, 0x38, 0x54, 0x48, 0x54, 0x68, 0x54, 0xa2,
+    0x54, 0xf6, 0x54, 0x10, 0x55, 0x53, 0x55, 0x63,
+    0x55, 0x84, 0x55, 0x84, 0x55, 0x99, 0x55, 0xab,
+    0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16, 0x57, 0x06,
+    0x56, 0x17, 0x57, 0x51, 0x56, 0x74, 0x56, 0x07,
+    0x52, 0xee, 0x58, 0xce, 0x57, 0xf4, 0x57, 0x0d,
+    0x58, 0x8b, 0x57, 0x32, 0x58, 0x31, 0x58, 0xac,
+    0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7, 0x58, 0x06,
+    0x59, 0x1a, 0x59, 0x22, 0x59, 0x62, 0x59, 0xa8,
+    0x16, 0xea, 0x16, 0xec, 0x59, 0x1b, 0x5a, 0x27,
+    0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee, 0x36, 0xfc,
+    0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e, 0x5b, 0xc8,
+    0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7, 0x5b, 0xf3,
+    0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06, 0x5c, 0x53,
+    0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60, 0x5c, 0x6e,
+    0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4, 0x1d, 0x43,
+    0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b, 0x5d, 0x7c,
+    0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f, 0x38, 0xfd,
+    0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69, 0x5e, 0x62,
+    0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0, 0x5e, 0xb3,
+    0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92, 0xa3, 0xfe,
+    0x5e, 0x31, 0x23, 0x31, 0x23, 0x01, 0x82, 0x22,
+    0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8, 0x32, 0xda,
+    0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3, 0x38, 0x9a,
+    0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9, 0x5f, 0x81,
+    0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94, 0x60, 0xd4,
+    0x26, 0xc7, 0x60, 0x02, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00,
+    0x00, 0x02, 0x08, 0x00, 0x80, 0x08, 0x00, 0x00,
+    0x08, 0x80, 0x28, 0x80, 0x02, 0x00, 0x00, 0x02,
+    0x48, 0x61, 0x00, 0x04, 0x06, 0x04, 0x32, 0x46,
+    0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae, 0xc8, 0xd3,
+    0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3, 0x0c, 0x2b,
+    0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63, 0x83, 0x63,
+    0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64, 0xc5, 0x63,
+    0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64, 0x7e, 0x64,
+    0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a, 0x4f, 0x65,
+    0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65, 0xf8, 0x66,
+    0x49, 0x66, 0x19, 0x3b, 0x91, 0x66, 0x08, 0x3b,
+    0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51, 0x00, 0x67,
+    0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43, 0x17, 0x67,
+    0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67, 0x53, 0x67,
+    0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67, 0x85, 0x67,
+    0x52, 0x68, 0x85, 0x68, 0x6d, 0x34, 0x8e, 0x68,
+    0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b, 0x42, 0x69,
+    0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a, 0xa3, 0x36,
+    0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b, 0xa7, 0x38,
+    0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b, 0x9f, 0x6b,
+    0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a, 0x0b, 0x1d,
+    0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c, 0xbf, 0x6c,
+    0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d, 0x3e, 0x6d,
+    0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d, 0x78, 0x6d,
+    0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d, 0x2f, 0x6e,
+    0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e, 0xc7, 0x6e,
+    0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f, 0x5e, 0x3f,
+    0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70, 0x1e, 0x70,
+    0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70, 0x7d, 0x70,
+    0x77, 0x70, 0xad, 0x70, 0x25, 0x05, 0x45, 0x71,
+    0x63, 0x42, 0x9c, 0x71, 0xab, 0x43, 0x28, 0x72,
+    0x35, 0x72, 0x50, 0x72, 0x08, 0x46, 0x80, 0x72,
+    0x95, 0x72, 0x35, 0x47, 0x02, 0x20, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80, 0x00,
+    0x00, 0x02, 0x02, 0x80, 0x8a, 0x00, 0x00, 0x20,
+    0x00, 0x08, 0x0a, 0x00, 0x80, 0x88, 0x80, 0x20,
+    0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73, 0xac, 0x3e,
+    0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e, 0x47, 0x74,
+    0x5c, 0x74, 0x71, 0x74, 0x85, 0x74, 0xca, 0x74,
+    0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c, 0x3e, 0x75,
+    0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21, 0x10, 0x76,
+    0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50, 0xfc, 0x3f,
+    0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50, 0xf2, 0x50,
+    0x19, 0x51, 0x33, 0x51, 0x1e, 0x77, 0x1f, 0x77,
+    0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40, 0x8b, 0x77,
+    0x46, 0x40, 0x96, 0x40, 0x1d, 0x54, 0x4e, 0x78,
+    0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40, 0x26, 0x56,
+    0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56, 0x8f, 0x79,
+    0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a, 0x4a, 0x7a,
+    0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a, 0xa7, 0x5a,
+    0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b, 0xc6, 0x7b,
+    0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c, 0xd2, 0x7c,
+    0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c, 0x00, 0x7d,
+    0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43, 0xc7, 0x7d,
+    0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43, 0x28, 0x62,
+    0x47, 0x62, 0x59, 0x43, 0xd9, 0x62, 0x7a, 0x7f,
+    0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f, 0x05, 0x80,
+    0xda, 0x64, 0x23, 0x65, 0x60, 0x80, 0xa8, 0x65,
+    0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43, 0xb2, 0x80,
+    0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81, 0xb5, 0x5a,
+    0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33, 0x9c, 0x33,
+    0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f, 0x6b, 0x44,
+    0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82, 0xb3, 0x52,
+    0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82, 0xe6, 0x82,
+    0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83, 0x63, 0x83,
+    0xad, 0x83, 0x23, 0x83, 0xbd, 0x83, 0xe7, 0x83,
+    0x57, 0x84, 0x53, 0x83, 0xca, 0x83, 0xcc, 0x83,
+    0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d, 0x02, 0x00,
+    0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a, 0x00, 0x20,
+    0x80, 0x28, 0x00, 0xa8, 0x20, 0x20, 0x00, 0x02,
+    0x80, 0x22, 0x02, 0x8a, 0x08, 0x00, 0xaa, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x28, 0xd5, 0x6c,
+    0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84, 0x16, 0x85,
+    0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f, 0x5d, 0x45,
+    0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70, 0x6b, 0x45,
+    0x50, 0x86, 0x5c, 0x86, 0x67, 0x86, 0x69, 0x86,
+    0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87, 0xe2, 0x86,
+    0x79, 0x87, 0x28, 0x87, 0x6b, 0x87, 0x86, 0x87,
+    0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88, 0xf9, 0x45,
+    0x60, 0x88, 0x63, 0x88, 0x67, 0x76, 0xd7, 0x88,
+    0xde, 0x88, 0x35, 0x46, 0xfa, 0x88, 0xbb, 0x34,
+    0xae, 0x78, 0x66, 0x79, 0xbe, 0x46, 0xc7, 0x46,
+    0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b, 0x55, 0x8c,
+    0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c, 0x1b, 0x8d,
+    0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08, 0xcb, 0x8d,
+    0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08, 0xd4, 0x8e,
+    0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85, 0x94, 0x90,
+    0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87, 0x1b, 0x91,
+    0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92, 0x7c, 0x92,
+    0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b, 0x8b, 0x95,
+    0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d, 0xe6, 0x49,
+    0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97, 0x45, 0x91,
+    0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a, 0xe0, 0x97,
+    0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94, 0x0b, 0x98,
+    0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95, 0xe2, 0x98,
+    0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99, 0xc2, 0x99,
+    0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b, 0x12, 0x9b,
+    0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c, 0xed, 0x4c,
+    0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c, 0x05, 0xa1,
+    0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e, 0x56, 0x4d,
+    0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f, 0x0f, 0x9f,
+    0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6, 0x02, 0x88,
+    0xa0, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x28,
+    0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80, 0x00, 0x80,
+    0x80, 0x00, 0x0a, 0x88, 0x80, 0x00, 0x80, 0x00,
+    0x20, 0x2a, 0x00, 0x80,
 };
 
 static const uint16_t unicode_comp_table[945] = {
@@ -2191,9 +2225,9 @@ static const uint16_t unicode_comp_table[945] = {
     0x5704, 0x5706, 0x5708, 0x570a, 0x570c, 0x570e, 0x5710, 0x5712,
     0x5714, 0x5716, 0x5740, 0x5742, 0x5744, 0x5780, 0x5781, 0x57c0,
     0x57c1, 0x5800, 0x5801, 0x5840, 0x5841, 0x5880, 0x5881, 0x5900,
-    0x5901, 0x5902, 0x5903, 0x5940, 0x8e80, 0x8e82, 0x8ec0, 0x8f00,
-    0x8f01, 0x8f40, 0x8f41, 0x8f81, 0x8f80, 0x8f83, 0x8fc0, 0x8fc1,
-    0x9000,
+    0x5901, 0x5902, 0x5903, 0x5940, 0x8f40, 0x8f42, 0x8f80, 0x8fc0,
+    0x8fc1, 0x9000, 0x9001, 0x9041, 0x9040, 0x9043, 0x9080, 0x9081,
+    0x90c0,
 };
 
 typedef enum {
@@ -2279,7 +2313,7 @@ static const char unicode_gc_name_table[] =
     "C,Other"                  "\0"
 ;
 
-static const uint8_t unicode_gc_table[3790] = {
+static const uint8_t unicode_gc_table[3897] = {
     0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13,
     0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
     0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e,
@@ -2312,448 +2346,462 @@ static const uint8_t unicode_gc_table[3790] = {
     0x11, 0x06, 0x16, 0x26, 0x16, 0x26, 0x16, 0x06,
     0xe0, 0x00, 0xe5, 0x13, 0x60, 0x65, 0x36, 0xe0,
     0x03, 0xbb, 0x4c, 0x36, 0x0d, 0x36, 0x2f, 0xe6,
-    0x03, 0x16, 0x1b, 0x00, 0x36, 0xe5, 0x18, 0x04,
-    0xe5, 0x02, 0xe6, 0x0d, 0xe9, 0x02, 0x76, 0x25,
-    0x06, 0xe5, 0x5b, 0x16, 0x05, 0xc6, 0x1b, 0x0f,
-    0xa6, 0x24, 0x26, 0x0f, 0x66, 0x25, 0xe9, 0x02,
-    0x45, 0x2f, 0x05, 0xf6, 0x06, 0x00, 0x1b, 0x05,
-    0x06, 0xe5, 0x16, 0xe6, 0x13, 0x20, 0xe5, 0x51,
-    0xe6, 0x03, 0x05, 0xe0, 0x06, 0xe9, 0x02, 0xe5,
-    0x19, 0xe6, 0x01, 0x24, 0x0f, 0x56, 0x04, 0x20,
-    0x06, 0x2d, 0xe5, 0x0e, 0x66, 0x04, 0xe6, 0x01,
-    0x04, 0x46, 0x04, 0x86, 0x20, 0xf6, 0x07, 0x00,
-    0xe5, 0x11, 0x46, 0x20, 0x16, 0x00, 0xe5, 0x03,
-    0xe0, 0x2d, 0xe5, 0x0d, 0x00, 0xe5, 0x0a, 0xe0,
-    0x03, 0xe6, 0x07, 0x1b, 0xe6, 0x18, 0x07, 0xe5,
-    0x2e, 0x06, 0x07, 0x06, 0x05, 0x47, 0xe6, 0x00,
-    0x67, 0x06, 0x27, 0x05, 0xc6, 0xe5, 0x02, 0x26,
-    0x36, 0xe9, 0x02, 0x16, 0x04, 0xe5, 0x07, 0x06,
-    0x27, 0x00, 0xe5, 0x00, 0x20, 0x25, 0x20, 0xe5,
-    0x0e, 0x00, 0xc5, 0x00, 0x05, 0x40, 0x65, 0x20,
-    0x06, 0x05, 0x47, 0x66, 0x20, 0x27, 0x20, 0x27,
-    0x06, 0x05, 0xe0, 0x00, 0x07, 0x60, 0x25, 0x00,
-    0x45, 0x26, 0x20, 0xe9, 0x02, 0x25, 0x2d, 0xab,
-    0x0f, 0x0d, 0x05, 0x16, 0x06, 0x20, 0x26, 0x07,
-    0x00, 0xa5, 0x60, 0x25, 0x20, 0xe5, 0x0e, 0x00,
-    0xc5, 0x00, 0x25, 0x00, 0x25, 0x00, 0x25, 0x20,
-    0x06, 0x00, 0x47, 0x26, 0x60, 0x26, 0x20, 0x46,
-    0x40, 0x06, 0xc0, 0x65, 0x00, 0x05, 0xc0, 0xe9,
-    0x02, 0x26, 0x45, 0x06, 0x16, 0xe0, 0x02, 0x26,
-    0x07, 0x00, 0xe5, 0x01, 0x00, 0x45, 0x00, 0xe5,
-    0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x85, 0x20,
-    0x06, 0x05, 0x47, 0x86, 0x00, 0x26, 0x07, 0x00,
-    0x27, 0x06, 0x20, 0x05, 0xe0, 0x07, 0x25, 0x26,
-    0x20, 0xe9, 0x02, 0x16, 0x0d, 0xc0, 0x05, 0xa6,
-    0x00, 0x06, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25,
-    0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00,
-    0x85, 0x20, 0x06, 0x05, 0x07, 0x06, 0x07, 0x66,
-    0x20, 0x27, 0x20, 0x27, 0x06, 0xc0, 0x26, 0x07,
+    0x03, 0x16, 0x1b, 0x56, 0xe5, 0x18, 0x04, 0xe5,
+    0x02, 0xe6, 0x0d, 0xe9, 0x02, 0x76, 0x25, 0x06,
+    0xe5, 0x5b, 0x16, 0x05, 0xc6, 0x1b, 0x0f, 0xa6,
+    0x24, 0x26, 0x0f, 0x66, 0x25, 0xe9, 0x02, 0x45,
+    0x2f, 0x05, 0xf6, 0x06, 0x00, 0x1b, 0x05, 0x06,
+    0xe5, 0x16, 0xe6, 0x13, 0x20, 0xe5, 0x51, 0xe6,
+    0x03, 0x05, 0xe0, 0x06, 0xe9, 0x02, 0xe5, 0x19,
+    0xe6, 0x01, 0x24, 0x0f, 0x56, 0x04, 0x20, 0x06,
+    0x2d, 0xe5, 0x0e, 0x66, 0x04, 0xe6, 0x01, 0x04,
+    0x46, 0x04, 0x86, 0x20, 0xf6, 0x07, 0x00, 0xe5,
+    0x11, 0x46, 0x20, 0x16, 0x00, 0xe5, 0x03, 0x80,
+    0xe5, 0x10, 0x0e, 0xa5, 0x00, 0x3b, 0xa0, 0xe6,
+    0x00, 0xe5, 0x21, 0x04, 0xe6, 0x10, 0x1b, 0xe6,
+    0x18, 0x07, 0xe5, 0x2e, 0x06, 0x07, 0x06, 0x05,
+    0x47, 0xe6, 0x00, 0x67, 0x06, 0x27, 0x05, 0xc6,
+    0xe5, 0x02, 0x26, 0x36, 0xe9, 0x02, 0x16, 0x04,
+    0xe5, 0x07, 0x06, 0x27, 0x00, 0xe5, 0x00, 0x20,
+    0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x05,
+    0x40, 0x65, 0x20, 0x06, 0x05, 0x47, 0x66, 0x20,
+    0x27, 0x20, 0x27, 0x06, 0x05, 0xe0, 0x00, 0x07,
     0x60, 0x25, 0x00, 0x45, 0x26, 0x20, 0xe9, 0x02,
-    0x0f, 0x05, 0xab, 0xe0, 0x02, 0x06, 0x05, 0x00,
-    0xa5, 0x40, 0x45, 0x00, 0x65, 0x40, 0x25, 0x00,
-    0x05, 0x00, 0x25, 0x40, 0x25, 0x40, 0x45, 0x40,
-    0xe5, 0x04, 0x60, 0x27, 0x06, 0x27, 0x40, 0x47,
-    0x00, 0x47, 0x06, 0x20, 0x05, 0xa0, 0x07, 0xe0,
-    0x06, 0xe9, 0x02, 0x4b, 0xaf, 0x0d, 0x0f, 0x80,
-    0x06, 0x47, 0x06, 0xe5, 0x00, 0x00, 0x45, 0x00,
-    0xe5, 0x0f, 0x00, 0xe5, 0x08, 0x40, 0x05, 0x46,
-    0x67, 0x00, 0x46, 0x00, 0x66, 0xc0, 0x26, 0x00,
-    0x45, 0x80, 0x25, 0x26, 0x20, 0xe9, 0x02, 0xc0,
-    0x16, 0xcb, 0x0f, 0x05, 0x06, 0x27, 0x16, 0xe5,
-    0x00, 0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5,
-    0x02, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07, 0x06,
-    0x87, 0x00, 0x06, 0x27, 0x00, 0x27, 0x26, 0xc0,
-    0x27, 0xc0, 0x05, 0x00, 0x25, 0x26, 0x20, 0xe9,
-    0x02, 0x00, 0x25, 0xe0, 0x05, 0x26, 0x27, 0xe5,
-    0x01, 0x00, 0x45, 0x00, 0xe5, 0x21, 0x26, 0x05,
-    0x47, 0x66, 0x00, 0x47, 0x00, 0x47, 0x06, 0x05,
-    0x0f, 0x60, 0x45, 0x07, 0xcb, 0x45, 0x26, 0x20,
-    0xe9, 0x02, 0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06,
-    0x27, 0x00, 0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00,
-    0xe5, 0x01, 0x00, 0x05, 0x20, 0xc5, 0x40, 0x06,
-    0x60, 0x47, 0x46, 0x00, 0x06, 0x00, 0xe7, 0x00,
-    0xa0, 0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0, 0x04,
-    0xe5, 0x28, 0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5,
-    0x04, 0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0,
-    0x1d, 0x25, 0x00, 0x05, 0x00, 0x85, 0x00, 0xe5,
-    0x10, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x06, 0x25,
-    0xe6, 0x01, 0x05, 0x20, 0x85, 0x00, 0x04, 0x00,
-    0xa6, 0x20, 0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18,
-    0x05, 0x4f, 0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26,
-    0xaf, 0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f,
-    0x06, 0x0f, 0x06, 0x12, 0x13, 0x12, 0x13, 0x27,
-    0xe5, 0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06,
-    0x07, 0x86, 0x16, 0x26, 0x85, 0xe6, 0x03, 0x00,
-    0xe6, 0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf, 0x00,
-    0x2f, 0x96, 0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23,
-    0x27, 0x66, 0x07, 0xa6, 0x07, 0x26, 0x27, 0x26,
-    0x05, 0xe9, 0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65,
-    0x46, 0x05, 0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5,
-    0x05, 0x06, 0x27, 0x26, 0xa7, 0x06, 0x05, 0x07,
-    0xe9, 0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00,
-    0x01, 0x80, 0x01, 0x20, 0xe2, 0x23, 0x16, 0x04,
-    0x42, 0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5,
-    0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x21, 0x00,
-    0x65, 0x20, 0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5,
-    0x00, 0x05, 0x00, 0x65, 0x20, 0xe5, 0x07, 0x00,
-    0xe5, 0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20,
-    0x46, 0xf6, 0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08,
-    0xef, 0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20,
-    0x11, 0xe5, 0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09,
-    0x17, 0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5, 0x43,
-    0x56, 0x4a, 0xe5, 0x00, 0xc0, 0xe5, 0x05, 0x00,
-    0x65, 0x46, 0xe0, 0x03, 0xe5, 0x0a, 0x46, 0x36,
-    0xe0, 0x01, 0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5,
-    0x05, 0x00, 0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5,
-    0x2c, 0x26, 0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27,
-    0xe6, 0x03, 0x56, 0x04, 0x56, 0x0d, 0x05, 0x06,
-    0x20, 0xe9, 0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6,
-    0x11, 0x76, 0x46, 0x1b, 0x00, 0xe9, 0x02, 0xa0,
-    0xe5, 0x1b, 0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26,
-    0xe5, 0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0,
-    0x02, 0xe5, 0x17, 0x00, 0x46, 0x67, 0x26, 0x47,
-    0x60, 0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40,
-    0x36, 0xe9, 0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0,
-    0x03, 0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9,
-    0x02, 0x0b, 0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26,
-    0x27, 0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06,
-    0x07, 0xc6, 0x00, 0x06, 0x07, 0x06, 0x27, 0xe6,
-    0x00, 0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02,
-    0xa0, 0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20,
-    0xe6, 0x06, 0x08, 0x26, 0xe0, 0x37, 0x66, 0x07,
-    0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87,
-    0x06, 0x27, 0xc5, 0x60, 0xe9, 0x02, 0xd6, 0xef,
-    0x02, 0xe6, 0x01, 0xef, 0x01, 0x40, 0x26, 0x07,
-    0xe5, 0x16, 0x07, 0x66, 0x27, 0x26, 0x07, 0x46,
-    0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06, 0x07, 0x26,
-    0x47, 0x06, 0x07, 0x46, 0x27, 0xe0, 0x00, 0x76,
-    0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00, 0x27, 0x26,
-    0x40, 0x96, 0xe9, 0x02, 0x40, 0x45, 0xe9, 0x02,
-    0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01, 0xc0, 0xe1,
-    0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0, 0x00, 0x46,
-    0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65, 0x06, 0xa5,
-    0x06, 0x25, 0x07, 0x26, 0x05, 0x80, 0xe2, 0x24,
-    0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2, 0x1a, 0xe4,
-    0x1d, 0xe6, 0x32, 0x00, 0x86, 0xff, 0x80, 0x0e,
-    0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00,
-    0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00,
-    0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20,
-    0xe2, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
-    0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20,
-    0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00,
-    0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61,
-    0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61,
-    0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e,
-    0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22,
-    0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1,
-    0x36, 0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14,
-    0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01,
-    0x14, 0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13,
-    0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17,
-    0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab,
-    0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12,
-    0x13, 0x00, 0xe4, 0x05, 0x40, 0xed, 0x18, 0xe0,
-    0x08, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04,
-    0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02,
-    0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c,
-    0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f,
-    0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f,
-    0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f,
-    0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a,
-    0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c,
-    0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17,
-    0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec,
-    0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13,
-    0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49,
-    0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac,
-    0xef, 0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d,
-    0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80,
-    0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec,
-    0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef,
-    0x24, 0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13,
+    0x25, 0x2d, 0xab, 0x0f, 0x0d, 0x05, 0x16, 0x06,
+    0x20, 0x26, 0x07, 0x00, 0xa5, 0x60, 0x25, 0x20,
+    0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x25,
+    0x00, 0x25, 0x20, 0x06, 0x00, 0x47, 0x26, 0x60,
+    0x26, 0x20, 0x46, 0x40, 0x06, 0xc0, 0x65, 0x00,
+    0x05, 0xc0, 0xe9, 0x02, 0x26, 0x45, 0x06, 0x16,
+    0xe0, 0x02, 0x26, 0x07, 0x00, 0xe5, 0x01, 0x00,
+    0x45, 0x00, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25,
+    0x00, 0x85, 0x20, 0x06, 0x05, 0x47, 0x86, 0x00,
+    0x26, 0x07, 0x00, 0x27, 0x06, 0x20, 0x05, 0xe0,
+    0x07, 0x25, 0x26, 0x20, 0xe9, 0x02, 0x16, 0x0d,
+    0xc0, 0x05, 0xa6, 0x00, 0x06, 0x27, 0x00, 0xe5,
+    0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5,
+    0x00, 0x25, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07,
+    0x06, 0x07, 0x66, 0x20, 0x27, 0x20, 0x27, 0x06,
+    0xc0, 0x26, 0x07, 0x60, 0x25, 0x00, 0x45, 0x26,
+    0x20, 0xe9, 0x02, 0x0f, 0x05, 0xab, 0xe0, 0x02,
+    0x06, 0x05, 0x00, 0xa5, 0x40, 0x45, 0x00, 0x65,
+    0x40, 0x25, 0x00, 0x05, 0x00, 0x25, 0x40, 0x25,
+    0x40, 0x45, 0x40, 0xe5, 0x04, 0x60, 0x27, 0x06,
+    0x27, 0x40, 0x47, 0x00, 0x47, 0x06, 0x20, 0x05,
+    0xa0, 0x07, 0xe0, 0x06, 0xe9, 0x02, 0x4b, 0xaf,
+    0x0d, 0x0f, 0x80, 0x06, 0x47, 0x06, 0xe5, 0x00,
+    0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x08,
+    0x20, 0x06, 0x05, 0x46, 0x67, 0x00, 0x46, 0x00,
+    0x66, 0xc0, 0x26, 0x00, 0x45, 0x20, 0x05, 0x20,
+    0x25, 0x26, 0x20, 0xe9, 0x02, 0xc0, 0x16, 0xcb,
+    0x0f, 0x05, 0x06, 0x27, 0x16, 0xe5, 0x00, 0x00,
+    0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x02, 0x00,
+    0x85, 0x20, 0x06, 0x05, 0x07, 0x06, 0x87, 0x00,
+    0x06, 0x27, 0x00, 0x27, 0x26, 0xc0, 0x27, 0xa0,
+    0x25, 0x00, 0x25, 0x26, 0x20, 0xe9, 0x02, 0x00,
+    0x25, 0xe0, 0x05, 0x26, 0x27, 0xe5, 0x01, 0x00,
+    0x45, 0x00, 0xe5, 0x21, 0x26, 0x05, 0x47, 0x66,
+    0x00, 0x47, 0x00, 0x47, 0x06, 0x05, 0x0f, 0x60,
+    0x45, 0x07, 0xcb, 0x45, 0x26, 0x20, 0xe9, 0x02,
+    0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06, 0x27, 0x00,
+    0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00, 0xe5, 0x01,
+    0x00, 0x05, 0x20, 0xc5, 0x40, 0x06, 0x60, 0x47,
+    0x46, 0x00, 0x06, 0x00, 0xe7, 0x00, 0xa0, 0xe9,
+    0x02, 0x20, 0x27, 0x16, 0xe0, 0x04, 0xe5, 0x28,
+    0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5, 0x04, 0xe6,
+    0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0, 0x1d, 0x25,
+    0x00, 0x05, 0x00, 0x85, 0x00, 0xe5, 0x10, 0x00,
+    0x05, 0x00, 0xe5, 0x02, 0x06, 0x25, 0xe6, 0x01,
+    0x05, 0x20, 0x85, 0x00, 0x04, 0x00, 0xa6, 0x20,
+    0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18, 0x05, 0x4f,
+    0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26, 0xaf, 0xe9,
+    0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f, 0x06, 0x0f,
+    0x06, 0x12, 0x13, 0x12, 0x13, 0x27, 0xe5, 0x00,
+    0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06, 0x07, 0x86,
+    0x16, 0x26, 0x85, 0xe6, 0x03, 0x00, 0xe6, 0x1c,
+    0x00, 0xef, 0x00, 0x06, 0xaf, 0x00, 0x2f, 0x96,
+    0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23, 0x27, 0x66,
+    0x07, 0xa6, 0x07, 0x26, 0x27, 0x26, 0x05, 0xe9,
+    0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65, 0x46, 0x05,
+    0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5, 0x05, 0x06,
+    0x27, 0x26, 0xa7, 0x06, 0x05, 0x07, 0xe9, 0x02,
+    0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00, 0x01, 0x80,
+    0x01, 0x20, 0xe2, 0x23, 0x16, 0x04, 0x42, 0xe5,
+    0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
+    0x00, 0x65, 0x20, 0xe5, 0x21, 0x00, 0x65, 0x20,
+    0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
+    0x00, 0x65, 0x20, 0xe5, 0x07, 0x00, 0xe5, 0x31,
+    0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20, 0x46, 0xf6,
+    0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08, 0xef, 0x02,
+    0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20, 0x11, 0xe5,
+    0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09, 0x17, 0xe5,
+    0x12, 0x12, 0x13, 0x40, 0xe5, 0x43, 0x56, 0x4a,
+    0xe5, 0x00, 0xc0, 0xe5, 0x0a, 0x46, 0x07, 0xe0,
+    0x01, 0xe5, 0x0b, 0x26, 0x07, 0x36, 0xe0, 0x01,
+    0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5, 0x05, 0x00,
+    0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5, 0x2c, 0x26,
+    0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27, 0xe6, 0x03,
+    0x56, 0x04, 0x56, 0x0d, 0x05, 0x06, 0x20, 0xe9,
+    0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6, 0x11, 0x76,
+    0x46, 0x1b, 0x06, 0xe9, 0x02, 0xa0, 0xe5, 0x1b,
+    0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26, 0xe5, 0x1a,
+    0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0, 0x02, 0xe5,
+    0x17, 0x00, 0x46, 0x67, 0x26, 0x47, 0x60, 0x27,
+    0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40, 0x36, 0xe9,
+    0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0, 0x03, 0xe5,
+    0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9, 0x02, 0x0b,
+    0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26, 0x27, 0x06,
+    0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06, 0x07, 0xc6,
+    0x00, 0x06, 0x07, 0x06, 0x27, 0xe6, 0x00, 0xa7,
+    0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02, 0xa0, 0xe9,
+    0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20, 0xe6, 0x06,
+    0x08, 0xe6, 0x08, 0xe0, 0x29, 0x66, 0x07, 0xe5,
+    0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87, 0x06,
+    0x27, 0xe5, 0x00, 0x40, 0xe9, 0x02, 0xd6, 0xef,
+    0x02, 0xe6, 0x01, 0xef, 0x01, 0x36, 0x00, 0x26,
+    0x07, 0xe5, 0x16, 0x07, 0x66, 0x27, 0x26, 0x07,
+    0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06, 0x07,
+    0x26, 0x47, 0x06, 0x07, 0x46, 0x27, 0xe0, 0x00,
+    0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00, 0x27,
+    0x26, 0x40, 0x96, 0xe9, 0x02, 0x40, 0x45, 0xe9,
+    0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01, 0xc0,
+    0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0, 0x00,
+    0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65, 0x06,
+    0xa5, 0x06, 0x25, 0x07, 0x26, 0x05, 0x80, 0xe2,
+    0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2, 0x1a,
+    0xe4, 0x1d, 0xe6, 0x38, 0xff, 0x80, 0x0e, 0xe2,
+    0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00, 0xa2,
+    0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00, 0xe2,
+    0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2,
+    0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20, 0xe2,
+    0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0xe2,
+    0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61, 0x03,
+    0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61, 0x03,
+    0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e, 0xe2,
+    0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22, 0x61,
+    0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1, 0x36,
+    0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14, 0xf6,
+    0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01, 0x14,
+    0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13, 0xf6,
+    0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17, 0x9b,
+    0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab, 0x4c,
+    0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12, 0x13,
+    0x00, 0xe4, 0x05, 0x40, 0xed, 0x19, 0xe0, 0x07,
+    0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04, 0xe0,
+    0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02, 0x41,
+    0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c, 0x81,
+    0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f, 0x61,
+    0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f, 0x22,
+    0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f, 0x02,
+    0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a, 0x0b,
+    0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c, 0x2f,
+    0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17, 0x2c,
+    0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec, 0x80,
+    0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13, 0xef,
+    0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49, 0x0c,
+    0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac, 0xef,
+    0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d, 0xeb,
+    0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80, 0x2f,
+    0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec, 0x00,
+    0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef, 0x24,
+    0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec,
+    0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0xec, 0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12,
-    0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec,
-    0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac,
-    0xef, 0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61,
-    0xe1, 0x27, 0x00, 0xe2, 0x27, 0x00, 0x5f, 0x21,
-    0x22, 0xdf, 0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82,
-    0x24, 0x41, 0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f,
-    0x46, 0x3f, 0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e,
-    0x00, 0x02, 0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0,
-    0x04, 0x16, 0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0,
-    0x01, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
-    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
-    0x00, 0xe6, 0x18, 0x36, 0x14, 0x15, 0x14, 0x15,
-    0x56, 0x14, 0x15, 0x16, 0x14, 0x15, 0xf6, 0x01,
-    0x11, 0x36, 0x11, 0x16, 0x14, 0x15, 0x36, 0x14,
-    0x15, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x96, 0x04, 0xf6, 0x02, 0x31, 0x76, 0x11,
-    0x16, 0x12, 0xf6, 0x05, 0x2f, 0x16, 0xe0, 0x25,
-    0xef, 0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef,
-    0x80, 0x4e, 0xe0, 0x12, 0xef, 0x04, 0x60, 0x17,
-    0x56, 0x0f, 0x04, 0x05, 0x0a, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x2f,
+    0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12, 0x13,
+    0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec, 0x80,
+    0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac, 0xef,
+    0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61, 0xe1,
+    0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22, 0xdf, 0x41,
+    0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24, 0x41, 0x02,
+    0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f, 0x80,
+    0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00, 0x02, 0x80,
+    0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16, 0xe0,
+    0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01, 0xc5, 0x00,
+    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00,
+    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xe6, 0x18,
+    0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14, 0x15,
+    0x16, 0x14, 0x15, 0xf6, 0x01, 0x11, 0x36, 0x11,
+    0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x96, 0x04,
+    0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12, 0xf6,
+    0x05, 0x2f, 0x56, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a, 0xef, 0x12,
+    0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80, 0x4e,
+    0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56, 0x0f,
+    0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0x12,
+    0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11, 0x84,
+    0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00, 0xe5,
+    0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5,
+    0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23, 0x00,
+    0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5,
+    0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08, 0xef,
+    0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb, 0x00,
+    0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02, 0xef,
+    0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5, 0x99,
+    0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11, 0x8d, 0x04,
+    0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01,
+    0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84, 0x04,
+    0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c,
+    0xff, 0x26, 0x05, 0x06, 0x48, 0x16, 0xe6, 0x02,
+    0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e,
+    0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee, 0x0f,
+    0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36,
+    0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04, 0x2e,
+    0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02,
+    0x81, 0x02, 0xff, 0x07, 0x41, 0x02, 0x3f, 0x80,
+    0x3f, 0x00, 0x02, 0x00, 0x02, 0x7f, 0xe0, 0x10,
+    0x44, 0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06, 0x45,
+    0x06, 0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07,
+    0x6f, 0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f, 0xa0,
+    0xe5, 0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5, 0x2a,
+    0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9, 0x02,
+    0xa0, 0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16, 0x25,
+    0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00, 0x36,
+    0xe5, 0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03, 0x16,
+    0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5, 0x27, 0x06,
+    0x27, 0x66, 0x27, 0x26, 0x47, 0xf6, 0x05, 0x00,
+    0x04, 0xe9, 0x02, 0x60, 0x36, 0x85, 0x06, 0x04,
+    0xe5, 0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5, 0x21,
+    0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0, 0x01, 0x45,
+    0x06, 0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9, 0x02,
+    0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f, 0x05,
+    0x07, 0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05, 0x46,
+    0x25, 0x26, 0x85, 0x26, 0x05, 0x06, 0x05, 0xe0,
+    0x10, 0x25, 0x04, 0x36, 0xe5, 0x03, 0x07, 0x26,
+    0x27, 0x36, 0x05, 0x24, 0x07, 0x06, 0xe0, 0x02,
+    0xa5, 0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01, 0xc5,
+    0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64, 0xe2,
+    0x01, 0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5, 0x1b,
+    0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06,
+    0x20, 0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c, 0xe0,
+    0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc,
+    0x87, 0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80, 0xe6,
+    0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04,
+    0x82, 0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c, 0xe5,
+    0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00,
+    0x25, 0x00, 0xe5, 0x64, 0xee, 0x09, 0xe0, 0x08,
+    0xe5, 0x80, 0xe3, 0x13, 0x12, 0xef, 0x08, 0xe5,
+    0x38, 0x20, 0xe5, 0x2e, 0xc0, 0x0f, 0xe0, 0x18,
+    0xe5, 0x04, 0x0d, 0x4f, 0xe6, 0x08, 0xd6, 0x12,
+    0x13, 0x16, 0xa0, 0xe6, 0x08, 0x16, 0x31, 0x30,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x11, 0x12, 0x33, 0x0f, 0xea, 0x01, 0x66, 0x27,
-    0x11, 0x84, 0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f,
-    0x00, 0xe5, 0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05,
-    0x11, 0xe5, 0x52, 0x16, 0x44, 0x05, 0x80, 0xe5,
-    0x23, 0x00, 0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef,
-    0x02, 0xe5, 0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5,
-    0x08, 0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16,
-    0xeb, 0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb,
-    0x02, 0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8,
-    0xe5, 0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11,
-    0x75, 0x40, 0xe5, 0x0d, 0x04, 0xe5, 0x83, 0xef,
-    0x40, 0xef, 0x2f, 0xe0, 0x01, 0xe5, 0x20, 0xa4,
-    0x36, 0xe5, 0x80, 0x84, 0x04, 0x56, 0xe5, 0x08,
-    0xe9, 0x02, 0x25, 0xe0, 0x0c, 0xff, 0x26, 0x05,
-    0x06, 0x48, 0x16, 0xe6, 0x02, 0x16, 0x04, 0xff,
-    0x14, 0x24, 0x26, 0xe5, 0x3e, 0xea, 0x02, 0x26,
-    0xb6, 0xe0, 0x00, 0xee, 0x0f, 0xe4, 0x01, 0x2e,
-    0xff, 0x06, 0x22, 0xff, 0x36, 0x04, 0xe2, 0x00,
-    0x9f, 0xff, 0x02, 0x04, 0x2e, 0x7f, 0x05, 0x7f,
-    0x22, 0xff, 0x0d, 0x61, 0x02, 0x81, 0x02, 0xff,
-    0x02, 0x20, 0x5f, 0x41, 0x02, 0x3f, 0xe0, 0x22,
-    0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06, 0x45, 0x06,
-    0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07, 0x6f,
-    0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f, 0xa0, 0xe5,
-    0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5, 0x2a, 0xe7,
-    0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9, 0x02, 0xa0,
-    0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16, 0x25, 0x06,
-    0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00, 0x36, 0xe5,
-    0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03, 0x16, 0xe5,
-    0x15, 0x40, 0x46, 0x07, 0xe5, 0x27, 0x06, 0x27,
-    0x66, 0x27, 0x26, 0x47, 0xf6, 0x05, 0x00, 0x04,
-    0xe9, 0x02, 0x60, 0x36, 0x85, 0x06, 0x04, 0xe5,
-    0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5, 0x21, 0xa6,
-    0x27, 0x26, 0x27, 0x26, 0xe0, 0x01, 0x45, 0x06,
-    0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9, 0x02, 0x20,
-    0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f, 0x05, 0x07,
-    0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05, 0x46, 0x25,
-    0x26, 0x85, 0x26, 0x05, 0x06, 0x05, 0xe0, 0x10,
-    0x25, 0x04, 0x36, 0xe5, 0x03, 0x07, 0x26, 0x27,
-    0x36, 0x05, 0x24, 0x07, 0x06, 0xe0, 0x02, 0xa5,
-    0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01, 0xc5, 0x00,
-    0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64, 0xe2, 0x01,
-    0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5, 0x1b, 0x27,
-    0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06, 0x20,
-    0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c, 0xe0, 0x04,
-    0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc, 0x87,
-    0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80, 0xe6, 0x20,
-    0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04, 0x82,
-    0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c, 0xe5, 0x05,
-    0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00, 0x25,
-    0x00, 0xe5, 0x64, 0xee, 0x08, 0xe0, 0x09, 0xe5,
-    0x80, 0xe3, 0x13, 0x12, 0xe0, 0x08, 0xe5, 0x38,
-    0x20, 0xe5, 0x2e, 0xe0, 0x20, 0xe5, 0x04, 0x0d,
-    0x0f, 0x20, 0xe6, 0x08, 0xd6, 0x12, 0x13, 0x16,
-    0xa0, 0xe6, 0x08, 0x16, 0x31, 0x30, 0x12, 0x13,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x36, 0x12,
-    0x13, 0x76, 0x50, 0x56, 0x00, 0x76, 0x11, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x56, 0x0c, 0x11,
-    0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60, 0x85, 0x00,
-    0xe5, 0x7f, 0x20, 0x1b, 0x00, 0x56, 0x0d, 0x56,
-    0x12, 0x13, 0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9,
-    0x02, 0x36, 0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16,
-    0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12, 0x12, 0x0c,
-    0x13, 0x0c, 0x12, 0x13, 0x16, 0x12, 0x13, 0x36,
-    0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24, 0xe5, 0x17,
-    0x40, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0x20, 0x45,
-    0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d, 0x00, 0x0f,
-    0x6c, 0x2f, 0xe0, 0x02, 0x5b, 0x2f, 0x20, 0xe5,
-    0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5, 0x0b, 0x00,
-    0x25, 0x00, 0xe5, 0x07, 0x20, 0xe5, 0x06, 0xe0,
-    0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60, 0xeb, 0x25,
-    0x40, 0xef, 0x01, 0xea, 0x2d, 0x6b, 0xef, 0x09,
-    0x2b, 0x4f, 0x00, 0xef, 0x05, 0x40, 0x0f, 0xe0,
-    0x27, 0xef, 0x25, 0x06, 0xe0, 0x7a, 0xe5, 0x15,
-    0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06, 0xeb, 0x13,
-    0x60, 0xe5, 0x18, 0x6b, 0xe0, 0x01, 0xe5, 0x0c,
-    0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5, 0x1e, 0x86,
-    0x80, 0xe5, 0x16, 0x00, 0x16, 0xe5, 0x1c, 0x60,
-    0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22, 0xe1, 0x20,
-    0xe2, 0x20, 0xe5, 0x46, 0x20, 0xe9, 0x02, 0xa0,
-    0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60, 0xe5, 0x20,
-    0xe0, 0x00, 0xe5, 0x2c, 0xe0, 0x03, 0x16, 0xe0,
-    0x80, 0x08, 0xe5, 0x80, 0xaf, 0xe0, 0x01, 0xe5,
-    0x0e, 0xe0, 0x02, 0xe5, 0x00, 0xe0, 0x80, 0x10,
-    0xa5, 0x20, 0x05, 0x00, 0xe5, 0x24, 0x00, 0x25,
-    0x40, 0x05, 0x20, 0xe5, 0x0f, 0x00, 0x16, 0xeb,
-    0x00, 0xe5, 0x0f, 0x2f, 0xcb, 0xe5, 0x17, 0xe0,
-    0x00, 0xeb, 0x01, 0xe0, 0x28, 0xe5, 0x0b, 0x00,
-    0x25, 0x80, 0x8b, 0xe5, 0x0e, 0xab, 0x40, 0x16,
-    0xe5, 0x12, 0x80, 0x16, 0xe0, 0x38, 0xe5, 0x30,
-    0x60, 0x2b, 0x25, 0xeb, 0x08, 0x20, 0xeb, 0x26,
-    0x05, 0x46, 0x00, 0x26, 0x80, 0x66, 0x65, 0x00,
-    0x45, 0x00, 0xe5, 0x15, 0x20, 0x46, 0x60, 0x06,
-    0xeb, 0x01, 0xc0, 0xf6, 0x01, 0xc0, 0xe5, 0x15,
-    0x2b, 0x16, 0xe5, 0x15, 0x4b, 0xe0, 0x18, 0xe5,
-    0x00, 0x0f, 0xe5, 0x14, 0x26, 0x60, 0x8b, 0xd6,
-    0xe0, 0x01, 0xe5, 0x2e, 0x40, 0xd6, 0xe5, 0x0e,
-    0x20, 0xeb, 0x00, 0xe5, 0x0b, 0x80, 0xeb, 0x00,
-    0xe5, 0x0a, 0xc0, 0x76, 0xe0, 0x04, 0xcb, 0xe0,
-    0x48, 0xe5, 0x41, 0xe0, 0x2f, 0xe1, 0x2b, 0xe0,
-    0x05, 0xe2, 0x2b, 0xc0, 0xab, 0xe5, 0x1c, 0x66,
-    0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x9e, 0xeb,
-    0x17, 0x00, 0xe5, 0x22, 0x00, 0x26, 0x11, 0x20,
-    0x25, 0xe0, 0x46, 0xe5, 0x15, 0xeb, 0x02, 0x05,
-    0xe0, 0x00, 0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96,
-    0xe0, 0x4e, 0xe5, 0x0d, 0xcb, 0xe0, 0x0c, 0xe5,
-    0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07, 0xe5, 0x2d,
-    0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c, 0xe9, 0x02,
-    0xe0, 0x07, 0x46, 0x07, 0xe5, 0x25, 0x47, 0x66,
-    0x27, 0x26, 0x36, 0x1b, 0x76, 0xe0, 0x03, 0x1b,
-    0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0, 0x46,
-    0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9,
-    0x02, 0x76, 0x05, 0x27, 0x05, 0xe0, 0x00, 0xe5,
-    0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07,
-    0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76,
-    0x66, 0x16, 0x07, 0x06, 0xe9, 0x02, 0x05, 0x16,
-    0x05, 0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5,
-    0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06,
-    0x07, 0x26, 0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00,
-    0x05, 0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5,
-    0x02, 0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6,
-    0x00, 0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00,
-    0xe5, 0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00,
-    0xc5, 0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05,
-    0x27, 0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20,
-    0x05, 0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6,
-    0x40, 0x86, 0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47,
-    0xe6, 0x00, 0x27, 0x46, 0x07, 0x06, 0x65, 0x96,
-    0xe9, 0x02, 0x36, 0x00, 0x16, 0x06, 0x45, 0xe0,
-    0x16, 0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67,
-    0x26, 0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00,
-    0xe9, 0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47,
-    0x66, 0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f,
-    0x65, 0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6,
-    0x00, 0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0,
-    0x03, 0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b,
-    0xe5, 0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07,
-    0x06, 0x05, 0xc0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5,
+    0x36, 0x12, 0x13, 0x76, 0x50, 0x56, 0x00, 0x76,
+    0x11, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x56,
+    0x0c, 0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60,
+    0x85, 0x00, 0xe5, 0x7f, 0x20, 0x1b, 0x00, 0x56,
+    0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16, 0x11,
+    0x36, 0xe9, 0x02, 0x36, 0x4c, 0x36, 0xe1, 0x12,
+    0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12,
+    0x12, 0x0c, 0x13, 0x0c, 0x12, 0x13, 0x16, 0x12,
+    0x13, 0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24,
+    0xe5, 0x17, 0x40, 0xa5, 0x20, 0xa5, 0x20, 0xa5,
+    0x20, 0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d,
+    0x00, 0x0f, 0x6c, 0x2f, 0xe0, 0x02, 0x5b, 0x2f,
+    0x20, 0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5,
+    0x0b, 0x00, 0x25, 0x00, 0xe5, 0x07, 0x20, 0xe5,
+    0x06, 0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60,
+    0xeb, 0x25, 0x40, 0xef, 0x01, 0xea, 0x2d, 0x6b,
+    0xef, 0x09, 0x2b, 0x4f, 0x00, 0xef, 0x05, 0x40,
+    0x0f, 0xe0, 0x27, 0xef, 0x25, 0x06, 0xe0, 0x7a,
+    0xe5, 0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06,
+    0xeb, 0x13, 0x60, 0xe5, 0x18, 0x6b, 0xe0, 0x01,
+    0xe5, 0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5,
+    0x1e, 0x86, 0x80, 0xe5, 0x16, 0x00, 0x16, 0xe5,
+    0x1c, 0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22,
+    0xe1, 0x20, 0xe2, 0x20, 0xe5, 0x46, 0x20, 0xe9,
+    0x02, 0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60,
+    0xe5, 0x20, 0xe0, 0x00, 0xe5, 0x2c, 0xe0, 0x03,
+    0x16, 0xe1, 0x03, 0x00, 0xe1, 0x07, 0x00, 0xc1,
+    0x00, 0x21, 0x00, 0xe2, 0x03, 0x00, 0xe2, 0x07,
+    0x00, 0xc2, 0x00, 0x22, 0xe0, 0x3b, 0xe5, 0x80,
+    0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02, 0xe5,
+    0x00, 0xe0, 0x10, 0xa4, 0x00, 0xe4, 0x22, 0x00,
+    0xe4, 0x01, 0xe0, 0x3d, 0xa5, 0x20, 0x05, 0x00,
+    0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20, 0xe5,
+    0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f, 0x2f,
+    0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01, 0xe0,
+    0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b, 0xe5,
+    0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80, 0x16,
+    0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25, 0xeb,
+    0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00, 0x26,
+    0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5, 0x15,
+    0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0, 0xf6,
+    0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5, 0x15,
+    0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5, 0x14,
+    0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5, 0x2e,
+    0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00, 0xe5,
+    0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0, 0x76,
+    0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41, 0xe0,
+    0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b, 0xc0,
+    0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9, 0x02,
+    0xe0, 0x80, 0x9e, 0xeb, 0x17, 0x00, 0xe5, 0x22,
+    0x00, 0x26, 0x11, 0x20, 0x25, 0xe0, 0x46, 0xe5,
+    0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00, 0xe5, 0x0e,
+    0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x0e, 0xe5, 0x0a,
+    0x66, 0x76, 0xe0, 0x1e, 0xe5, 0x0d, 0xcb, 0xe0,
+    0x0c, 0xe5, 0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07,
+    0xe5, 0x2d, 0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c,
+    0xe9, 0x02, 0x06, 0x25, 0x26, 0x05, 0xe0, 0x01,
+    0x46, 0x07, 0xe5, 0x25, 0x47, 0x66, 0x27, 0x26,
+    0x36, 0x1b, 0x76, 0x06, 0xe0, 0x02, 0x1b, 0x20,
+    0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0, 0x46, 0xe5,
+    0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9, 0x02,
+    0x76, 0x05, 0x27, 0x05, 0xe0, 0x00, 0xe5, 0x1b,
+    0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07, 0xe5,
+    0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76, 0x66,
+    0x16, 0x07, 0x06, 0xe9, 0x02, 0x05, 0x16, 0x05,
+    0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a,
+    0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07,
+    0x26, 0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00, 0x05,
+    0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02,
+    0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00,
+    0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5,
+    0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5,
+    0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27,
+    0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05,
+    0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40,
+    0x86, 0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47, 0xe6,
+    0x00, 0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9,
+    0x02, 0x36, 0x00, 0x16, 0x06, 0x45, 0xe0, 0x16,
+    0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67, 0x26,
+    0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9,
+    0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47, 0x66,
+    0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f, 0x65,
+    0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6, 0x00,
+    0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03,
+    0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b, 0xe5,
+    0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06,
+    0x05, 0x16, 0xa0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5,
     0x13, 0x20, 0x46, 0x27, 0x66, 0x07, 0x86, 0x60,
-    0xe9, 0x02, 0x2b, 0x56, 0x0f, 0xe0, 0x80, 0x38,
-    0xe5, 0x24, 0x47, 0xe6, 0x01, 0x07, 0x26, 0x16,
-    0xe0, 0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9, 0x02,
-    0xeb, 0x01, 0xe0, 0x04, 0xe5, 0x00, 0x20, 0x05,
-    0x20, 0xe5, 0x00, 0x00, 0x25, 0x00, 0xe5, 0x10,
-    0xa7, 0x00, 0x27, 0x20, 0x26, 0x07, 0x06, 0x05,
-    0x07, 0x05, 0x07, 0x06, 0x56, 0xe0, 0x01, 0xe9,
-    0x02, 0xe0, 0x3e, 0xe5, 0x00, 0x20, 0xe5, 0x1f,
-    0x47, 0x66, 0x20, 0x26, 0x67, 0x06, 0x05, 0x16,
-    0x05, 0x07, 0xe0, 0x13, 0x05, 0xe6, 0x02, 0xe5,
-    0x20, 0xa6, 0x07, 0x05, 0x66, 0xf6, 0x00, 0x06,
-    0xe0, 0x00, 0x05, 0xa6, 0x27, 0x46, 0xe5, 0x26,
-    0xe6, 0x05, 0x07, 0x26, 0x56, 0x05, 0x96, 0xe0,
-    0x15, 0xe5, 0x31, 0xe0, 0x80, 0x7f, 0xe5, 0x01,
-    0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6, 0x07,
-    0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02, 0xeb,
-    0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6, 0x0e,
-    0x00, 0x07, 0xc6, 0x07, 0x26, 0x07, 0x26, 0xe0,
-    0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e, 0xa6,
-    0x40, 0x06, 0x00, 0x26, 0x00, 0xc6, 0x05, 0x06,
-    0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00, 0x25,
-    0x00, 0xe5, 0x18, 0x87, 0x00, 0x26, 0x00, 0x27,
-    0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02, 0xe0,
-    0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36, 0xe0,
-    0x80, 0x2f, 0x05, 0xe0, 0x07, 0xeb, 0x0d, 0xef,
-    0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16, 0xe5,
-    0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00, 0x96,
-    0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x8a, 0x34,
-    0xe5, 0x83, 0xa7, 0x00, 0xfb, 0x01, 0xe0, 0x8f,
-    0x3f, 0xe5, 0x81, 0xbf, 0xe0, 0xa1, 0x31, 0xe5,
-    0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00, 0xe9, 0x02,
-    0x60, 0x36, 0xe0, 0x58, 0xe5, 0x16, 0x20, 0x86,
-    0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f,
-    0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00,
-    0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0,
-    0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb, 0x0f,
-    0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06, 0x05,
-    0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38,
-    0x24, 0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0xe0,
-    0x06, 0xe5, 0x97, 0x70, 0xe0, 0x00, 0xe5, 0x84,
-    0x4e, 0xe0, 0x22, 0xe5, 0x01, 0xe0, 0xa2, 0x6f,
-    0xe5, 0x80, 0x97, 0xe0, 0x29, 0x45, 0xe0, 0x09,
+    0xe9, 0x02, 0x2b, 0x56, 0x0f, 0xc5, 0xe0, 0x80,
+    0x31, 0xe5, 0x24, 0x47, 0xe6, 0x01, 0x07, 0x26,
+    0x16, 0xe0, 0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9,
+    0x02, 0xeb, 0x01, 0xe0, 0x04, 0xe5, 0x00, 0x20,
+    0x05, 0x20, 0xe5, 0x00, 0x00, 0x25, 0x00, 0xe5,
+    0x10, 0xa7, 0x00, 0x27, 0x20, 0x26, 0x07, 0x06,
+    0x05, 0x07, 0x05, 0x07, 0x06, 0x56, 0xe0, 0x01,
+    0xe9, 0x02, 0xe0, 0x3e, 0xe5, 0x00, 0x20, 0xe5,
+    0x1f, 0x47, 0x66, 0x20, 0x26, 0x67, 0x06, 0x05,
+    0x16, 0x05, 0x07, 0xe0, 0x13, 0x05, 0xe6, 0x02,
+    0xe5, 0x20, 0xa6, 0x07, 0x05, 0x66, 0xf6, 0x00,
+    0x06, 0xe0, 0x00, 0x05, 0xa6, 0x27, 0x46, 0xe5,
+    0x26, 0xe6, 0x05, 0x07, 0x26, 0x56, 0x05, 0x96,
+    0xe0, 0x05, 0xe5, 0x41, 0xe0, 0x80, 0x7f, 0xe5,
+    0x01, 0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6,
+    0x07, 0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02,
+    0xeb, 0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6,
+    0x0e, 0x00, 0x07, 0xc6, 0x07, 0x26, 0x07, 0x26,
+    0xe0, 0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e,
+    0xa6, 0x40, 0x06, 0x00, 0x26, 0x00, 0xc6, 0x05,
+    0x06, 0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00,
+    0x25, 0x00, 0xe5, 0x18, 0x87, 0x00, 0x26, 0x00,
+    0x27, 0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02,
+    0xe0, 0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36,
+    0xe0, 0x80, 0x2f, 0x05, 0xe0, 0x07, 0xeb, 0x0d,
+    0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16,
+    0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00,
+    0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x89,
+    0xc4, 0xe5, 0x59, 0x36, 0xe0, 0x05, 0xe5, 0x83,
+    0xa7, 0x00, 0xfb, 0x01, 0xe0, 0x8f, 0x3f, 0xe5,
+    0x81, 0xbf, 0xe0, 0xa1, 0x31, 0xe5, 0x81, 0xb1,
+    0xc0, 0xe5, 0x17, 0x00, 0xe9, 0x02, 0x60, 0x36,
+    0xe5, 0x47, 0x00, 0xe9, 0x02, 0xa0, 0xe5, 0x16,
+    0x20, 0x86, 0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6,
+    0x96, 0x6f, 0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9,
+    0x02, 0x00, 0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5,
+    0x0b, 0xe0, 0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18,
+    0xeb, 0x0f, 0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60,
+    0x06, 0x05, 0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05,
+    0xe0, 0x38, 0x24, 0x16, 0x04, 0x06, 0xe0, 0x03,
+    0x27, 0xe0, 0x06, 0xe5, 0x97, 0x70, 0xe0, 0x00,
+    0xe5, 0x84, 0x4e, 0xe0, 0x22, 0xe5, 0x01, 0xe0,
+    0xa2, 0x5f, 0x64, 0x00, 0xc4, 0x00, 0x24, 0x00,
+    0xe5, 0x80, 0x9b, 0xe0, 0x25, 0x45, 0xe0, 0x09,
     0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0, 0x88,
     0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05, 0x40, 0xe5,
     0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26, 0x16,
-    0x7b, 0xe0, 0x92, 0xd4, 0xef, 0x80, 0x6e, 0xe0,
-    0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27, 0x46,
-    0x4f, 0xa7, 0xfb, 0x00, 0xe6, 0x00, 0x2f, 0xc6,
-    0xef, 0x16, 0x66, 0xef, 0x33, 0xe0, 0x0f, 0xef,
-    0x3a, 0x46, 0x0f, 0xe0, 0x80, 0x12, 0xeb, 0x0c,
-    0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11,
-    0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
-    0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12,
-    0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21, 0x20,
-    0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02, 0x00,
-    0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12,
-    0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1,
-    0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00, 0x81,
-    0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1,
-    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
-    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
-    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20,
+    0x7b, 0xe0, 0x91, 0xd4, 0xe6, 0x26, 0x20, 0xe6,
+    0x0f, 0xe0, 0x01, 0xef, 0x6c, 0xe0, 0x34, 0xef,
+    0x80, 0x6e, 0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef,
+    0x34, 0x27, 0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6,
+    0x00, 0x2f, 0xc6, 0xef, 0x16, 0x66, 0xef, 0x35,
+    0xe0, 0x0d, 0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x80,
+    0x12, 0xeb, 0x0c, 0xe0, 0x04, 0xef, 0x4f, 0xe0,
+    0x01, 0xeb, 0x11, 0xe0, 0x7f, 0xe1, 0x12, 0xe2,
+    0x12, 0xe1, 0x12, 0xc2, 0x00, 0xe2, 0x0a, 0xe1,
+    0x12, 0xe2, 0x12, 0x01, 0x00, 0x21, 0x20, 0x01,
+    0x20, 0x21, 0x20, 0x61, 0x00, 0xe1, 0x00, 0x62,
+    0x00, 0x02, 0x00, 0xc2, 0x00, 0xe2, 0x03, 0xe1,
+    0x12, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x20, 0xe1,
+    0x00, 0x00, 0xc1, 0x00, 0xe2, 0x12, 0x21, 0x00,
+    0x61, 0x00, 0x81, 0x00, 0x01, 0x40, 0xc1, 0x00,
+    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
+    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
+    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
+    0xe2, 0x14, 0x20, 0xe1, 0x11, 0x0c, 0xe2, 0x11,
+    0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c,
+    0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2,
     0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1,
-    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11,
-    0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
-    0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2,
-    0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef,
-    0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef,
-    0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0,
-    0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x84, 0xc8,
-    0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6, 0x00, 0x26,
-    0x00, 0x86, 0xe0, 0x80, 0x4d, 0xe5, 0x25, 0x40,
-    0xc6, 0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05, 0x0f,
-    0xe0, 0x80, 0xe8, 0xe5, 0x24, 0x66, 0xe9, 0x02,
-    0x80, 0x0d, 0xe0, 0x84, 0x78, 0xe5, 0x80, 0x3d,
-    0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a,
-    0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02, 0x60,
-    0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f, 0x4b,
-    0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f, 0xeb,
-    0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5, 0x13,
-    0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0xe5,
-    0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05, 0xa0,
-    0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00,
-    0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5, 0x00,
-    0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5, 0x02,
-    0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85, 0x00,
-    0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80, 0x86,
-    0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef,
-    0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07, 0x00,
-    0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0xef, 0x80,
-    0x19, 0xe0, 0x30, 0xef, 0x15, 0xe0, 0x05, 0xef,
-    0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0, 0x06,
-    0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73, 0x8e,
-    0xef, 0x82, 0x50, 0xe0, 0x00, 0xef, 0x05, 0x40,
+    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0x3f, 0x20,
+    0xe9, 0x2a, 0xef, 0x81, 0x78, 0xe6, 0x2f, 0x6f,
+    0xe6, 0x2a, 0xef, 0x00, 0x06, 0xef, 0x06, 0x06,
+    0x2f, 0x96, 0xe0, 0x07, 0x86, 0x00, 0xe6, 0x07,
+    0xe0, 0x83, 0xc8, 0xe2, 0x02, 0x05, 0xe2, 0x0c,
+    0xe0, 0x80, 0x59, 0xc6, 0x00, 0xe6, 0x09, 0x20,
+    0xc6, 0x00, 0x26, 0x00, 0x86, 0xe0, 0x80, 0x4d,
+    0xe5, 0x25, 0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02,
+    0x60, 0x05, 0x0f, 0xe0, 0x80, 0xb8, 0xe5, 0x16,
+    0x06, 0xe0, 0x09, 0xe5, 0x24, 0x66, 0xe9, 0x02,
+    0x80, 0x0d, 0xe0, 0x84, 0x58, 0xc5, 0x00, 0x65,
+    0x00, 0x25, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x80,
+    0x3d, 0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1,
+    0x1a, 0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02,
+    0x60, 0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f,
+    0x4b, 0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f,
+    0xeb, 0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5,
+    0x13, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
+    0xe5, 0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05,
+    0xa0, 0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05,
+    0x00, 0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05,
+    0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
+    0x00, 0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5,
+    0x00, 0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5,
+    0x02, 0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85,
+    0x00, 0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80,
+    0x86, 0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04,
+    0xef, 0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07,
+    0x00, 0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0xef,
+    0x80, 0x19, 0xe0, 0x30, 0xef, 0x15, 0xe0, 0x05,
+    0xef, 0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0,
+    0x06, 0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73,
+    0x8e, 0xef, 0x82, 0x50, 0x80, 0xef, 0x08, 0x40,
     0xef, 0x05, 0x40, 0xef, 0x6c, 0xe0, 0x04, 0xef,
-    0x51, 0xc0, 0xef, 0x04, 0xe0, 0x0c, 0xef, 0x04,
-    0x60, 0xef, 0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0,
-    0xef, 0x20, 0xe0, 0x00, 0xef, 0x16, 0x20, 0x2f,
-    0xe0, 0x46, 0xef, 0x71, 0x00, 0xef, 0x4a, 0x00,
-    0xef, 0x7f, 0xe0, 0x04, 0xef, 0x06, 0x20, 0x8f,
-    0x40, 0x4f, 0x80, 0xcf, 0xe0, 0x01, 0xef, 0x11,
-    0xc0, 0xcf, 0xe0, 0x01, 0x4f, 0xe0, 0x05, 0xcf,
-    0xe0, 0x21, 0xef, 0x80, 0x0b, 0x00, 0xef, 0x2f,
-    0xe0, 0x1d, 0xe9, 0x02, 0xe0, 0x83, 0x7e, 0xe5,
-    0xc0, 0x66, 0x56, 0xe0, 0x1a, 0xe5, 0x8f, 0xad,
-    0xe0, 0x03, 0xe5, 0x80, 0x56, 0x20, 0xe5, 0x95,
-    0xfa, 0xe0, 0x06, 0xe5, 0x9c, 0xa9, 0xe0, 0x8b,
-    0x97, 0xe5, 0x81, 0x96, 0xe0, 0x85, 0x5a, 0xe5,
-    0x92, 0xc3, 0xe0, 0xca, 0xac, 0x2e, 0x1b, 0xe0,
-    0x16, 0xfb, 0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68,
-    0xe0, 0xc0, 0xbd, 0x88, 0xfd, 0xc0, 0xbf, 0x76,
-    0x20, 0xfd, 0xc0, 0xbf, 0x76, 0x20,
+    0x51, 0xc0, 0xef, 0x04, 0x60, 0x0f, 0xe0, 0x07,
+    0xef, 0x04, 0x60, 0xef, 0x30, 0xe0, 0x00, 0xef,
+    0x02, 0xa0, 0xef, 0x20, 0xe0, 0x00, 0xef, 0x16,
+    0x20, 0x2f, 0xe0, 0x46, 0xef, 0x80, 0xcc, 0xe0,
+    0x04, 0xef, 0x06, 0x20, 0x8f, 0x40, 0x8f, 0x40,
+    0xcf, 0xe0, 0x01, 0xef, 0x15, 0x40, 0xef, 0x03,
+    0x80, 0xaf, 0xe0, 0x02, 0xef, 0x02, 0xa0, 0xef,
+    0x00, 0xe0, 0x00, 0xcf, 0xe0, 0x01, 0xef, 0x80,
+    0x0b, 0x00, 0xef, 0x2f, 0xe0, 0x1d, 0xe9, 0x02,
+    0xe0, 0x83, 0x7e, 0xe5, 0xc0, 0x66, 0x58, 0xe0,
+    0x18, 0xe5, 0x8f, 0xb1, 0xc0, 0xe5, 0x80, 0x56,
+    0x20, 0xe5, 0x95, 0xfa, 0xe0, 0x06, 0xe5, 0x9c,
+    0xa9, 0xe0, 0x8b, 0x97, 0xe5, 0x81, 0x96, 0xe0,
+    0x85, 0x5a, 0xe5, 0x92, 0xc3, 0xe0, 0xca, 0xac,
+    0x2e, 0x1b, 0xe0, 0x16, 0xfb, 0x58, 0xe0, 0x78,
+    0xe6, 0x80, 0x68, 0xe0, 0xc0, 0xbd, 0x88, 0xfd,
+    0xc0, 0xbf, 0x76, 0x20, 0xfd, 0xc0, 0xbf, 0x76,
+    0x20,
 };
 
 typedef enum {
@@ -2787,6 +2835,7 @@ typedef enum {
     UNICODE_SCRIPT_Cuneiform,
     UNICODE_SCRIPT_Cypriot,
     UNICODE_SCRIPT_Cyrillic,
+    UNICODE_SCRIPT_Cypro_Minoan,
     UNICODE_SCRIPT_Deseret,
     UNICODE_SCRIPT_Devanagari,
     UNICODE_SCRIPT_Dives_Akuru,
@@ -2869,6 +2918,7 @@ typedef enum {
     UNICODE_SCRIPT_Old_Sogdian,
     UNICODE_SCRIPT_Old_South_Arabian,
     UNICODE_SCRIPT_Old_Turkic,
+    UNICODE_SCRIPT_Old_Uyghur,
     UNICODE_SCRIPT_Oriya,
     UNICODE_SCRIPT_Osage,
     UNICODE_SCRIPT_Osmanya,
@@ -2907,8 +2957,11 @@ typedef enum {
     UNICODE_SCRIPT_Tibetan,
     UNICODE_SCRIPT_Tifinagh,
     UNICODE_SCRIPT_Tirhuta,
+    UNICODE_SCRIPT_Tangsa,
+    UNICODE_SCRIPT_Toto,
     UNICODE_SCRIPT_Ugaritic,
     UNICODE_SCRIPT_Vai,
+    UNICODE_SCRIPT_Vithkuqi,
     UNICODE_SCRIPT_Wancho,
     UNICODE_SCRIPT_Warang_Citi,
     UNICODE_SCRIPT_Yezidi,
@@ -2947,6 +3000,7 @@ static const char unicode_script_name_table[] =
     "Cuneiform,Xsux"              "\0"
     "Cypriot,Cprt"                "\0"
     "Cyrillic,Cyrl"               "\0"
+    "Cypro_Minoan,Cpmn"           "\0"
     "Deseret,Dsrt"                "\0"
     "Devanagari,Deva"             "\0"
     "Dives_Akuru,Diak"            "\0"
@@ -3029,6 +3083,7 @@ static const char unicode_script_name_table[] =
     "Old_Sogdian,Sogo"            "\0"
     "Old_South_Arabian,Sarb"      "\0"
     "Old_Turkic,Orkh"             "\0"
+    "Old_Uyghur,Ougr"             "\0"
     "Oriya,Orya"                  "\0"
     "Osage,Osge"                  "\0"
     "Osmanya,Osma"                "\0"
@@ -3067,8 +3122,11 @@ static const char unicode_script_name_table[] =
     "Tibetan,Tibt"                "\0"
     "Tifinagh,Tfng"               "\0"
     "Tirhuta,Tirh"                "\0"
+    "Tangsa,Tnsa"                 "\0"
+    "Toto,Toto"                   "\0"
     "Ugaritic,Ugar"               "\0"
     "Vai,Vaii"                    "\0"
+    "Vithkuqi,Vith"               "\0"
     "Wancho,Wcho"                 "\0"
     "Warang_Citi,Wara"            "\0"
     "Yezidi,Yezi"                 "\0"
@@ -3076,437 +3134,451 @@ static const char unicode_script_name_table[] =
     "Zanabazar_Square,Zanb"       "\0"
 ;
 
-static const uint8_t unicode_script_table[2609] = {
-    0xc0, 0x19, 0x99, 0x45, 0x85, 0x19, 0x99, 0x45,
-    0xae, 0x19, 0x80, 0x45, 0x8e, 0x19, 0x80, 0x45,
-    0x84, 0x19, 0x96, 0x45, 0x80, 0x19, 0x9e, 0x45,
-    0x80, 0x19, 0xe1, 0x60, 0x45, 0xa6, 0x19, 0x84,
-    0x45, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
-    0x0f, 0x37, 0x83, 0x2b, 0x80, 0x19, 0x82, 0x2b,
-    0x01, 0x83, 0x2b, 0x80, 0x19, 0x80, 0x2b, 0x03,
-    0x80, 0x2b, 0x80, 0x19, 0x80, 0x2b, 0x80, 0x19,
-    0x82, 0x2b, 0x00, 0x80, 0x2b, 0x00, 0x93, 0x2b,
-    0x00, 0xbe, 0x2b, 0x8d, 0x1a, 0x8f, 0x2b, 0xe0,
-    0x24, 0x1d, 0x81, 0x37, 0xe0, 0x48, 0x1d, 0x00,
+static const uint8_t unicode_script_table[2690] = {
+    0xc0, 0x19, 0x99, 0x46, 0x85, 0x19, 0x99, 0x46,
+    0xae, 0x19, 0x80, 0x46, 0x8e, 0x19, 0x80, 0x46,
+    0x84, 0x19, 0x96, 0x46, 0x80, 0x19, 0x9e, 0x46,
+    0x80, 0x19, 0xe1, 0x60, 0x46, 0xa6, 0x19, 0x84,
+    0x46, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
+    0x0f, 0x38, 0x83, 0x2c, 0x80, 0x19, 0x82, 0x2c,
+    0x01, 0x83, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x03,
+    0x80, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x80, 0x19,
+    0x82, 0x2c, 0x00, 0x80, 0x2c, 0x00, 0x93, 0x2c,
+    0x00, 0xbe, 0x2c, 0x8d, 0x1a, 0x8f, 0x2c, 0xe0,
+    0x24, 0x1d, 0x81, 0x38, 0xe0, 0x48, 0x1d, 0x00,
     0xa5, 0x05, 0x01, 0xb1, 0x05, 0x01, 0x82, 0x05,
-    0x00, 0xb6, 0x34, 0x07, 0x9a, 0x34, 0x03, 0x85,
-    0x34, 0x0a, 0x84, 0x04, 0x80, 0x19, 0x85, 0x04,
-    0x80, 0x19, 0x8d, 0x04, 0x80, 0x19, 0x80, 0x04,
-    0x00, 0x80, 0x04, 0x80, 0x19, 0x9f, 0x04, 0x80,
-    0x19, 0x89, 0x04, 0x8a, 0x37, 0x99, 0x04, 0x80,
-    0x37, 0xe0, 0x0b, 0x04, 0x80, 0x19, 0xa1, 0x04,
-    0x8d, 0x87, 0x00, 0xbb, 0x87, 0x01, 0x82, 0x87,
-    0xaf, 0x04, 0xb1, 0x91, 0x0d, 0xba, 0x63, 0x01,
-    0x82, 0x63, 0xad, 0x7b, 0x01, 0x8e, 0x7b, 0x00,
-    0x9b, 0x50, 0x01, 0x80, 0x50, 0x00, 0x8a, 0x87,
-    0x34, 0x94, 0x04, 0x00, 0x91, 0x04, 0x0a, 0x8e,
-    0x04, 0x80, 0x19, 0x9c, 0x04, 0xd0, 0x1f, 0x83,
-    0x37, 0x8e, 0x1f, 0x81, 0x19, 0x99, 0x1f, 0x83,
-    0x0b, 0x00, 0x87, 0x0b, 0x01, 0x81, 0x0b, 0x01,
-    0x95, 0x0b, 0x00, 0x86, 0x0b, 0x00, 0x80, 0x0b,
-    0x02, 0x83, 0x0b, 0x01, 0x88, 0x0b, 0x01, 0x81,
-    0x0b, 0x01, 0x83, 0x0b, 0x07, 0x80, 0x0b, 0x03,
-    0x81, 0x0b, 0x00, 0x84, 0x0b, 0x01, 0x98, 0x0b,
-    0x01, 0x82, 0x2e, 0x00, 0x85, 0x2e, 0x03, 0x81,
-    0x2e, 0x01, 0x95, 0x2e, 0x00, 0x86, 0x2e, 0x00,
-    0x81, 0x2e, 0x00, 0x81, 0x2e, 0x00, 0x81, 0x2e,
-    0x01, 0x80, 0x2e, 0x00, 0x84, 0x2e, 0x03, 0x81,
-    0x2e, 0x01, 0x82, 0x2e, 0x02, 0x80, 0x2e, 0x06,
-    0x83, 0x2e, 0x00, 0x80, 0x2e, 0x06, 0x90, 0x2e,
-    0x09, 0x82, 0x2c, 0x00, 0x88, 0x2c, 0x00, 0x82,
-    0x2c, 0x00, 0x95, 0x2c, 0x00, 0x86, 0x2c, 0x00,
-    0x81, 0x2c, 0x00, 0x84, 0x2c, 0x01, 0x89, 0x2c,
-    0x00, 0x82, 0x2c, 0x00, 0x82, 0x2c, 0x01, 0x80,
-    0x2c, 0x0e, 0x83, 0x2c, 0x01, 0x8b, 0x2c, 0x06,
-    0x86, 0x2c, 0x00, 0x82, 0x70, 0x00, 0x87, 0x70,
-    0x01, 0x81, 0x70, 0x01, 0x95, 0x70, 0x00, 0x86,
-    0x70, 0x00, 0x81, 0x70, 0x00, 0x84, 0x70, 0x01,
-    0x88, 0x70, 0x01, 0x81, 0x70, 0x01, 0x82, 0x70,
-    0x06, 0x82, 0x70, 0x03, 0x81, 0x70, 0x00, 0x84,
-    0x70, 0x01, 0x91, 0x70, 0x09, 0x81, 0x8e, 0x00,
-    0x85, 0x8e, 0x02, 0x82, 0x8e, 0x00, 0x83, 0x8e,
-    0x02, 0x81, 0x8e, 0x00, 0x80, 0x8e, 0x00, 0x81,
-    0x8e, 0x02, 0x81, 0x8e, 0x02, 0x82, 0x8e, 0x02,
-    0x8b, 0x8e, 0x03, 0x84, 0x8e, 0x02, 0x82, 0x8e,
-    0x00, 0x83, 0x8e, 0x01, 0x80, 0x8e, 0x05, 0x80,
-    0x8e, 0x0d, 0x94, 0x8e, 0x04, 0x8c, 0x90, 0x00,
-    0x82, 0x90, 0x00, 0x96, 0x90, 0x00, 0x8f, 0x90,
-    0x02, 0x87, 0x90, 0x00, 0x82, 0x90, 0x00, 0x83,
-    0x90, 0x06, 0x81, 0x90, 0x00, 0x82, 0x90, 0x04,
-    0x83, 0x90, 0x01, 0x89, 0x90, 0x06, 0x88, 0x90,
-    0x8c, 0x3c, 0x00, 0x82, 0x3c, 0x00, 0x96, 0x3c,
-    0x00, 0x89, 0x3c, 0x00, 0x84, 0x3c, 0x01, 0x88,
-    0x3c, 0x00, 0x82, 0x3c, 0x00, 0x83, 0x3c, 0x06,
-    0x81, 0x3c, 0x06, 0x80, 0x3c, 0x00, 0x83, 0x3c,
-    0x01, 0x89, 0x3c, 0x00, 0x81, 0x3c, 0x0c, 0x8c,
-    0x4f, 0x00, 0x82, 0x4f, 0x00, 0xb2, 0x4f, 0x00,
-    0x82, 0x4f, 0x00, 0x85, 0x4f, 0x03, 0x8f, 0x4f,
-    0x01, 0x99, 0x4f, 0x00, 0x82, 0x81, 0x00, 0x91,
-    0x81, 0x02, 0x97, 0x81, 0x00, 0x88, 0x81, 0x00,
-    0x80, 0x81, 0x01, 0x86, 0x81, 0x02, 0x80, 0x81,
-    0x03, 0x85, 0x81, 0x00, 0x80, 0x81, 0x00, 0x87,
-    0x81, 0x05, 0x89, 0x81, 0x01, 0x82, 0x81, 0x0b,
-    0xb9, 0x92, 0x03, 0x80, 0x19, 0x9b, 0x92, 0x24,
-    0x81, 0x44, 0x00, 0x80, 0x44, 0x00, 0x84, 0x44,
-    0x00, 0x97, 0x44, 0x00, 0x80, 0x44, 0x00, 0x96,
-    0x44, 0x01, 0x84, 0x44, 0x00, 0x80, 0x44, 0x00,
-    0x85, 0x44, 0x01, 0x89, 0x44, 0x01, 0x83, 0x44,
-    0x1f, 0xc7, 0x93, 0x00, 0xa3, 0x93, 0x03, 0xa6,
-    0x93, 0x00, 0xa3, 0x93, 0x00, 0x8e, 0x93, 0x00,
-    0x86, 0x93, 0x83, 0x19, 0x81, 0x93, 0x24, 0xe0,
-    0x3f, 0x5e, 0xa5, 0x27, 0x00, 0x80, 0x27, 0x04,
-    0x80, 0x27, 0x01, 0xaa, 0x27, 0x80, 0x19, 0x83,
-    0x27, 0xe0, 0x9f, 0x30, 0xc8, 0x26, 0x00, 0x83,
-    0x26, 0x01, 0x86, 0x26, 0x00, 0x80, 0x26, 0x00,
-    0x83, 0x26, 0x01, 0xa8, 0x26, 0x00, 0x83, 0x26,
-    0x01, 0xa0, 0x26, 0x00, 0x83, 0x26, 0x01, 0x86,
-    0x26, 0x00, 0x80, 0x26, 0x00, 0x83, 0x26, 0x01,
-    0x8e, 0x26, 0x00, 0xb8, 0x26, 0x00, 0x83, 0x26,
-    0x01, 0xc2, 0x26, 0x01, 0x9f, 0x26, 0x02, 0x99,
-    0x26, 0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01,
-    0xe2, 0x1f, 0x12, 0x9c, 0x66, 0x02, 0xca, 0x7a,
-    0x82, 0x19, 0x8a, 0x7a, 0x06, 0x8c, 0x88, 0x00,
-    0x86, 0x88, 0x0a, 0x94, 0x32, 0x81, 0x19, 0x08,
-    0x93, 0x11, 0x0b, 0x8c, 0x89, 0x00, 0x82, 0x89,
-    0x00, 0x81, 0x89, 0x0b, 0xdd, 0x40, 0x01, 0x89,
-    0x40, 0x05, 0x89, 0x40, 0x05, 0x81, 0x5b, 0x81,
-    0x19, 0x80, 0x5b, 0x80, 0x19, 0x88, 0x5b, 0x00,
-    0x89, 0x5b, 0x05, 0xd8, 0x5b, 0x06, 0xaa, 0x5b,
-    0x04, 0xc5, 0x12, 0x09, 0x9e, 0x47, 0x00, 0x8b,
-    0x47, 0x03, 0x8b, 0x47, 0x03, 0x80, 0x47, 0x02,
-    0x8b, 0x47, 0x9d, 0x8a, 0x01, 0x84, 0x8a, 0x0a,
-    0xab, 0x61, 0x03, 0x99, 0x61, 0x05, 0x8a, 0x61,
-    0x02, 0x81, 0x61, 0x9f, 0x40, 0x9b, 0x10, 0x01,
-    0x81, 0x10, 0xbe, 0x8b, 0x00, 0x9c, 0x8b, 0x01,
-    0x8a, 0x8b, 0x05, 0x89, 0x8b, 0x05, 0x8d, 0x8b,
-    0x01, 0x90, 0x37, 0x3e, 0xcb, 0x07, 0x03, 0xac,
-    0x07, 0x02, 0xbf, 0x85, 0xb3, 0x0a, 0x07, 0x83,
-    0x0a, 0xb7, 0x46, 0x02, 0x8e, 0x46, 0x02, 0x82,
-    0x46, 0xaf, 0x67, 0x88, 0x1d, 0x06, 0xaa, 0x27,
-    0x01, 0x82, 0x27, 0x87, 0x85, 0x07, 0x82, 0x37,
-    0x80, 0x19, 0x8c, 0x37, 0x80, 0x19, 0x86, 0x37,
-    0x83, 0x19, 0x80, 0x37, 0x85, 0x19, 0x80, 0x37,
-    0x82, 0x19, 0x81, 0x37, 0x80, 0x19, 0x04, 0xa5,
-    0x45, 0x84, 0x2b, 0x80, 0x1d, 0xb0, 0x45, 0x84,
-    0x2b, 0x83, 0x45, 0x84, 0x2b, 0x8c, 0x45, 0x80,
-    0x1d, 0xc5, 0x45, 0x80, 0x2b, 0xb9, 0x37, 0x00,
-    0x84, 0x37, 0xe0, 0x9f, 0x45, 0x95, 0x2b, 0x01,
-    0x85, 0x2b, 0x01, 0xa5, 0x2b, 0x01, 0x85, 0x2b,
-    0x01, 0x87, 0x2b, 0x00, 0x80, 0x2b, 0x00, 0x80,
-    0x2b, 0x00, 0x80, 0x2b, 0x00, 0x9e, 0x2b, 0x01,
-    0xb4, 0x2b, 0x00, 0x8e, 0x2b, 0x00, 0x8d, 0x2b,
-    0x01, 0x85, 0x2b, 0x00, 0x92, 0x2b, 0x01, 0x82,
-    0x2b, 0x00, 0x88, 0x2b, 0x00, 0x8b, 0x19, 0x81,
-    0x37, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80, 0x45,
-    0x01, 0x8a, 0x19, 0x80, 0x45, 0x8e, 0x19, 0x00,
-    0x8c, 0x45, 0x02, 0x9f, 0x19, 0x0f, 0xa0, 0x37,
-    0x0e, 0xa5, 0x19, 0x80, 0x2b, 0x82, 0x19, 0x81,
-    0x45, 0x85, 0x19, 0x80, 0x45, 0x9a, 0x19, 0x80,
-    0x45, 0x90, 0x19, 0xa8, 0x45, 0x82, 0x19, 0x03,
-    0xe2, 0x36, 0x19, 0x18, 0x8a, 0x19, 0x14, 0xe3,
-    0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13, 0x19,
-    0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19, 0xae,
-    0x28, 0x00, 0xae, 0x28, 0x00, 0x9f, 0x45, 0xe0,
-    0x13, 0x1a, 0x04, 0x86, 0x1a, 0xa5, 0x27, 0x00,
-    0x80, 0x27, 0x04, 0x80, 0x27, 0x01, 0xb7, 0x94,
-    0x06, 0x81, 0x94, 0x0d, 0x80, 0x94, 0x96, 0x26,
-    0x08, 0x86, 0x26, 0x00, 0x86, 0x26, 0x00, 0x86,
-    0x26, 0x00, 0x86, 0x26, 0x00, 0x86, 0x26, 0x00,
-    0x86, 0x26, 0x00, 0x86, 0x26, 0x00, 0x86, 0x26,
-    0x00, 0x9f, 0x1d, 0xd2, 0x19, 0x2c, 0x99, 0x2f,
-    0x00, 0xd8, 0x2f, 0x0b, 0xe0, 0x75, 0x2f, 0x19,
-    0x8b, 0x19, 0x03, 0x84, 0x19, 0x80, 0x2f, 0x80,
-    0x19, 0x80, 0x2f, 0x98, 0x19, 0x88, 0x2f, 0x83,
-    0x37, 0x81, 0x30, 0x87, 0x19, 0x83, 0x2f, 0x83,
-    0x19, 0x00, 0xd5, 0x35, 0x01, 0x81, 0x37, 0x81,
-    0x19, 0x82, 0x35, 0x80, 0x19, 0xd9, 0x3d, 0x81,
-    0x19, 0x82, 0x3d, 0x04, 0xaa, 0x0d, 0x00, 0xdd,
-    0x30, 0x00, 0x8f, 0x19, 0x9f, 0x0d, 0xa3, 0x19,
-    0x0b, 0x8f, 0x3d, 0x9e, 0x30, 0x00, 0xbf, 0x19,
-    0x9e, 0x30, 0xd0, 0x19, 0xae, 0x3d, 0x80, 0x19,
-    0xd7, 0x3d, 0xe0, 0x47, 0x19, 0xf0, 0x09, 0x5f,
-    0x2f, 0xbf, 0x19, 0xf0, 0x41, 0x9c, 0x2f, 0x02,
-    0xe4, 0x2c, 0x9b, 0x02, 0xb6, 0x9b, 0x08, 0xaf,
-    0x4a, 0xe0, 0xcb, 0x97, 0x13, 0xdf, 0x1d, 0xd7,
-    0x08, 0x07, 0xa1, 0x19, 0xe0, 0x05, 0x45, 0x82,
-    0x19, 0xb4, 0x45, 0x01, 0x88, 0x45, 0x29, 0x8a,
-    0x45, 0xac, 0x86, 0x02, 0x89, 0x19, 0x05, 0xb7,
-    0x76, 0x07, 0xc5, 0x7c, 0x07, 0x8b, 0x7c, 0x05,
-    0x9f, 0x1f, 0xad, 0x3e, 0x80, 0x19, 0x80, 0x3e,
-    0xa3, 0x79, 0x0a, 0x80, 0x79, 0x9c, 0x30, 0x02,
-    0xcd, 0x3a, 0x00, 0x80, 0x19, 0x89, 0x3a, 0x03,
-    0x81, 0x3a, 0x9e, 0x5e, 0x00, 0xb6, 0x16, 0x08,
-    0x8d, 0x16, 0x01, 0x89, 0x16, 0x01, 0x83, 0x16,
-    0x9f, 0x5e, 0xc2, 0x8c, 0x17, 0x84, 0x8c, 0x96,
-    0x55, 0x09, 0x85, 0x26, 0x01, 0x85, 0x26, 0x01,
-    0x85, 0x26, 0x08, 0x86, 0x26, 0x00, 0x86, 0x26,
-    0x00, 0xaa, 0x45, 0x80, 0x19, 0x88, 0x45, 0x80,
-    0x2b, 0x83, 0x45, 0x81, 0x19, 0x03, 0xcf, 0x17,
-    0xad, 0x55, 0x01, 0x89, 0x55, 0x05, 0xf0, 0x1b,
-    0x43, 0x30, 0x0b, 0x96, 0x30, 0x03, 0xb0, 0x30,
-    0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x2f, 0x01, 0xe0,
-    0x09, 0x2f, 0x25, 0x86, 0x45, 0x0b, 0x84, 0x05,
-    0x04, 0x99, 0x34, 0x00, 0x84, 0x34, 0x00, 0x80,
-    0x34, 0x00, 0x81, 0x34, 0x00, 0x81, 0x34, 0x00,
-    0x89, 0x34, 0xe0, 0x11, 0x04, 0x10, 0xe1, 0x0a,
-    0x04, 0x81, 0x19, 0x0f, 0xbf, 0x04, 0x01, 0xb5,
-    0x04, 0x27, 0x8d, 0x04, 0x01, 0x8f, 0x37, 0x89,
-    0x19, 0x05, 0x8d, 0x37, 0x81, 0x1d, 0xa2, 0x19,
-    0x00, 0x92, 0x19, 0x00, 0x83, 0x19, 0x03, 0x84,
-    0x04, 0x00, 0xe0, 0x26, 0x04, 0x01, 0x80, 0x19,
-    0x00, 0x9f, 0x19, 0x99, 0x45, 0x85, 0x19, 0x99,
-    0x45, 0x8a, 0x19, 0x89, 0x3d, 0x80, 0x19, 0xac,
-    0x3d, 0x81, 0x19, 0x9e, 0x30, 0x02, 0x85, 0x30,
-    0x01, 0x85, 0x30, 0x01, 0x85, 0x30, 0x01, 0x82,
-    0x30, 0x02, 0x86, 0x19, 0x00, 0x86, 0x19, 0x09,
-    0x84, 0x19, 0x01, 0x8b, 0x49, 0x00, 0x99, 0x49,
-    0x00, 0x92, 0x49, 0x00, 0x81, 0x49, 0x00, 0x8e,
-    0x49, 0x01, 0x8d, 0x49, 0x21, 0xe0, 0x1a, 0x49,
-    0x04, 0x82, 0x19, 0x03, 0xac, 0x19, 0x02, 0x88,
-    0x19, 0xce, 0x2b, 0x00, 0x8c, 0x19, 0x02, 0x80,
-    0x2b, 0x2e, 0xac, 0x19, 0x80, 0x37, 0x60, 0x21,
-    0x9c, 0x4b, 0x02, 0xb0, 0x13, 0x0e, 0x80, 0x37,
-    0x9a, 0x19, 0x03, 0xa3, 0x69, 0x08, 0x82, 0x69,
-    0x9a, 0x29, 0x04, 0xaa, 0x6b, 0x04, 0x9d, 0x96,
-    0x00, 0x80, 0x96, 0xa3, 0x6c, 0x03, 0x8d, 0x6c,
-    0x29, 0xcf, 0x1e, 0xaf, 0x7e, 0x9d, 0x72, 0x01,
-    0x89, 0x72, 0x05, 0xa3, 0x71, 0x03, 0xa3, 0x71,
-    0x03, 0xa7, 0x24, 0x07, 0xb3, 0x14, 0x0a, 0x80,
-    0x14, 0x60, 0x2f, 0xe0, 0xd6, 0x48, 0x08, 0x95,
-    0x48, 0x09, 0x87, 0x48, 0x60, 0x37, 0x85, 0x1c,
-    0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c, 0x00, 0x81,
-    0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80, 0x1c, 0x95,
-    0x36, 0x00, 0x88, 0x36, 0x9f, 0x74, 0x9e, 0x5f,
-    0x07, 0x88, 0x5f, 0x2f, 0x92, 0x33, 0x00, 0x81,
-    0x33, 0x04, 0x84, 0x33, 0x9b, 0x77, 0x02, 0x80,
-    0x77, 0x99, 0x4c, 0x04, 0x80, 0x4c, 0x3f, 0x9f,
-    0x58, 0x97, 0x57, 0x03, 0x93, 0x57, 0x01, 0xad,
-    0x57, 0x83, 0x3f, 0x00, 0x81, 0x3f, 0x04, 0x87,
-    0x3f, 0x00, 0x82, 0x3f, 0x00, 0x9c, 0x3f, 0x01,
-    0x82, 0x3f, 0x03, 0x89, 0x3f, 0x06, 0x88, 0x3f,
-    0x06, 0x9f, 0x6e, 0x9f, 0x6a, 0x1f, 0xa6, 0x51,
-    0x03, 0x8b, 0x51, 0x08, 0xb5, 0x06, 0x02, 0x86,
-    0x06, 0x95, 0x39, 0x01, 0x87, 0x39, 0x92, 0x38,
-    0x04, 0x87, 0x38, 0x91, 0x78, 0x06, 0x83, 0x78,
-    0x0b, 0x86, 0x78, 0x4f, 0xc8, 0x6f, 0x36, 0xb2,
-    0x68, 0x0c, 0xb2, 0x68, 0x06, 0x85, 0x68, 0xa7,
-    0x31, 0x07, 0x89, 0x31, 0x60, 0xc5, 0x9e, 0x04,
-    0x00, 0xa9, 0x9a, 0x00, 0x82, 0x9a, 0x01, 0x81,
-    0x9a, 0x4d, 0xa7, 0x6d, 0x07, 0xa9, 0x82, 0x55,
-    0x9b, 0x18, 0x13, 0x96, 0x25, 0x08, 0xcd, 0x0e,
-    0x03, 0x9d, 0x0e, 0x0e, 0x80, 0x0e, 0xc1, 0x3b,
-    0x0a, 0x80, 0x3b, 0x01, 0x98, 0x83, 0x06, 0x89,
-    0x83, 0x05, 0xb4, 0x15, 0x00, 0x91, 0x15, 0x07,
-    0xa6, 0x4e, 0x08, 0xdf, 0x7d, 0x00, 0x93, 0x81,
-    0x0a, 0x91, 0x41, 0x00, 0xab, 0x41, 0x40, 0x86,
-    0x5d, 0x00, 0x80, 0x5d, 0x00, 0x83, 0x5d, 0x00,
-    0x8e, 0x5d, 0x00, 0x8a, 0x5d, 0x05, 0xba, 0x43,
-    0x04, 0x89, 0x43, 0x05, 0x83, 0x2a, 0x00, 0x87,
-    0x2a, 0x01, 0x81, 0x2a, 0x01, 0x95, 0x2a, 0x00,
-    0x86, 0x2a, 0x00, 0x81, 0x2a, 0x00, 0x84, 0x2a,
-    0x00, 0x80, 0x37, 0x88, 0x2a, 0x01, 0x81, 0x2a,
-    0x01, 0x82, 0x2a, 0x01, 0x80, 0x2a, 0x05, 0x80,
-    0x2a, 0x04, 0x86, 0x2a, 0x01, 0x86, 0x2a, 0x02,
-    0x84, 0x2a, 0x60, 0x2a, 0xdb, 0x62, 0x00, 0x84,
-    0x62, 0x1d, 0xc7, 0x95, 0x07, 0x89, 0x95, 0x60,
-    0x45, 0xb5, 0x7f, 0x01, 0xa5, 0x7f, 0x21, 0xc4,
-    0x5a, 0x0a, 0x89, 0x5a, 0x05, 0x8c, 0x5b, 0x12,
-    0xb8, 0x8d, 0x06, 0x89, 0x8d, 0x35, 0x9a, 0x02,
-    0x01, 0x8e, 0x02, 0x03, 0x8f, 0x02, 0x60, 0x5f,
-    0xbb, 0x21, 0x60, 0x03, 0xd2, 0x99, 0x0b, 0x80,
-    0x99, 0x86, 0x20, 0x01, 0x80, 0x20, 0x01, 0x87,
-    0x20, 0x00, 0x81, 0x20, 0x00, 0x9d, 0x20, 0x00,
-    0x81, 0x20, 0x01, 0x8b, 0x20, 0x08, 0x89, 0x20,
-    0x45, 0x87, 0x60, 0x01, 0xad, 0x60, 0x01, 0x8a,
-    0x60, 0x1a, 0xc7, 0x9c, 0x07, 0xd2, 0x84, 0x1c,
-    0xb8, 0x75, 0x60, 0xa6, 0x88, 0x0c, 0x00, 0xac,
-    0x0c, 0x00, 0x8d, 0x0c, 0x09, 0x9c, 0x0c, 0x02,
-    0x9f, 0x52, 0x01, 0x95, 0x52, 0x00, 0x8d, 0x52,
-    0x48, 0x86, 0x53, 0x00, 0x81, 0x53, 0x00, 0xab,
-    0x53, 0x02, 0x80, 0x53, 0x00, 0x81, 0x53, 0x00,
-    0x88, 0x53, 0x07, 0x89, 0x53, 0x05, 0x85, 0x2d,
-    0x00, 0x81, 0x2d, 0x00, 0xa4, 0x2d, 0x00, 0x81,
-    0x2d, 0x00, 0x85, 0x2d, 0x06, 0x89, 0x2d, 0x60,
-    0xd5, 0x98, 0x4d, 0x60, 0x56, 0x80, 0x4a, 0x0e,
-    0xb1, 0x8e, 0x0c, 0x80, 0x8e, 0xe3, 0x39, 0x1b,
-    0x60, 0x05, 0xe0, 0x0e, 0x1b, 0x00, 0x84, 0x1b,
-    0x0a, 0xe0, 0x63, 0x1b, 0x6a, 0x5b, 0xe3, 0xce,
-    0x23, 0x00, 0x88, 0x23, 0x6f, 0x66, 0xe1, 0xe6,
-    0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8, 0x08, 0x06,
-    0x9e, 0x5c, 0x00, 0x89, 0x5c, 0x03, 0x81, 0x5c,
-    0x5f, 0x9d, 0x09, 0x01, 0x85, 0x09, 0x09, 0xc5,
-    0x73, 0x09, 0x89, 0x73, 0x00, 0x86, 0x73, 0x00,
-    0x94, 0x73, 0x04, 0x92, 0x73, 0x62, 0x4f, 0xda,
-    0x54, 0x60, 0x04, 0xca, 0x59, 0x03, 0xb8, 0x59,
-    0x06, 0x90, 0x59, 0x3f, 0x80, 0x8f, 0x80, 0x64,
-    0x81, 0x19, 0x80, 0x42, 0x0a, 0x81, 0x2f, 0x0d,
-    0xf0, 0x07, 0x97, 0x8f, 0x07, 0xe2, 0x9f, 0x8f,
-    0xe1, 0x75, 0x42, 0x29, 0x88, 0x8f, 0x70, 0x12,
-    0x96, 0x80, 0x3d, 0xe0, 0xbd, 0x35, 0x30, 0x82,
-    0x35, 0x10, 0x83, 0x3d, 0x07, 0xe1, 0x2b, 0x64,
-    0x68, 0xa3, 0xe0, 0x0a, 0x22, 0x04, 0x8c, 0x22,
-    0x02, 0x88, 0x22, 0x06, 0x89, 0x22, 0x01, 0x83,
-    0x22, 0x83, 0x19, 0x70, 0x02, 0xfb, 0xe0, 0x95,
-    0x19, 0x09, 0xa6, 0x19, 0x01, 0xbd, 0x19, 0x82,
-    0x37, 0x90, 0x19, 0x87, 0x37, 0x81, 0x19, 0x86,
-    0x37, 0x9d, 0x19, 0x83, 0x37, 0xba, 0x19, 0x16,
-    0xc5, 0x2b, 0x60, 0x39, 0x93, 0x19, 0x0b, 0xd6,
-    0x19, 0x08, 0x98, 0x19, 0x60, 0x26, 0xd4, 0x19,
-    0x00, 0xc6, 0x19, 0x00, 0x81, 0x19, 0x01, 0x80,
-    0x19, 0x01, 0x81, 0x19, 0x01, 0x83, 0x19, 0x00,
-    0x8b, 0x19, 0x00, 0x80, 0x19, 0x00, 0x86, 0x19,
-    0x00, 0xc0, 0x19, 0x00, 0x83, 0x19, 0x01, 0x87,
-    0x19, 0x00, 0x86, 0x19, 0x00, 0x9b, 0x19, 0x00,
-    0x83, 0x19, 0x00, 0x84, 0x19, 0x00, 0x80, 0x19,
-    0x02, 0x86, 0x19, 0x00, 0xe0, 0xf3, 0x19, 0x01,
-    0xe0, 0xc3, 0x19, 0x01, 0xb1, 0x19, 0xe2, 0x2b,
-    0x80, 0x0e, 0x84, 0x80, 0x00, 0x8e, 0x80, 0x64,
-    0xef, 0x86, 0x28, 0x00, 0x90, 0x28, 0x01, 0x86,
-    0x28, 0x00, 0x81, 0x28, 0x00, 0x84, 0x28, 0x60,
-    0x74, 0xac, 0x65, 0x02, 0x8d, 0x65, 0x01, 0x89,
-    0x65, 0x03, 0x81, 0x65, 0x61, 0x0f, 0xb9, 0x98,
-    0x04, 0x80, 0x98, 0x64, 0x9f, 0xe0, 0x64, 0x56,
-    0x01, 0x8f, 0x56, 0x28, 0xcb, 0x01, 0x03, 0x89,
-    0x01, 0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19,
-    0x4b, 0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00,
-    0x9a, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
-    0x01, 0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83,
-    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05,
-    0x80, 0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04,
-    0x00, 0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81,
-    0x04, 0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00,
-    0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04,
-    0x00, 0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80,
-    0x04, 0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00,
-    0x83, 0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04,
-    0x00, 0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82,
-    0x04, 0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33,
-    0x81, 0x04, 0x60, 0xad, 0xab, 0x19, 0x03, 0xe0,
-    0x03, 0x19, 0x0b, 0x8e, 0x19, 0x01, 0x8e, 0x19,
-    0x00, 0x8e, 0x19, 0x00, 0xa4, 0x19, 0x09, 0xe0,
-    0x4d, 0x19, 0x37, 0x99, 0x19, 0x80, 0x35, 0x81,
-    0x19, 0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06,
-    0x81, 0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3,
-    0x77, 0x19, 0x07, 0x8c, 0x19, 0x02, 0x8c, 0x19,
-    0x02, 0xe0, 0x13, 0x19, 0x0b, 0xd8, 0x19, 0x06,
-    0x8b, 0x19, 0x13, 0x8b, 0x19, 0x03, 0xb7, 0x19,
-    0x07, 0x89, 0x19, 0x05, 0xa7, 0x19, 0x07, 0x9d,
-    0x19, 0x01, 0x81, 0x19, 0x4d, 0xe0, 0x18, 0x19,
-    0x00, 0xd1, 0x19, 0x00, 0xe0, 0x26, 0x19, 0x0b,
-    0x8d, 0x19, 0x01, 0x84, 0x19, 0x02, 0x82, 0x19,
-    0x04, 0x86, 0x19, 0x08, 0x98, 0x19, 0x06, 0x86,
-    0x19, 0x08, 0x82, 0x19, 0x0c, 0x86, 0x19, 0x28,
-    0xe0, 0x32, 0x19, 0x00, 0xb6, 0x19, 0x24, 0x89,
-    0x19, 0x63, 0xa5, 0xf0, 0x96, 0x7d, 0x2f, 0x21,
-    0xef, 0xd4, 0x2f, 0x0a, 0xe0, 0x7d, 0x2f, 0x01,
-    0xf0, 0x06, 0x21, 0x2f, 0x0d, 0xf0, 0x0c, 0xd0,
-    0x2f, 0x6b, 0xbe, 0xe1, 0xbd, 0x2f, 0x65, 0x81,
-    0xf0, 0x02, 0xea, 0x2f, 0x7a, 0xdc, 0x55, 0x80,
-    0x19, 0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0, 0x8f,
-    0x37,
+    0x00, 0xb6, 0x35, 0x07, 0x9a, 0x35, 0x03, 0x85,
+    0x35, 0x0a, 0x84, 0x04, 0x80, 0x19, 0x85, 0x04,
+    0x80, 0x19, 0x8d, 0x04, 0x80, 0x19, 0x82, 0x04,
+    0x80, 0x19, 0x9f, 0x04, 0x80, 0x19, 0x89, 0x04,
+    0x8a, 0x38, 0x99, 0x04, 0x80, 0x38, 0xe0, 0x0b,
+    0x04, 0x80, 0x19, 0xa1, 0x04, 0x8d, 0x89, 0x00,
+    0xbb, 0x89, 0x01, 0x82, 0x89, 0xaf, 0x04, 0xb1,
+    0x93, 0x0d, 0xba, 0x64, 0x01, 0x82, 0x64, 0xad,
+    0x7d, 0x01, 0x8e, 0x7d, 0x00, 0x9b, 0x51, 0x01,
+    0x80, 0x51, 0x00, 0x8a, 0x89, 0x04, 0x9e, 0x04,
+    0x00, 0x81, 0x04, 0x05, 0xc9, 0x04, 0x80, 0x19,
+    0x9c, 0x04, 0xd0, 0x20, 0x83, 0x38, 0x8e, 0x20,
+    0x81, 0x19, 0x99, 0x20, 0x83, 0x0b, 0x00, 0x87,
+    0x0b, 0x01, 0x81, 0x0b, 0x01, 0x95, 0x0b, 0x00,
+    0x86, 0x0b, 0x00, 0x80, 0x0b, 0x02, 0x83, 0x0b,
+    0x01, 0x88, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x83,
+    0x0b, 0x07, 0x80, 0x0b, 0x03, 0x81, 0x0b, 0x00,
+    0x84, 0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x2f,
+    0x00, 0x85, 0x2f, 0x03, 0x81, 0x2f, 0x01, 0x95,
+    0x2f, 0x00, 0x86, 0x2f, 0x00, 0x81, 0x2f, 0x00,
+    0x81, 0x2f, 0x00, 0x81, 0x2f, 0x01, 0x80, 0x2f,
+    0x00, 0x84, 0x2f, 0x03, 0x81, 0x2f, 0x01, 0x82,
+    0x2f, 0x02, 0x80, 0x2f, 0x06, 0x83, 0x2f, 0x00,
+    0x80, 0x2f, 0x06, 0x90, 0x2f, 0x09, 0x82, 0x2d,
+    0x00, 0x88, 0x2d, 0x00, 0x82, 0x2d, 0x00, 0x95,
+    0x2d, 0x00, 0x86, 0x2d, 0x00, 0x81, 0x2d, 0x00,
+    0x84, 0x2d, 0x01, 0x89, 0x2d, 0x00, 0x82, 0x2d,
+    0x00, 0x82, 0x2d, 0x01, 0x80, 0x2d, 0x0e, 0x83,
+    0x2d, 0x01, 0x8b, 0x2d, 0x06, 0x86, 0x2d, 0x00,
+    0x82, 0x72, 0x00, 0x87, 0x72, 0x01, 0x81, 0x72,
+    0x01, 0x95, 0x72, 0x00, 0x86, 0x72, 0x00, 0x81,
+    0x72, 0x00, 0x84, 0x72, 0x01, 0x88, 0x72, 0x01,
+    0x81, 0x72, 0x01, 0x82, 0x72, 0x06, 0x82, 0x72,
+    0x03, 0x81, 0x72, 0x00, 0x84, 0x72, 0x01, 0x91,
+    0x72, 0x09, 0x81, 0x90, 0x00, 0x85, 0x90, 0x02,
+    0x82, 0x90, 0x00, 0x83, 0x90, 0x02, 0x81, 0x90,
+    0x00, 0x80, 0x90, 0x00, 0x81, 0x90, 0x02, 0x81,
+    0x90, 0x02, 0x82, 0x90, 0x02, 0x8b, 0x90, 0x03,
+    0x84, 0x90, 0x02, 0x82, 0x90, 0x00, 0x83, 0x90,
+    0x01, 0x80, 0x90, 0x05, 0x80, 0x90, 0x0d, 0x94,
+    0x90, 0x04, 0x8c, 0x92, 0x00, 0x82, 0x92, 0x00,
+    0x96, 0x92, 0x00, 0x8f, 0x92, 0x01, 0x88, 0x92,
+    0x00, 0x82, 0x92, 0x00, 0x83, 0x92, 0x06, 0x81,
+    0x92, 0x00, 0x82, 0x92, 0x01, 0x80, 0x92, 0x01,
+    0x83, 0x92, 0x01, 0x89, 0x92, 0x06, 0x88, 0x92,
+    0x8c, 0x3d, 0x00, 0x82, 0x3d, 0x00, 0x96, 0x3d,
+    0x00, 0x89, 0x3d, 0x00, 0x84, 0x3d, 0x01, 0x88,
+    0x3d, 0x00, 0x82, 0x3d, 0x00, 0x83, 0x3d, 0x06,
+    0x81, 0x3d, 0x05, 0x81, 0x3d, 0x00, 0x83, 0x3d,
+    0x01, 0x89, 0x3d, 0x00, 0x81, 0x3d, 0x0c, 0x8c,
+    0x50, 0x00, 0x82, 0x50, 0x00, 0xb2, 0x50, 0x00,
+    0x82, 0x50, 0x00, 0x85, 0x50, 0x03, 0x8f, 0x50,
+    0x01, 0x99, 0x50, 0x00, 0x82, 0x83, 0x00, 0x91,
+    0x83, 0x02, 0x97, 0x83, 0x00, 0x88, 0x83, 0x00,
+    0x80, 0x83, 0x01, 0x86, 0x83, 0x02, 0x80, 0x83,
+    0x03, 0x85, 0x83, 0x00, 0x80, 0x83, 0x00, 0x87,
+    0x83, 0x05, 0x89, 0x83, 0x01, 0x82, 0x83, 0x0b,
+    0xb9, 0x94, 0x03, 0x80, 0x19, 0x9b, 0x94, 0x24,
+    0x81, 0x45, 0x00, 0x80, 0x45, 0x00, 0x84, 0x45,
+    0x00, 0x97, 0x45, 0x00, 0x80, 0x45, 0x00, 0x96,
+    0x45, 0x01, 0x84, 0x45, 0x00, 0x80, 0x45, 0x00,
+    0x85, 0x45, 0x01, 0x89, 0x45, 0x01, 0x83, 0x45,
+    0x1f, 0xc7, 0x95, 0x00, 0xa3, 0x95, 0x03, 0xa6,
+    0x95, 0x00, 0xa3, 0x95, 0x00, 0x8e, 0x95, 0x00,
+    0x86, 0x95, 0x83, 0x19, 0x81, 0x95, 0x24, 0xe0,
+    0x3f, 0x5f, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
+    0x80, 0x28, 0x01, 0xaa, 0x28, 0x80, 0x19, 0x83,
+    0x28, 0xe0, 0x9f, 0x31, 0xc8, 0x27, 0x00, 0x83,
+    0x27, 0x01, 0x86, 0x27, 0x00, 0x80, 0x27, 0x00,
+    0x83, 0x27, 0x01, 0xa8, 0x27, 0x00, 0x83, 0x27,
+    0x01, 0xa0, 0x27, 0x00, 0x83, 0x27, 0x01, 0x86,
+    0x27, 0x00, 0x80, 0x27, 0x00, 0x83, 0x27, 0x01,
+    0x8e, 0x27, 0x00, 0xb8, 0x27, 0x00, 0x83, 0x27,
+    0x01, 0xc2, 0x27, 0x01, 0x9f, 0x27, 0x02, 0x99,
+    0x27, 0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01,
+    0xe2, 0x1f, 0x12, 0x9c, 0x67, 0x02, 0xca, 0x7c,
+    0x82, 0x19, 0x8a, 0x7c, 0x06, 0x95, 0x8a, 0x08,
+    0x80, 0x8a, 0x94, 0x33, 0x81, 0x19, 0x08, 0x93,
+    0x11, 0x0b, 0x8c, 0x8b, 0x00, 0x82, 0x8b, 0x00,
+    0x81, 0x8b, 0x0b, 0xdd, 0x41, 0x01, 0x89, 0x41,
+    0x05, 0x89, 0x41, 0x05, 0x81, 0x5c, 0x81, 0x19,
+    0x80, 0x5c, 0x80, 0x19, 0x93, 0x5c, 0x05, 0xd8,
+    0x5c, 0x06, 0xaa, 0x5c, 0x04, 0xc5, 0x12, 0x09,
+    0x9e, 0x48, 0x00, 0x8b, 0x48, 0x03, 0x8b, 0x48,
+    0x03, 0x80, 0x48, 0x02, 0x8b, 0x48, 0x9d, 0x8c,
+    0x01, 0x84, 0x8c, 0x0a, 0xab, 0x62, 0x03, 0x99,
+    0x62, 0x05, 0x8a, 0x62, 0x02, 0x81, 0x62, 0x9f,
+    0x41, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x8d,
+    0x00, 0x9c, 0x8d, 0x01, 0x8a, 0x8d, 0x05, 0x89,
+    0x8d, 0x05, 0x8d, 0x8d, 0x01, 0x9e, 0x38, 0x30,
+    0xcc, 0x07, 0x02, 0xae, 0x07, 0x00, 0xbf, 0x87,
+    0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x47, 0x02,
+    0x8e, 0x47, 0x02, 0x82, 0x47, 0xaf, 0x68, 0x88,
+    0x1d, 0x06, 0xaa, 0x28, 0x01, 0x82, 0x28, 0x87,
+    0x87, 0x07, 0x82, 0x38, 0x80, 0x19, 0x8c, 0x38,
+    0x80, 0x19, 0x86, 0x38, 0x83, 0x19, 0x80, 0x38,
+    0x85, 0x19, 0x80, 0x38, 0x82, 0x19, 0x81, 0x38,
+    0x80, 0x19, 0x04, 0xa5, 0x46, 0x84, 0x2c, 0x80,
+    0x1d, 0xb0, 0x46, 0x84, 0x2c, 0x83, 0x46, 0x84,
+    0x2c, 0x8c, 0x46, 0x80, 0x1d, 0xc5, 0x46, 0x80,
+    0x2c, 0xbf, 0x38, 0xe0, 0x9f, 0x46, 0x95, 0x2c,
+    0x01, 0x85, 0x2c, 0x01, 0xa5, 0x2c, 0x01, 0x85,
+    0x2c, 0x01, 0x87, 0x2c, 0x00, 0x80, 0x2c, 0x00,
+    0x80, 0x2c, 0x00, 0x80, 0x2c, 0x00, 0x9e, 0x2c,
+    0x01, 0xb4, 0x2c, 0x00, 0x8e, 0x2c, 0x00, 0x8d,
+    0x2c, 0x01, 0x85, 0x2c, 0x00, 0x92, 0x2c, 0x01,
+    0x82, 0x2c, 0x00, 0x88, 0x2c, 0x00, 0x8b, 0x19,
+    0x81, 0x38, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80,
+    0x46, 0x01, 0x8a, 0x19, 0x80, 0x46, 0x8e, 0x19,
+    0x00, 0x8c, 0x46, 0x02, 0xa0, 0x19, 0x0e, 0xa0,
+    0x38, 0x0e, 0xa5, 0x19, 0x80, 0x2c, 0x82, 0x19,
+    0x81, 0x46, 0x85, 0x19, 0x80, 0x46, 0x9a, 0x19,
+    0x80, 0x46, 0x90, 0x19, 0xa8, 0x46, 0x82, 0x19,
+    0x03, 0xe2, 0x36, 0x19, 0x18, 0x8a, 0x19, 0x14,
+    0xe3, 0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13,
+    0x19, 0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19,
+    0xdf, 0x29, 0x9f, 0x46, 0xe0, 0x13, 0x1a, 0x04,
+    0x86, 0x1a, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
+    0x80, 0x28, 0x01, 0xb7, 0x96, 0x06, 0x81, 0x96,
+    0x0d, 0x80, 0x96, 0x96, 0x27, 0x08, 0x86, 0x27,
+    0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x86,
+    0x27, 0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00,
+    0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x9f, 0x1d,
+    0xdd, 0x19, 0x21, 0x99, 0x30, 0x00, 0xd8, 0x30,
+    0x0b, 0xe0, 0x75, 0x30, 0x19, 0x8b, 0x19, 0x03,
+    0x84, 0x19, 0x80, 0x30, 0x80, 0x19, 0x80, 0x30,
+    0x98, 0x19, 0x88, 0x30, 0x83, 0x38, 0x81, 0x31,
+    0x87, 0x19, 0x83, 0x30, 0x83, 0x19, 0x00, 0xd5,
+    0x36, 0x01, 0x81, 0x38, 0x81, 0x19, 0x82, 0x36,
+    0x80, 0x19, 0xd9, 0x3e, 0x81, 0x19, 0x82, 0x3e,
+    0x04, 0xaa, 0x0d, 0x00, 0xdd, 0x31, 0x00, 0x8f,
+    0x19, 0x9f, 0x0d, 0xa3, 0x19, 0x0b, 0x8f, 0x3e,
+    0x9e, 0x31, 0x00, 0xbf, 0x19, 0x9e, 0x31, 0xd0,
+    0x19, 0xae, 0x3e, 0x80, 0x19, 0xd7, 0x3e, 0xe0,
+    0x47, 0x19, 0xf0, 0x09, 0x5f, 0x30, 0xbf, 0x19,
+    0xf0, 0x41, 0x9f, 0x30, 0xe4, 0x2c, 0xa0, 0x02,
+    0xb6, 0xa0, 0x08, 0xaf, 0x4b, 0xe0, 0xcb, 0x9b,
+    0x13, 0xdf, 0x1d, 0xd7, 0x08, 0x07, 0xa1, 0x19,
+    0xe0, 0x05, 0x46, 0x82, 0x19, 0xbf, 0x46, 0x04,
+    0x81, 0x46, 0x00, 0x80, 0x46, 0x00, 0x84, 0x46,
+    0x17, 0x8d, 0x46, 0xac, 0x88, 0x02, 0x89, 0x19,
+    0x05, 0xb7, 0x78, 0x07, 0xc5, 0x7e, 0x07, 0x8b,
+    0x7e, 0x05, 0x9f, 0x20, 0xad, 0x3f, 0x80, 0x19,
+    0x80, 0x3f, 0xa3, 0x7b, 0x0a, 0x80, 0x7b, 0x9c,
+    0x31, 0x02, 0xcd, 0x3b, 0x00, 0x80, 0x19, 0x89,
+    0x3b, 0x03, 0x81, 0x3b, 0x9e, 0x5f, 0x00, 0xb6,
+    0x16, 0x08, 0x8d, 0x16, 0x01, 0x89, 0x16, 0x01,
+    0x83, 0x16, 0x9f, 0x5f, 0xc2, 0x8e, 0x17, 0x84,
+    0x8e, 0x96, 0x56, 0x09, 0x85, 0x27, 0x01, 0x85,
+    0x27, 0x01, 0x85, 0x27, 0x08, 0x86, 0x27, 0x00,
+    0x86, 0x27, 0x00, 0xaa, 0x46, 0x80, 0x19, 0x88,
+    0x46, 0x80, 0x2c, 0x83, 0x46, 0x81, 0x19, 0x03,
+    0xcf, 0x17, 0xad, 0x56, 0x01, 0x89, 0x56, 0x05,
+    0xf0, 0x1b, 0x43, 0x31, 0x0b, 0x96, 0x31, 0x03,
+    0xb0, 0x31, 0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x30,
+    0x01, 0xe0, 0x09, 0x30, 0x25, 0x86, 0x46, 0x0b,
+    0x84, 0x05, 0x04, 0x99, 0x35, 0x00, 0x84, 0x35,
+    0x00, 0x80, 0x35, 0x00, 0x81, 0x35, 0x00, 0x81,
+    0x35, 0x00, 0x89, 0x35, 0xe0, 0x12, 0x04, 0x0f,
+    0xe1, 0x0a, 0x04, 0x81, 0x19, 0xcf, 0x04, 0x01,
+    0xb5, 0x04, 0x06, 0x80, 0x04, 0x1f, 0x8f, 0x04,
+    0x8f, 0x38, 0x89, 0x19, 0x05, 0x8d, 0x38, 0x81,
+    0x1d, 0xa2, 0x19, 0x00, 0x92, 0x19, 0x00, 0x83,
+    0x19, 0x03, 0x84, 0x04, 0x00, 0xe0, 0x26, 0x04,
+    0x01, 0x80, 0x19, 0x00, 0x9f, 0x19, 0x99, 0x46,
+    0x85, 0x19, 0x99, 0x46, 0x8a, 0x19, 0x89, 0x3e,
+    0x80, 0x19, 0xac, 0x3e, 0x81, 0x19, 0x9e, 0x31,
+    0x02, 0x85, 0x31, 0x01, 0x85, 0x31, 0x01, 0x85,
+    0x31, 0x01, 0x82, 0x31, 0x02, 0x86, 0x19, 0x00,
+    0x86, 0x19, 0x09, 0x84, 0x19, 0x01, 0x8b, 0x4a,
+    0x00, 0x99, 0x4a, 0x00, 0x92, 0x4a, 0x00, 0x81,
+    0x4a, 0x00, 0x8e, 0x4a, 0x01, 0x8d, 0x4a, 0x21,
+    0xe0, 0x1a, 0x4a, 0x04, 0x82, 0x19, 0x03, 0xac,
+    0x19, 0x02, 0x88, 0x19, 0xce, 0x2c, 0x00, 0x8c,
+    0x19, 0x02, 0x80, 0x2c, 0x2e, 0xac, 0x19, 0x80,
+    0x38, 0x60, 0x21, 0x9c, 0x4c, 0x02, 0xb0, 0x13,
+    0x0e, 0x80, 0x38, 0x9a, 0x19, 0x03, 0xa3, 0x6a,
+    0x08, 0x82, 0x6a, 0x9a, 0x2a, 0x04, 0xaa, 0x6c,
+    0x04, 0x9d, 0x9a, 0x00, 0x80, 0x9a, 0xa3, 0x6d,
+    0x03, 0x8d, 0x6d, 0x29, 0xcf, 0x1f, 0xaf, 0x80,
+    0x9d, 0x74, 0x01, 0x89, 0x74, 0x05, 0xa3, 0x73,
+    0x03, 0xa3, 0x73, 0x03, 0xa7, 0x25, 0x07, 0xb3,
+    0x14, 0x0a, 0x80, 0x14, 0x8a, 0x9c, 0x00, 0x8e,
+    0x9c, 0x00, 0x86, 0x9c, 0x00, 0x81, 0x9c, 0x00,
+    0x8a, 0x9c, 0x00, 0x8e, 0x9c, 0x00, 0x86, 0x9c,
+    0x00, 0x81, 0x9c, 0x42, 0xe0, 0xd6, 0x49, 0x08,
+    0x95, 0x49, 0x09, 0x87, 0x49, 0x17, 0x85, 0x46,
+    0x00, 0xa9, 0x46, 0x00, 0x88, 0x46, 0x44, 0x85,
+    0x1c, 0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c, 0x00,
+    0x81, 0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80, 0x1c,
+    0x95, 0x37, 0x00, 0x88, 0x37, 0x9f, 0x76, 0x9e,
+    0x60, 0x07, 0x88, 0x60, 0x2f, 0x92, 0x34, 0x00,
+    0x81, 0x34, 0x04, 0x84, 0x34, 0x9b, 0x79, 0x02,
+    0x80, 0x79, 0x99, 0x4d, 0x04, 0x80, 0x4d, 0x3f,
+    0x9f, 0x59, 0x97, 0x58, 0x03, 0x93, 0x58, 0x01,
+    0xad, 0x58, 0x83, 0x40, 0x00, 0x81, 0x40, 0x04,
+    0x87, 0x40, 0x00, 0x82, 0x40, 0x00, 0x9c, 0x40,
+    0x01, 0x82, 0x40, 0x03, 0x89, 0x40, 0x06, 0x88,
+    0x40, 0x06, 0x9f, 0x6f, 0x9f, 0x6b, 0x1f, 0xa6,
+    0x52, 0x03, 0x8b, 0x52, 0x08, 0xb5, 0x06, 0x02,
+    0x86, 0x06, 0x95, 0x3a, 0x01, 0x87, 0x3a, 0x92,
+    0x39, 0x04, 0x87, 0x39, 0x91, 0x7a, 0x06, 0x83,
+    0x7a, 0x0b, 0x86, 0x7a, 0x4f, 0xc8, 0x70, 0x36,
+    0xb2, 0x69, 0x0c, 0xb2, 0x69, 0x06, 0x85, 0x69,
+    0xa7, 0x32, 0x07, 0x89, 0x32, 0x60, 0xc5, 0x9e,
+    0x04, 0x00, 0xa9, 0x9f, 0x00, 0x82, 0x9f, 0x01,
+    0x81, 0x9f, 0x4d, 0xa7, 0x6e, 0x07, 0xa9, 0x84,
+    0x15, 0x99, 0x71, 0x25, 0x9b, 0x18, 0x13, 0x96,
+    0x26, 0x08, 0xcd, 0x0e, 0x03, 0xa3, 0x0e, 0x08,
+    0x80, 0x0e, 0xc2, 0x3c, 0x09, 0x80, 0x3c, 0x01,
+    0x98, 0x85, 0x06, 0x89, 0x85, 0x05, 0xb4, 0x15,
+    0x00, 0x91, 0x15, 0x07, 0xa6, 0x4f, 0x08, 0xdf,
+    0x7f, 0x00, 0x93, 0x83, 0x0a, 0x91, 0x42, 0x00,
+    0xab, 0x42, 0x40, 0x86, 0x5e, 0x00, 0x80, 0x5e,
+    0x00, 0x83, 0x5e, 0x00, 0x8e, 0x5e, 0x00, 0x8a,
+    0x5e, 0x05, 0xba, 0x44, 0x04, 0x89, 0x44, 0x05,
+    0x83, 0x2b, 0x00, 0x87, 0x2b, 0x01, 0x81, 0x2b,
+    0x01, 0x95, 0x2b, 0x00, 0x86, 0x2b, 0x00, 0x81,
+    0x2b, 0x00, 0x84, 0x2b, 0x00, 0x80, 0x38, 0x88,
+    0x2b, 0x01, 0x81, 0x2b, 0x01, 0x82, 0x2b, 0x01,
+    0x80, 0x2b, 0x05, 0x80, 0x2b, 0x04, 0x86, 0x2b,
+    0x01, 0x86, 0x2b, 0x02, 0x84, 0x2b, 0x60, 0x2a,
+    0xdb, 0x63, 0x00, 0x84, 0x63, 0x1d, 0xc7, 0x97,
+    0x07, 0x89, 0x97, 0x60, 0x45, 0xb5, 0x81, 0x01,
+    0xa5, 0x81, 0x21, 0xc4, 0x5b, 0x0a, 0x89, 0x5b,
+    0x05, 0x8c, 0x5c, 0x12, 0xb9, 0x8f, 0x05, 0x89,
+    0x8f, 0x35, 0x9a, 0x02, 0x01, 0x8e, 0x02, 0x03,
+    0x96, 0x02, 0x60, 0x58, 0xbb, 0x22, 0x60, 0x03,
+    0xd2, 0x9e, 0x0b, 0x80, 0x9e, 0x86, 0x21, 0x01,
+    0x80, 0x21, 0x01, 0x87, 0x21, 0x00, 0x81, 0x21,
+    0x00, 0x9d, 0x21, 0x00, 0x81, 0x21, 0x01, 0x8b,
+    0x21, 0x08, 0x89, 0x21, 0x45, 0x87, 0x61, 0x01,
+    0xad, 0x61, 0x01, 0x8a, 0x61, 0x1a, 0xc7, 0xa1,
+    0x07, 0xd2, 0x86, 0x0c, 0x8f, 0x12, 0xb8, 0x77,
+    0x60, 0xa6, 0x88, 0x0c, 0x00, 0xac, 0x0c, 0x00,
+    0x8d, 0x0c, 0x09, 0x9c, 0x0c, 0x02, 0x9f, 0x53,
+    0x01, 0x95, 0x53, 0x00, 0x8d, 0x53, 0x48, 0x86,
+    0x54, 0x00, 0x81, 0x54, 0x00, 0xab, 0x54, 0x02,
+    0x80, 0x54, 0x00, 0x81, 0x54, 0x00, 0x88, 0x54,
+    0x07, 0x89, 0x54, 0x05, 0x85, 0x2e, 0x00, 0x81,
+    0x2e, 0x00, 0xa4, 0x2e, 0x00, 0x81, 0x2e, 0x00,
+    0x85, 0x2e, 0x06, 0x89, 0x2e, 0x60, 0xd5, 0x98,
+    0x4e, 0x60, 0x56, 0x80, 0x4b, 0x0e, 0xb1, 0x90,
+    0x0c, 0x80, 0x90, 0xe3, 0x39, 0x1b, 0x60, 0x05,
+    0xe0, 0x0e, 0x1b, 0x00, 0x84, 0x1b, 0x0a, 0xe0,
+    0x63, 0x1b, 0x69, 0xeb, 0xe0, 0x02, 0x1e, 0x0c,
+    0xe3, 0xce, 0x24, 0x00, 0x88, 0x24, 0x6f, 0x66,
+    0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8,
+    0x08, 0x06, 0x9e, 0x5d, 0x00, 0x89, 0x5d, 0x03,
+    0x81, 0x5d, 0xce, 0x98, 0x00, 0x89, 0x98, 0x05,
+    0x9d, 0x09, 0x01, 0x85, 0x09, 0x09, 0xc5, 0x75,
+    0x09, 0x89, 0x75, 0x00, 0x86, 0x75, 0x00, 0x94,
+    0x75, 0x04, 0x92, 0x75, 0x62, 0x4f, 0xda, 0x55,
+    0x60, 0x04, 0xca, 0x5a, 0x03, 0xb8, 0x5a, 0x06,
+    0x90, 0x5a, 0x3f, 0x80, 0x91, 0x80, 0x65, 0x81,
+    0x30, 0x80, 0x43, 0x0a, 0x81, 0x30, 0x0d, 0xf0,
+    0x07, 0x97, 0x91, 0x07, 0xe2, 0x9f, 0x91, 0xe1,
+    0x75, 0x43, 0x29, 0x88, 0x91, 0x70, 0x12, 0x86,
+    0x83, 0x3e, 0x00, 0x86, 0x3e, 0x00, 0x81, 0x3e,
+    0x00, 0x80, 0x3e, 0xe0, 0xbe, 0x36, 0x82, 0x3e,
+    0x2c, 0x82, 0x36, 0x10, 0x83, 0x3e, 0x07, 0xe1,
+    0x2b, 0x65, 0x68, 0xa3, 0xe0, 0x0a, 0x23, 0x04,
+    0x8c, 0x23, 0x02, 0x88, 0x23, 0x06, 0x89, 0x23,
+    0x01, 0x83, 0x23, 0x83, 0x19, 0x70, 0x01, 0xfb,
+    0xad, 0x38, 0x01, 0x96, 0x38, 0x08, 0xe0, 0x13,
+    0x19, 0x3b, 0xe0, 0x95, 0x19, 0x09, 0xa6, 0x19,
+    0x01, 0xbd, 0x19, 0x82, 0x38, 0x90, 0x19, 0x87,
+    0x38, 0x81, 0x19, 0x86, 0x38, 0x9d, 0x19, 0x83,
+    0x38, 0xbc, 0x19, 0x14, 0xc5, 0x2c, 0x60, 0x39,
+    0x93, 0x19, 0x0b, 0xd6, 0x19, 0x08, 0x98, 0x19,
+    0x60, 0x26, 0xd4, 0x19, 0x00, 0xc6, 0x19, 0x00,
+    0x81, 0x19, 0x01, 0x80, 0x19, 0x01, 0x81, 0x19,
+    0x01, 0x83, 0x19, 0x00, 0x8b, 0x19, 0x00, 0x80,
+    0x19, 0x00, 0x86, 0x19, 0x00, 0xc0, 0x19, 0x00,
+    0x83, 0x19, 0x01, 0x87, 0x19, 0x00, 0x86, 0x19,
+    0x00, 0x9b, 0x19, 0x00, 0x83, 0x19, 0x00, 0x84,
+    0x19, 0x00, 0x80, 0x19, 0x02, 0x86, 0x19, 0x00,
+    0xe0, 0xf3, 0x19, 0x01, 0xe0, 0xc3, 0x19, 0x01,
+    0xb1, 0x19, 0xe2, 0x2b, 0x82, 0x0e, 0x84, 0x82,
+    0x00, 0x8e, 0x82, 0x63, 0xef, 0x9e, 0x46, 0x60,
+    0x80, 0x86, 0x29, 0x00, 0x90, 0x29, 0x01, 0x86,
+    0x29, 0x00, 0x81, 0x29, 0x00, 0x84, 0x29, 0x60,
+    0x74, 0xac, 0x66, 0x02, 0x8d, 0x66, 0x01, 0x89,
+    0x66, 0x03, 0x81, 0x66, 0x60, 0xdf, 0x9e, 0x99,
+    0x10, 0xb9, 0x9d, 0x04, 0x80, 0x9d, 0x64, 0x7f,
+    0x86, 0x27, 0x00, 0x83, 0x27, 0x00, 0x81, 0x27,
+    0x00, 0x8e, 0x27, 0x00, 0xe0, 0x64, 0x57, 0x01,
+    0x8f, 0x57, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
+    0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19, 0x4b,
+    0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a,
+    0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
+    0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83, 0x04,
+    0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05, 0x80,
+    0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
+    0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81, 0x04,
+    0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00, 0x80,
+    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
+    0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
+    0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00, 0x83,
+    0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04, 0x00,
+    0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82, 0x04,
+    0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33, 0x81,
+    0x04, 0x60, 0xad, 0xab, 0x19, 0x03, 0xe0, 0x03,
+    0x19, 0x0b, 0x8e, 0x19, 0x01, 0x8e, 0x19, 0x00,
+    0x8e, 0x19, 0x00, 0xa4, 0x19, 0x09, 0xe0, 0x4d,
+    0x19, 0x37, 0x99, 0x19, 0x80, 0x36, 0x81, 0x19,
+    0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06, 0x81,
+    0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3, 0x77,
+    0x19, 0x04, 0x8f, 0x19, 0x02, 0x8c, 0x19, 0x02,
+    0xe0, 0x13, 0x19, 0x0b, 0xd8, 0x19, 0x06, 0x8b,
+    0x19, 0x03, 0x80, 0x19, 0x0e, 0x8b, 0x19, 0x03,
+    0xb7, 0x19, 0x07, 0x89, 0x19, 0x05, 0xa7, 0x19,
+    0x07, 0x9d, 0x19, 0x01, 0x81, 0x19, 0x4d, 0xe0,
+    0xf3, 0x19, 0x0b, 0x8d, 0x19, 0x01, 0x84, 0x19,
+    0x02, 0x84, 0x19, 0x02, 0x86, 0x19, 0x08, 0x9c,
+    0x19, 0x02, 0x8a, 0x19, 0x04, 0x85, 0x19, 0x09,
+    0x89, 0x19, 0x05, 0x87, 0x19, 0x07, 0x86, 0x19,
+    0x08, 0xe0, 0x32, 0x19, 0x00, 0xb6, 0x19, 0x24,
+    0x89, 0x19, 0x63, 0xa5, 0xf0, 0x96, 0x7f, 0x30,
+    0x1f, 0xef, 0xd8, 0x30, 0x06, 0xe0, 0x7d, 0x30,
+    0x01, 0xf0, 0x06, 0x21, 0x30, 0x0d, 0xf0, 0x0c,
+    0xd0, 0x30, 0x6b, 0xbe, 0xe1, 0xbd, 0x30, 0x65,
+    0x81, 0xf0, 0x02, 0xea, 0x30, 0x7a, 0xdc, 0x55,
+    0x80, 0x19, 0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0,
+    0x8f, 0x38,
 };
 
-static const uint8_t unicode_script_ext_table[799] = {
-    0x82, 0xc1, 0x00, 0x00, 0x01, 0x2b, 0x01, 0x00,
-    0x00, 0x01, 0x2b, 0x1c, 0x00, 0x0c, 0x01, 0x45,
-    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6b, 0x00,
-    0x02, 0x1d, 0x28, 0x01, 0x02, 0x1d, 0x45, 0x00,
-    0x02, 0x1d, 0x28, 0x81, 0x03, 0x00, 0x00, 0x05,
-    0x04, 0x31, 0x87, 0x91, 0x9a, 0x0d, 0x00, 0x00,
-    0x05, 0x04, 0x31, 0x87, 0x91, 0x9a, 0x00, 0x03,
-    0x04, 0x87, 0x91, 0x01, 0x00, 0x00, 0x05, 0x04,
-    0x31, 0x87, 0x91, 0x9a, 0x1f, 0x00, 0x00, 0x08,
-    0x01, 0x04, 0x50, 0x51, 0x78, 0x31, 0x82, 0x87,
-    0x09, 0x00, 0x0a, 0x02, 0x04, 0x87, 0x09, 0x00,
-    0x09, 0x03, 0x04, 0x91, 0x9a, 0x05, 0x00, 0x00,
-    0x02, 0x04, 0x87, 0x62, 0x00, 0x00, 0x02, 0x04,
-    0x31, 0x81, 0xfb, 0x00, 0x00, 0x0d, 0x0b, 0x1f,
-    0x2a, 0x2c, 0x2e, 0x3c, 0x45, 0x4f, 0x70, 0x7d,
-    0x8e, 0x90, 0x95, 0x00, 0x0c, 0x0b, 0x1f, 0x2a,
-    0x2c, 0x2e, 0x3c, 0x45, 0x4f, 0x70, 0x8e, 0x90,
-    0x95, 0x10, 0x00, 0x00, 0x14, 0x0b, 0x1f, 0x21,
-    0x2d, 0x53, 0x2a, 0x2c, 0x2e, 0x3c, 0x4e, 0x4f,
-    0x60, 0x70, 0x43, 0x81, 0x86, 0x8d, 0x8e, 0x90,
-    0x95, 0x00, 0x15, 0x0b, 0x1f, 0x21, 0x2d, 0x53,
-    0x2a, 0x2c, 0x2e, 0x3c, 0x47, 0x4e, 0x4f, 0x60,
-    0x70, 0x43, 0x81, 0x86, 0x8d, 0x8e, 0x90, 0x95,
-    0x09, 0x04, 0x1f, 0x21, 0x3b, 0x4e, 0x75, 0x00,
-    0x09, 0x03, 0x0b, 0x15, 0x86, 0x75, 0x00, 0x09,
-    0x02, 0x2e, 0x5d, 0x75, 0x00, 0x09, 0x02, 0x2c,
-    0x41, 0x80, 0x75, 0x00, 0x0d, 0x02, 0x2a, 0x8e,
-    0x80, 0x71, 0x00, 0x09, 0x02, 0x3c, 0x60, 0x82,
-    0xcf, 0x00, 0x09, 0x03, 0x15, 0x5e, 0x8a, 0x80,
-    0x30, 0x00, 0x00, 0x02, 0x27, 0x45, 0x85, 0xb8,
-    0x00, 0x01, 0x04, 0x11, 0x32, 0x89, 0x88, 0x80,
-    0x4a, 0x00, 0x01, 0x02, 0x5b, 0x76, 0x00, 0x00,
-    0x00, 0x02, 0x5b, 0x76, 0x84, 0x49, 0x00, 0x00,
-    0x04, 0x0b, 0x1f, 0x2a, 0x3c, 0x00, 0x01, 0x1f,
-    0x00, 0x04, 0x0b, 0x1f, 0x2a, 0x3c, 0x00, 0x02,
-    0x1f, 0x2a, 0x00, 0x01, 0x1f, 0x01, 0x02, 0x0b,
-    0x1f, 0x00, 0x02, 0x1f, 0x7d, 0x00, 0x02, 0x0b,
-    0x1f, 0x00, 0x02, 0x1f, 0x7d, 0x00, 0x06, 0x1f,
-    0x3c, 0x4f, 0x70, 0x8e, 0x90, 0x00, 0x01, 0x1f,
-    0x01, 0x02, 0x1f, 0x7d, 0x01, 0x01, 0x1f, 0x00,
-    0x02, 0x1f, 0x7d, 0x00, 0x02, 0x0b, 0x1f, 0x06,
-    0x01, 0x1f, 0x00, 0x02, 0x1f, 0x60, 0x00, 0x02,
-    0x0b, 0x1f, 0x01, 0x01, 0x1f, 0x00, 0x02, 0x0b,
-    0x1f, 0x03, 0x01, 0x1f, 0x00, 0x08, 0x0b, 0x1f,
-    0x2a, 0x3c, 0x60, 0x70, 0x90, 0x95, 0x00, 0x02,
-    0x1f, 0x2a, 0x00, 0x03, 0x1f, 0x2a, 0x3c, 0x01,
-    0x02, 0x0b, 0x1f, 0x00, 0x01, 0x0b, 0x01, 0x02,
-    0x1f, 0x2a, 0x00, 0x01, 0x60, 0x80, 0x44, 0x00,
-    0x01, 0x01, 0x2b, 0x35, 0x00, 0x00, 0x02, 0x1d,
-    0x87, 0x81, 0xb5, 0x00, 0x00, 0x02, 0x45, 0x5b,
-    0x80, 0x3f, 0x00, 0x00, 0x03, 0x1f, 0x2a, 0x45,
-    0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d, 0x28, 0x81,
-    0x3c, 0x00, 0x01, 0x06, 0x0d, 0x30, 0x2f, 0x35,
-    0x3d, 0x9b, 0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35,
-    0x3d, 0x01, 0x00, 0x00, 0x01, 0x2f, 0x00, 0x00,
-    0x09, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x9b,
-    0x00, 0x00, 0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35,
-    0x3d, 0x07, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
-    0x9b, 0x03, 0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
-    0x09, 0x00, 0x03, 0x02, 0x0d, 0x2f, 0x01, 0x00,
-    0x00, 0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x04,
-    0x02, 0x35, 0x3d, 0x00, 0x00, 0x00, 0x05, 0x0d,
-    0x30, 0x2f, 0x35, 0x3d, 0x03, 0x00, 0x01, 0x03,
-    0x2f, 0x35, 0x3d, 0x01, 0x01, 0x2f, 0x58, 0x00,
-    0x03, 0x02, 0x35, 0x3d, 0x02, 0x00, 0x00, 0x02,
-    0x35, 0x3d, 0x59, 0x00, 0x00, 0x06, 0x0d, 0x30,
-    0x2f, 0x35, 0x3d, 0x9b, 0x00, 0x02, 0x35, 0x3d,
-    0x80, 0x12, 0x00, 0x0f, 0x01, 0x2f, 0x1f, 0x00,
-    0x23, 0x01, 0x2f, 0x3b, 0x00, 0x27, 0x01, 0x2f,
-    0x37, 0x00, 0x30, 0x01, 0x2f, 0x0e, 0x00, 0x0b,
-    0x01, 0x2f, 0x32, 0x00, 0x00, 0x01, 0x2f, 0x57,
-    0x00, 0x18, 0x01, 0x2f, 0x09, 0x00, 0x04, 0x01,
-    0x2f, 0x5f, 0x00, 0x1e, 0x01, 0x2f, 0xc0, 0x31,
-    0xef, 0x00, 0x00, 0x02, 0x1d, 0x28, 0x80, 0x0f,
-    0x00, 0x07, 0x02, 0x2f, 0x45, 0x80, 0xa7, 0x00,
-    0x02, 0x0e, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3c,
-    0x3b, 0x4e, 0x4f, 0x5a, 0x60, 0x43, 0x8d, 0x95,
-    0x02, 0x0d, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3c,
-    0x3b, 0x4e, 0x5a, 0x60, 0x43, 0x8d, 0x95, 0x03,
-    0x0b, 0x1f, 0x21, 0x2c, 0x2e, 0x41, 0x3b, 0x4e,
-    0x5a, 0x43, 0x8d, 0x95, 0x80, 0x36, 0x00, 0x00,
-    0x02, 0x0b, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x1f,
-    0x8e, 0x39, 0x00, 0x00, 0x03, 0x3e, 0x45, 0x5e,
-    0x80, 0x1f, 0x00, 0x00, 0x02, 0x10, 0x3a, 0xc0,
-    0x13, 0xa1, 0x00, 0x00, 0x02, 0x04, 0x91, 0x09,
-    0x00, 0x00, 0x02, 0x04, 0x91, 0x46, 0x00, 0x01,
-    0x05, 0x0d, 0x30, 0x2f, 0x35, 0x3d, 0x80, 0x99,
-    0x00, 0x04, 0x06, 0x0d, 0x30, 0x2f, 0x35, 0x3d,
-    0x9b, 0x09, 0x00, 0x00, 0x02, 0x35, 0x3d, 0x2c,
-    0x00, 0x01, 0x02, 0x35, 0x3d, 0x80, 0xdf, 0x00,
-    0x02, 0x02, 0x1c, 0x49, 0x03, 0x00, 0x2c, 0x03,
-    0x1c, 0x48, 0x49, 0x02, 0x00, 0x08, 0x02, 0x1c,
-    0x49, 0x81, 0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a,
-    0x8f, 0x84, 0x00, 0x00, 0x02, 0x2a, 0x8e, 0x00,
-    0x00, 0x00, 0x02, 0x2a, 0x8e, 0x36, 0x00, 0x01,
-    0x02, 0x2a, 0x8e, 0x8c, 0x12, 0x00, 0x01, 0x02,
-    0x2a, 0x8e, 0x00, 0x00, 0x00, 0x02, 0x2a, 0x8e,
-    0xc0, 0x5c, 0x4b, 0x00, 0x03, 0x01, 0x22, 0x96,
-    0x3b, 0x00, 0x11, 0x01, 0x2f, 0x9e, 0x5d, 0x00,
-    0x01, 0x01, 0x2f, 0xce, 0xcd, 0x2d, 0x00,
+static const uint8_t unicode_script_ext_table[828] = {
+    0x82, 0xc1, 0x00, 0x00, 0x01, 0x2c, 0x01, 0x00,
+    0x00, 0x01, 0x2c, 0x1c, 0x00, 0x0c, 0x01, 0x46,
+    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6c, 0x00,
+    0x02, 0x1d, 0x29, 0x01, 0x02, 0x1d, 0x46, 0x00,
+    0x02, 0x1d, 0x29, 0x81, 0x03, 0x00, 0x00, 0x06,
+    0x04, 0x64, 0x32, 0x89, 0x93, 0x9f, 0x0d, 0x00,
+    0x00, 0x06, 0x04, 0x64, 0x32, 0x89, 0x93, 0x9f,
+    0x00, 0x03, 0x04, 0x89, 0x93, 0x01, 0x00, 0x00,
+    0x07, 0x01, 0x04, 0x64, 0x32, 0x89, 0x93, 0x9f,
+    0x1f, 0x00, 0x00, 0x09, 0x01, 0x04, 0x51, 0x52,
+    0x71, 0x7a, 0x32, 0x84, 0x89, 0x09, 0x00, 0x0a,
+    0x02, 0x04, 0x89, 0x09, 0x00, 0x09, 0x03, 0x04,
+    0x93, 0x9f, 0x05, 0x00, 0x00, 0x02, 0x04, 0x89,
+    0x62, 0x00, 0x00, 0x02, 0x04, 0x32, 0x81, 0xfb,
+    0x00, 0x00, 0x0d, 0x0b, 0x20, 0x2b, 0x2d, 0x2f,
+    0x3d, 0x46, 0x50, 0x72, 0x7f, 0x90, 0x92, 0x97,
+    0x00, 0x0c, 0x0b, 0x20, 0x2b, 0x2d, 0x2f, 0x3d,
+    0x46, 0x50, 0x72, 0x90, 0x92, 0x97, 0x10, 0x00,
+    0x00, 0x14, 0x0b, 0x20, 0x22, 0x2e, 0x54, 0x2b,
+    0x2d, 0x2f, 0x3d, 0x4f, 0x50, 0x61, 0x72, 0x44,
+    0x83, 0x88, 0x8f, 0x90, 0x92, 0x97, 0x00, 0x15,
+    0x0b, 0x20, 0x22, 0x2e, 0x54, 0x2b, 0x2d, 0x2f,
+    0x3d, 0x48, 0x4f, 0x50, 0x61, 0x72, 0x44, 0x83,
+    0x88, 0x8f, 0x90, 0x92, 0x97, 0x09, 0x04, 0x20,
+    0x22, 0x3c, 0x4f, 0x75, 0x00, 0x09, 0x03, 0x0b,
+    0x15, 0x88, 0x75, 0x00, 0x09, 0x02, 0x2f, 0x5e,
+    0x75, 0x00, 0x09, 0x02, 0x2d, 0x42, 0x80, 0x75,
+    0x00, 0x0d, 0x02, 0x2b, 0x90, 0x80, 0x71, 0x00,
+    0x09, 0x02, 0x3d, 0x61, 0x82, 0xcf, 0x00, 0x09,
+    0x03, 0x15, 0x5f, 0x8c, 0x80, 0x30, 0x00, 0x00,
+    0x02, 0x28, 0x46, 0x85, 0xb8, 0x00, 0x01, 0x04,
+    0x11, 0x33, 0x8b, 0x8a, 0x80, 0x4a, 0x00, 0x01,
+    0x02, 0x5c, 0x78, 0x00, 0x00, 0x00, 0x02, 0x5c,
+    0x78, 0x84, 0x49, 0x00, 0x00, 0x04, 0x0b, 0x20,
+    0x2b, 0x3d, 0x00, 0x01, 0x20, 0x00, 0x04, 0x0b,
+    0x20, 0x2b, 0x3d, 0x00, 0x02, 0x20, 0x2b, 0x00,
+    0x01, 0x20, 0x01, 0x02, 0x0b, 0x20, 0x00, 0x02,
+    0x20, 0x7f, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x02,
+    0x20, 0x7f, 0x00, 0x06, 0x20, 0x3d, 0x50, 0x72,
+    0x90, 0x92, 0x00, 0x01, 0x20, 0x01, 0x02, 0x20,
+    0x7f, 0x01, 0x01, 0x20, 0x00, 0x02, 0x20, 0x7f,
+    0x00, 0x02, 0x0b, 0x20, 0x06, 0x01, 0x20, 0x00,
+    0x02, 0x20, 0x61, 0x00, 0x02, 0x0b, 0x20, 0x01,
+    0x01, 0x20, 0x00, 0x02, 0x0b, 0x20, 0x03, 0x01,
+    0x20, 0x00, 0x08, 0x0b, 0x20, 0x2b, 0x3d, 0x61,
+    0x72, 0x92, 0x97, 0x00, 0x02, 0x20, 0x2b, 0x00,
+    0x03, 0x20, 0x2b, 0x3d, 0x01, 0x02, 0x0b, 0x20,
+    0x00, 0x01, 0x0b, 0x01, 0x02, 0x20, 0x2b, 0x00,
+    0x01, 0x61, 0x80, 0x44, 0x00, 0x01, 0x01, 0x2c,
+    0x35, 0x00, 0x00, 0x02, 0x1d, 0x89, 0x00, 0x00,
+    0x00, 0x01, 0x89, 0x81, 0xb3, 0x00, 0x00, 0x02,
+    0x46, 0x5c, 0x80, 0x3f, 0x00, 0x00, 0x03, 0x20,
+    0x2b, 0x46, 0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d,
+    0x29, 0x81, 0x3c, 0x00, 0x01, 0x06, 0x0d, 0x31,
+    0x30, 0x36, 0x3e, 0xa0, 0x00, 0x05, 0x0d, 0x31,
+    0x30, 0x36, 0x3e, 0x01, 0x00, 0x00, 0x01, 0x30,
+    0x00, 0x00, 0x09, 0x06, 0x0d, 0x31, 0x30, 0x36,
+    0x3e, 0xa0, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x31,
+    0x30, 0x36, 0x3e, 0x07, 0x06, 0x0d, 0x31, 0x30,
+    0x36, 0x3e, 0xa0, 0x03, 0x05, 0x0d, 0x31, 0x30,
+    0x36, 0x3e, 0x09, 0x00, 0x03, 0x02, 0x0d, 0x30,
+    0x01, 0x00, 0x00, 0x05, 0x0d, 0x31, 0x30, 0x36,
+    0x3e, 0x04, 0x02, 0x36, 0x3e, 0x00, 0x00, 0x00,
+    0x05, 0x0d, 0x31, 0x30, 0x36, 0x3e, 0x03, 0x00,
+    0x01, 0x03, 0x30, 0x36, 0x3e, 0x01, 0x01, 0x30,
+    0x58, 0x00, 0x03, 0x02, 0x36, 0x3e, 0x02, 0x00,
+    0x00, 0x02, 0x36, 0x3e, 0x59, 0x00, 0x00, 0x06,
+    0x0d, 0x31, 0x30, 0x36, 0x3e, 0xa0, 0x00, 0x02,
+    0x36, 0x3e, 0x80, 0x12, 0x00, 0x0f, 0x01, 0x30,
+    0x1f, 0x00, 0x23, 0x01, 0x30, 0x3b, 0x00, 0x27,
+    0x01, 0x30, 0x37, 0x00, 0x30, 0x01, 0x30, 0x0e,
+    0x00, 0x0b, 0x01, 0x30, 0x32, 0x00, 0x00, 0x01,
+    0x30, 0x57, 0x00, 0x18, 0x01, 0x30, 0x09, 0x00,
+    0x04, 0x01, 0x30, 0x5f, 0x00, 0x1e, 0x01, 0x30,
+    0xc0, 0x31, 0xef, 0x00, 0x00, 0x02, 0x1d, 0x29,
+    0x80, 0x0f, 0x00, 0x07, 0x02, 0x30, 0x46, 0x80,
+    0xa7, 0x00, 0x02, 0x0e, 0x20, 0x22, 0x2d, 0x2f,
+    0x42, 0x3d, 0x3c, 0x4f, 0x50, 0x5b, 0x61, 0x44,
+    0x8f, 0x97, 0x02, 0x0d, 0x20, 0x22, 0x2d, 0x2f,
+    0x42, 0x3d, 0x3c, 0x4f, 0x5b, 0x61, 0x44, 0x8f,
+    0x97, 0x03, 0x0b, 0x20, 0x22, 0x2d, 0x2f, 0x42,
+    0x3c, 0x4f, 0x5b, 0x44, 0x8f, 0x97, 0x80, 0x36,
+    0x00, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x00, 0x00,
+    0x02, 0x20, 0x90, 0x39, 0x00, 0x00, 0x03, 0x3f,
+    0x46, 0x5f, 0x80, 0x1f, 0x00, 0x00, 0x02, 0x10,
+    0x3b, 0xc0, 0x12, 0xed, 0x00, 0x01, 0x02, 0x04,
+    0x64, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04, 0x93,
+    0x09, 0x00, 0x00, 0x02, 0x04, 0x93, 0x46, 0x00,
+    0x01, 0x05, 0x0d, 0x31, 0x30, 0x36, 0x3e, 0x80,
+    0x99, 0x00, 0x04, 0x06, 0x0d, 0x31, 0x30, 0x36,
+    0x3e, 0xa0, 0x09, 0x00, 0x00, 0x02, 0x36, 0x3e,
+    0x2c, 0x00, 0x01, 0x02, 0x36, 0x3e, 0x80, 0xdf,
+    0x00, 0x01, 0x03, 0x1e, 0x1c, 0x4a, 0x00, 0x02,
+    0x1c, 0x4a, 0x03, 0x00, 0x2c, 0x03, 0x1c, 0x49,
+    0x4a, 0x02, 0x00, 0x08, 0x02, 0x1c, 0x4a, 0x81,
+    0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a, 0x87, 0x75,
+    0x00, 0x00, 0x02, 0x52, 0x71, 0x87, 0x8d, 0x00,
+    0x00, 0x02, 0x2b, 0x90, 0x00, 0x00, 0x00, 0x02,
+    0x2b, 0x90, 0x36, 0x00, 0x01, 0x02, 0x2b, 0x90,
+    0x8c, 0x12, 0x00, 0x01, 0x02, 0x2b, 0x90, 0x00,
+    0x00, 0x00, 0x02, 0x2b, 0x90, 0xc0, 0x5c, 0x4b,
+    0x00, 0x03, 0x01, 0x23, 0x96, 0x3b, 0x00, 0x11,
+    0x01, 0x30, 0x9e, 0x5d, 0x00, 0x01, 0x01, 0x30,
+    0xce, 0xcd, 0x2d, 0x00,
 };
 
 static const uint8_t unicode_prop_Hyphen_table[28] = {
@@ -3544,7 +3616,7 @@ static const uint8_t unicode_prop_Other_Math_table[200] = {
     0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
 };
 
-static const uint8_t unicode_prop_Other_Alphabetic_table[411] = {
+static const uint8_t unicode_prop_Other_Alphabetic_table[417] = {
     0x43, 0x44, 0x80, 0x42, 0x69, 0x8d, 0x00, 0x01,
     0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c, 0x06, 0x8f,
     0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80,
@@ -3568,45 +3640,47 @@ static const uint8_t unicode_prop_Other_Alphabetic_table[411] = {
     0x89, 0x83, 0x46, 0x73, 0x81, 0x9d, 0x81, 0x9d,
     0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40, 0xbb, 0x81,
     0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88, 0x40, 0xdd,
-    0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9, 0x81, 0xbe,
-    0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09,
-    0xb8, 0x8a, 0xb1, 0x92, 0x41, 0xaf, 0x8d, 0x46,
-    0xc0, 0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73,
-    0x87, 0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96,
-    0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80,
-    0xa5, 0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b,
-    0xa4, 0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac,
-    0x82, 0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24,
-    0x80, 0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80,
-    0x48, 0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83,
-    0x43, 0x13, 0x83, 0x41, 0x82, 0x81, 0x41, 0x52,
-    0x82, 0xb4, 0x8d, 0xbb, 0x80, 0xac, 0x88, 0xc6,
-    0x82, 0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf,
-    0x8c, 0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x40,
-    0x9f, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09, 0x81,
-    0x89, 0x80, 0x89, 0x81, 0x40, 0xd0, 0x8c, 0x02,
-    0xe9, 0x91, 0x40, 0xec, 0x31, 0x86, 0x9c, 0x81,
-    0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6, 0x8d, 0x41,
-    0x00, 0x8c, 0x40, 0xf6, 0x28, 0x09, 0x0a, 0x00,
-    0x80, 0x40, 0x8d, 0x31, 0x2b, 0x80, 0x9b, 0x89,
-    0xa9, 0x20, 0x83, 0x91, 0x8a, 0xad, 0x8d, 0x41,
-    0x96, 0x38, 0x86, 0xd2, 0x95, 0x80, 0x8d, 0xf9,
-    0x2a, 0x00, 0x08, 0x10, 0x02, 0x80, 0xc1, 0x20,
-    0x08, 0x83, 0x41, 0x5b, 0x83, 0x60, 0x50, 0x57,
-    0x00, 0xb6, 0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab,
-    0x80, 0x60, 0x23, 0x60, 0x30, 0x90, 0x0e, 0x01,
-    0x04, 0x49, 0x1b, 0x80, 0x47, 0xe7, 0x99, 0x85,
-    0x99, 0x85, 0x99,
+    0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9, 0x81, 0x8a,
+    0x82, 0xb0, 0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d,
+    0x88, 0x09, 0xb8, 0x8a, 0xb1, 0x92, 0x41, 0xaf,
+    0x8d, 0x46, 0xc0, 0xb3, 0x48, 0xf5, 0x9f, 0x60,
+    0x78, 0x73, 0x87, 0xa1, 0x81, 0x41, 0x61, 0x07,
+    0x80, 0x96, 0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00,
+    0xb8, 0x80, 0xa5, 0x84, 0x9b, 0x8b, 0xac, 0x83,
+    0xaf, 0x8b, 0xa4, 0x80, 0xc2, 0x8d, 0x8b, 0x07,
+    0x81, 0xac, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x80,
+    0xab, 0x24, 0x80, 0x40, 0xec, 0x87, 0x60, 0x4f,
+    0x32, 0x80, 0x48, 0x56, 0x84, 0x46, 0x85, 0x10,
+    0x0c, 0x83, 0x43, 0x13, 0x83, 0x41, 0x82, 0x81,
+    0x41, 0x52, 0x82, 0xb4, 0x8d, 0xac, 0x81, 0x8c,
+    0x80, 0xac, 0x88, 0x88, 0x80, 0xbc, 0x82, 0xa3,
+    0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf, 0x8c, 0x8d,
+    0x81, 0xdb, 0x88, 0x08, 0x28, 0x40, 0x9f, 0x89,
+    0x96, 0x83, 0xb9, 0x31, 0x09, 0x81, 0x89, 0x80,
+    0x89, 0x81, 0x40, 0xd0, 0x8c, 0x02, 0xe9, 0x91,
+    0x40, 0xec, 0x31, 0x86, 0x9c, 0x81, 0xd1, 0x8e,
+    0x00, 0xe9, 0x8a, 0xe6, 0x8d, 0x41, 0x00, 0x8c,
+    0x40, 0xf6, 0x28, 0x09, 0x0a, 0x00, 0x80, 0x40,
+    0x8d, 0x31, 0x2b, 0x80, 0x9b, 0x89, 0xa9, 0x20,
+    0x83, 0x91, 0x8a, 0xad, 0x8d, 0x41, 0x96, 0x38,
+    0x86, 0xd2, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00,
+    0x08, 0x10, 0x02, 0x80, 0xc1, 0x20, 0x08, 0x83,
+    0x41, 0x5b, 0x83, 0x60, 0x50, 0x57, 0x00, 0xb6,
+    0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80, 0x60,
+    0x23, 0x60, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x49,
+    0x1b, 0x80, 0x47, 0xe7, 0x99, 0x85, 0x99, 0x85,
+    0x99,
 };
 
-static const uint8_t unicode_prop_Other_Lowercase_table[51] = {
+static const uint8_t unicode_prop_Other_Lowercase_table[59] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0x41, 0xf4, 0x88,
     0x31, 0x9d, 0x84, 0xdf, 0x80, 0xb3, 0x80, 0x59,
     0xb0, 0xbe, 0x8c, 0x80, 0xa1, 0xa4, 0x42, 0xb0,
     0x80, 0x8c, 0x80, 0x8f, 0x8c, 0x40, 0xd2, 0x8f,
     0x43, 0x4f, 0x99, 0x47, 0x91, 0x81, 0x60, 0x7a,
     0x1d, 0x81, 0x40, 0xd1, 0x80, 0x40, 0x86, 0x81,
-    0x43, 0x61, 0x83,
+    0x43, 0x61, 0x83, 0x60, 0x5c, 0x1f, 0x01, 0x10,
+    0xa9, 0x80, 0x88,
 };
 
 static const uint8_t unicode_prop_Other_Uppercase_table[15] = {
@@ -3643,10 +3717,10 @@ static const uint8_t unicode_prop_Other_ID_Continue_table[12] = {
     0x88, 0x46, 0x67, 0x80,
 };
 
-static const uint8_t unicode_prop_Prepended_Concatenation_Mark_table[17] = {
+static const uint8_t unicode_prop_Prepended_Concatenation_Mark_table[19] = {
     0x45, 0xff, 0x85, 0x40, 0xd6, 0x80, 0xb0, 0x80,
-    0x41, 0xd1, 0x80, 0x61, 0x07, 0xd9, 0x80, 0x8e,
-    0x80,
+    0x41, 0x7f, 0x81, 0xcf, 0x80, 0x61, 0x07, 0xd9,
+    0x80, 0x8e, 0x80,
 };
 
 static const uint8_t unicode_prop_XID_Start1_table[31] = {
@@ -3676,7 +3750,7 @@ static const uint8_t unicode_prop_Changes_When_Casefolded1_table[33] = {
     0x84,
 };
 
-static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[441] = {
+static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[448] = {
     0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12,
     0x10, 0x82, 0x9f, 0x80, 0xcf, 0x01, 0x80, 0x8b,
     0x07, 0x80, 0xfb, 0x01, 0x01, 0x80, 0xa5, 0x80,
@@ -3690,7 +3764,7 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[441] = {
     0x03, 0x03, 0x03, 0x80, 0x8b, 0x80, 0x88, 0x00,
     0x26, 0x80, 0x90, 0x80, 0x88, 0x03, 0x03, 0x03,
     0x80, 0x8b, 0x80, 0x41, 0x41, 0x80, 0xe1, 0x81,
-    0x46, 0x52, 0x81, 0xd4, 0x83, 0x45, 0x1c, 0x10,
+    0x46, 0x52, 0x81, 0xd4, 0x84, 0x45, 0x1b, 0x10,
     0x8a, 0x80, 0x91, 0x80, 0x9b, 0x8c, 0x80, 0xa1,
     0xa4, 0x40, 0xd9, 0x80, 0x40, 0xd5, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x01, 0x3f, 0x3f, 0x87,
@@ -3709,30 +3783,30 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[441] = {
     0x80, 0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf,
     0x9e, 0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f,
     0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0x40,
-    0x86, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80, 0x60,
-    0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81, 0x89,
-    0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9, 0xa5,
-    0x86, 0x8b, 0x24, 0x00, 0x97, 0x04, 0x00, 0x01,
-    0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf,
-    0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94,
-    0x81, 0x8b, 0x80, 0x92, 0x03, 0x1a, 0x00, 0x80,
-    0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40, 0x83,
-    0x15, 0x0d, 0x0d, 0x0a, 0x16, 0x06, 0x80, 0x88,
-    0x60, 0xbc, 0xa6, 0x83, 0x54, 0xb9, 0x86, 0x8d,
-    0x87, 0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6,
-    0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06,
-    0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03,
-    0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41,
-    0x23, 0x81, 0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01,
-    0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28,
-    0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00,
-    0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03,
-    0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04,
-    0x80, 0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80,
-    0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c,
-    0xab, 0x83, 0x88, 0x31, 0x49, 0x9d, 0x89, 0x60,
-    0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1, 0x4f,
-    0xff,
+    0x80, 0x12, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80,
+    0x60, 0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81,
+    0x89, 0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9,
+    0xa5, 0x86, 0x8b, 0x24, 0x00, 0x97, 0x04, 0x00,
+    0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91,
+    0xbf, 0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95,
+    0x94, 0x81, 0x8b, 0x80, 0x92, 0x03, 0x1a, 0x00,
+    0x80, 0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40,
+    0x83, 0x15, 0x0d, 0x0d, 0x0a, 0x16, 0x06, 0x80,
+    0x88, 0x47, 0x87, 0x20, 0xa9, 0x80, 0x88, 0x60,
+    0xb4, 0xe4, 0x83, 0x54, 0xb9, 0x86, 0x8d, 0x87,
+    0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01,
+    0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80,
+    0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04,
+    0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23,
+    0x81, 0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01, 0x00,
+    0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18,
+    0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03,
+    0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80,
+    0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80, 0x9f,
+    0x99, 0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c, 0xab,
+    0x83, 0x88, 0x31, 0x49, 0x9d, 0x89, 0x60, 0xfc,
+    0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1, 0x4f, 0xff,
 };
 
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
@@ -3744,14 +3818,14 @@ static const uint8_t unicode_prop_Bidi_Control_table[10] = {
     0xb6, 0x83,
 };
 
-static const uint8_t unicode_prop_Dash_table[53] = {
+static const uint8_t unicode_prop_Dash_table[55] = {
     0xac, 0x80, 0x45, 0x5b, 0x80, 0xb2, 0x80, 0x4e,
     0x40, 0x80, 0x44, 0x04, 0x80, 0x48, 0x08, 0x85,
     0xbc, 0x80, 0xa6, 0x80, 0x8e, 0x80, 0x41, 0x85,
     0x80, 0x4c, 0x03, 0x01, 0x80, 0x9e, 0x0b, 0x80,
-    0x41, 0xda, 0x80, 0x92, 0x80, 0xee, 0x80, 0x60,
-    0xcd, 0x8f, 0x81, 0xa4, 0x80, 0x89, 0x80, 0x40,
-    0xa8, 0x80, 0x4f, 0x9e, 0x80,
+    0x9b, 0x80, 0x41, 0xbd, 0x80, 0x92, 0x80, 0xee,
+    0x80, 0x60, 0xcd, 0x8f, 0x81, 0xa4, 0x80, 0x89,
+    0x80, 0x40, 0xa8, 0x80, 0x4f, 0x9e, 0x80,
 };
 
 static const uint8_t unicode_prop_Deprecated_table[23] = {
@@ -3760,55 +3834,59 @@ static const uint8_t unicode_prop_Deprecated_table[23] = {
     0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
 };
 
-static const uint8_t unicode_prop_Diacritic_table[358] = {
+static const uint8_t unicode_prop_Diacritic_table[391] = {
     0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81,
     0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
     0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0,
     0x80, 0xb6, 0x90, 0x80, 0x9a, 0x00, 0x01, 0x00,
     0x40, 0x85, 0x3b, 0x81, 0x40, 0x85, 0x0b, 0x0a,
     0x82, 0xc2, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0xa1,
-    0x81, 0x40, 0xc8, 0x9b, 0xbc, 0x80, 0x8f, 0x02,
-    0x83, 0x9b, 0x80, 0xc9, 0x80, 0x8f, 0x80, 0xed,
-    0x80, 0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xae,
-    0x82, 0xbb, 0x80, 0x8f, 0x06, 0x80, 0xf6, 0x80,
-    0xfe, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xec, 0x81,
-    0x8f, 0x80, 0xfb, 0x80, 0xfb, 0x28, 0x80, 0xea,
-    0x80, 0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00,
-    0x03, 0x81, 0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef,
-    0x00, 0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80,
-    0x89, 0x81, 0x42, 0xc0, 0x82, 0x44, 0x68, 0x8a,
+    0x81, 0xfd, 0x87, 0xa8, 0x89, 0x8f, 0x9b, 0xbc,
+    0x80, 0x8f, 0x02, 0x83, 0x9b, 0x80, 0xc9, 0x80,
+    0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xed, 0x80,
+    0x8f, 0x80, 0xae, 0x82, 0xbb, 0x80, 0x8f, 0x06,
+    0x80, 0xf6, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xed,
+    0x80, 0x8f, 0x80, 0xec, 0x81, 0x8f, 0x80, 0xfb,
+    0x80, 0xfb, 0x28, 0x80, 0xea, 0x80, 0x8c, 0x84,
+    0xca, 0x81, 0x9a, 0x00, 0x00, 0x03, 0x81, 0xc1,
+    0x10, 0x81, 0xbd, 0x80, 0xef, 0x00, 0x81, 0xa7,
+    0x0b, 0x84, 0x98, 0x30, 0x80, 0x89, 0x81, 0x42,
+    0xc0, 0x82, 0x43, 0xb3, 0x81, 0x40, 0xb2, 0x8a,
     0x88, 0x80, 0x41, 0x5a, 0x82, 0x41, 0x38, 0x39,
-    0x80, 0xaf, 0x8d, 0xf5, 0x80, 0x8e, 0x80, 0xa5,
-    0x88, 0xb5, 0x81, 0x40, 0x89, 0x81, 0xbf, 0x85,
-    0xd1, 0x98, 0x18, 0x28, 0x0a, 0xb1, 0xbe, 0xd8,
-    0x8b, 0xa4, 0x22, 0x82, 0x41, 0xbc, 0x00, 0x82,
-    0x8a, 0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81,
-    0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80, 0x41, 0xf9,
-    0x85, 0xe8, 0x83, 0xde, 0x80, 0x60, 0x75, 0x71,
-    0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81,
-    0x8d, 0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40, 0xc9,
-    0x80, 0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80, 0xde,
-    0x80, 0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94, 0x82,
-    0xc0, 0x83, 0xb2, 0x80, 0xe3, 0x84, 0x88, 0x82,
-    0xff, 0x81, 0x60, 0x4f, 0x2f, 0x80, 0x43, 0x00,
-    0x8f, 0x41, 0x0d, 0x00, 0x80, 0xae, 0x80, 0xac,
-    0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x48, 0x03,
-    0x81, 0x42, 0x3a, 0x85, 0x42, 0x1d, 0x8a, 0x41,
-    0x67, 0x81, 0xf7, 0x81, 0xbd, 0x80, 0xcb, 0x80,
-    0x88, 0x82, 0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0,
-    0x80, 0x8f, 0x80, 0x97, 0x32, 0x84, 0x40, 0xcc,
-    0x02, 0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd,
-    0x80, 0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81,
-    0x41, 0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2,
-    0x80, 0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80,
-    0x41, 0x01, 0x00, 0x81, 0xd0, 0x80, 0x60, 0x4d,
-    0x57, 0x84, 0xba, 0x86, 0x44, 0x57, 0x90, 0xcf,
-    0x81, 0x60, 0x61, 0x74, 0x12, 0x2f, 0x39, 0x86,
-    0x9d, 0x83, 0x4f, 0x81, 0x86, 0x41, 0xb4, 0x83,
-    0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
+    0x80, 0xaf, 0x8e, 0x81, 0x8a, 0xe7, 0x80, 0x8e,
+    0x80, 0xa5, 0x88, 0xb5, 0x81, 0x40, 0x89, 0x81,
+    0xbf, 0x85, 0xd1, 0x98, 0x18, 0x28, 0x0a, 0xb1,
+    0xbe, 0xd8, 0x8b, 0xa4, 0x8a, 0x41, 0xbc, 0x00,
+    0x82, 0x8a, 0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c,
+    0x81, 0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80, 0x41,
+    0xf9, 0x85, 0xe8, 0x83, 0xde, 0x80, 0x60, 0x75,
+    0x71, 0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1,
+    0x81, 0x8d, 0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40,
+    0xc9, 0x80, 0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80,
+    0xde, 0x80, 0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94,
+    0x82, 0xc0, 0x83, 0xb2, 0x80, 0xe3, 0x84, 0x88,
+    0x82, 0xff, 0x81, 0x60, 0x4f, 0x2f, 0x80, 0x43,
+    0x00, 0x8f, 0x41, 0x0d, 0x00, 0x80, 0xae, 0x80,
+    0xac, 0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x44,
+    0x9e, 0x28, 0xa9, 0x80, 0x88, 0x43, 0x29, 0x81,
+    0x42, 0x3a, 0x85, 0x42, 0x1d, 0x8a, 0xb0, 0x83,
+    0x40, 0xbf, 0x80, 0xa8, 0x80, 0xc7, 0x81, 0xf7,
+    0x81, 0xbd, 0x80, 0xcb, 0x80, 0x88, 0x82, 0xe7,
+    0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80, 0x8f, 0x80,
+    0x97, 0x32, 0x84, 0x40, 0xcc, 0x02, 0x80, 0xfa,
+    0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80, 0xf5, 0x81,
+    0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0x01, 0x0b,
+    0x80, 0x40, 0x9b, 0x80, 0xd2, 0x80, 0x91, 0x80,
+    0xd0, 0x80, 0x41, 0xa4, 0x80, 0x41, 0x01, 0x00,
+    0x81, 0xd0, 0x80, 0x60, 0x4d, 0x57, 0x84, 0xba,
+    0x86, 0x44, 0x57, 0x90, 0xcf, 0x81, 0x60, 0x3f,
+    0xfd, 0x18, 0x30, 0x81, 0x5f, 0x00, 0xad, 0x81,
+    0x96, 0x42, 0x1f, 0x12, 0x2f, 0x39, 0x86, 0x9d,
+    0x83, 0x4f, 0x81, 0x86, 0x41, 0x76, 0x80, 0xbc,
+    0x83, 0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
 };
 
-static const uint8_t unicode_prop_Extender_table[89] = {
+static const uint8_t unicode_prop_Extender_table[92] = {
     0x40, 0xb6, 0x80, 0x42, 0x17, 0x81, 0x43, 0x6d,
     0x80, 0x41, 0xb8, 0x80, 0x43, 0x59, 0x80, 0x42,
     0xef, 0x80, 0xfe, 0x80, 0x49, 0x42, 0x80, 0xb7,
@@ -3817,10 +3895,10 @@ static const uint8_t unicode_prop_Extender_table[89] = {
     0xdc, 0x82, 0x60, 0x6f, 0x15, 0x80, 0x45, 0xf5,
     0x80, 0x43, 0xc1, 0x80, 0x95, 0x80, 0x40, 0x88,
     0x80, 0xeb, 0x80, 0x94, 0x81, 0x60, 0x54, 0x7a,
-    0x80, 0x53, 0xeb, 0x80, 0x42, 0x67, 0x82, 0x44,
-    0xce, 0x80, 0x60, 0x50, 0xa8, 0x81, 0x44, 0x9b,
-    0x08, 0x80, 0x60, 0x71, 0x57, 0x81, 0x48, 0x05,
-    0x82,
+    0x80, 0x48, 0x0f, 0x81, 0x4b, 0xd9, 0x80, 0x42,
+    0x67, 0x82, 0x44, 0xce, 0x80, 0x60, 0x50, 0xa8,
+    0x81, 0x44, 0x9b, 0x08, 0x80, 0x60, 0x71, 0x57,
+    0x81, 0x48, 0x05, 0x82,
 };
 
 static const uint8_t unicode_prop_Hex_Digit_table[12] = {
@@ -3838,12 +3916,12 @@ static const uint8_t unicode_prop_IDS_Trinary_Operator_table[4] = {
 
 static const uint8_t unicode_prop_Ideographic_table[66] = {
     0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82,
-    0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xfc,
-    0x60, 0x59, 0x02, 0x41, 0x6d, 0x81, 0xe9, 0x60,
+    0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xff,
+    0x60, 0x58, 0xff, 0x41, 0x6d, 0x81, 0xe9, 0x60,
     0x75, 0x09, 0x80, 0x9a, 0x57, 0xf7, 0x87, 0x44,
     0xd5, 0xa9, 0x88, 0x60, 0x24, 0x66, 0x41, 0x8b,
-    0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdd, 0xa1, 0x50,
-    0x34, 0x8a, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
+    0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdf, 0x9f, 0x50,
+    0x38, 0x86, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
     0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1,
     0x53, 0x4a,
 };
@@ -3901,34 +3979,35 @@ static const uint8_t unicode_prop_Regional_Indicator_table[4] = {
     0x61, 0xf1, 0xe5, 0x99,
 };
 
-static const uint8_t unicode_prop_Sentence_Terminal_table[188] = {
+static const uint8_t unicode_prop_Sentence_Terminal_table[194] = {
     0xa0, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0x45, 0x48,
-    0x80, 0x40, 0x93, 0x81, 0x40, 0xb3, 0x80, 0xaa,
+    0x80, 0x40, 0x92, 0x82, 0x40, 0xb3, 0x80, 0xaa,
     0x82, 0x40, 0xf5, 0x80, 0xbc, 0x00, 0x02, 0x81,
     0x41, 0x24, 0x81, 0x46, 0xe3, 0x81, 0x43, 0x15,
     0x03, 0x81, 0x43, 0x04, 0x80, 0x40, 0xc5, 0x81,
     0x40, 0xcb, 0x04, 0x80, 0x41, 0x39, 0x81, 0x41,
-    0x61, 0x83, 0x40, 0xad, 0x09, 0x81, 0x40, 0xda,
-    0x81, 0xc0, 0x81, 0x43, 0xbb, 0x81, 0x88, 0x82,
-    0x4d, 0xe3, 0x80, 0x8c, 0x80, 0x41, 0xc4, 0x80,
-    0x60, 0x74, 0xfb, 0x80, 0x41, 0x0d, 0x81, 0x40,
-    0xe2, 0x02, 0x80, 0x41, 0x7d, 0x81, 0xd5, 0x81,
-    0xde, 0x80, 0x40, 0x97, 0x81, 0x40, 0x92, 0x82,
-    0x40, 0x8f, 0x81, 0x40, 0xf8, 0x80, 0x60, 0x52,
-    0x65, 0x02, 0x81, 0x40, 0xa8, 0x80, 0x8b, 0x80,
-    0x8f, 0x80, 0xc0, 0x80, 0x4a, 0xf3, 0x81, 0x44,
-    0xfc, 0x84, 0x40, 0xec, 0x81, 0xf4, 0x83, 0xfe,
-    0x82, 0x40, 0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7,
-    0x08, 0x81, 0xeb, 0x80, 0x41, 0xa0, 0x81, 0x41,
-    0x74, 0x0c, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82,
-    0x42, 0x04, 0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6,
-    0x81, 0x41, 0xa3, 0x81, 0x42, 0xb3, 0x81, 0x60,
-    0x4b, 0x74, 0x81, 0x40, 0x84, 0x80, 0xc0, 0x81,
-    0x8a, 0x80, 0x43, 0x52, 0x80, 0x60, 0x4e, 0x05,
-    0x80, 0x5d, 0xe7, 0x80,
+    0x61, 0x83, 0x40, 0xad, 0x09, 0x81, 0x9c, 0x81,
+    0x40, 0xbb, 0x81, 0xc0, 0x81, 0x43, 0xbb, 0x81,
+    0x88, 0x82, 0x4d, 0xe3, 0x80, 0x8c, 0x80, 0x95,
+    0x81, 0x41, 0xac, 0x80, 0x60, 0x74, 0xfb, 0x80,
+    0x41, 0x0d, 0x81, 0x40, 0xe2, 0x02, 0x80, 0x41,
+    0x7d, 0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x97,
+    0x81, 0x40, 0x92, 0x82, 0x40, 0x8f, 0x81, 0x40,
+    0xf8, 0x80, 0x60, 0x52, 0x65, 0x02, 0x81, 0x40,
+    0xa8, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0xc0, 0x80,
+    0x4a, 0xf3, 0x81, 0x44, 0xfc, 0x84, 0xab, 0x83,
+    0x40, 0xbc, 0x81, 0xf4, 0x83, 0xfe, 0x82, 0x40,
+    0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x08, 0x81,
+    0xeb, 0x80, 0x41, 0xa0, 0x81, 0x41, 0x74, 0x0c,
+    0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42, 0x04,
+    0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6, 0x81, 0x41,
+    0xa3, 0x81, 0x42, 0xb3, 0x81, 0x60, 0x4b, 0x74,
+    0x81, 0x40, 0x84, 0x80, 0xc0, 0x81, 0x8a, 0x80,
+    0x43, 0x52, 0x80, 0x60, 0x4e, 0x05, 0x80, 0x5d,
+    0xe7, 0x80,
 };
 
-static const uint8_t unicode_prop_Soft_Dotted_table[71] = {
+static const uint8_t unicode_prop_Soft_Dotted_table[74] = {
     0xe8, 0x81, 0x40, 0xc3, 0x80, 0x41, 0x18, 0x80,
     0x9d, 0x80, 0xb3, 0x80, 0x93, 0x80, 0x41, 0x3f,
     0x80, 0xe1, 0x00, 0x80, 0x59, 0x08, 0x80, 0xb2,
@@ -3937,55 +4016,56 @@ static const uint8_t unicode_prop_Soft_Dotted_table[71] = {
     0x4b, 0x31, 0x80, 0x61, 0xa7, 0xa4, 0x81, 0xb1,
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1,
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1,
-    0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81,
+    0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0x48,
+    0x85, 0x80,
 };
 
-static const uint8_t unicode_prop_Terminal_Punctuation_table[241] = {
+static const uint8_t unicode_prop_Terminal_Punctuation_table[246] = {
     0xa0, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
     0x43, 0x3d, 0x07, 0x80, 0x42, 0x00, 0x80, 0xb8,
-    0x80, 0xc7, 0x80, 0x8d, 0x01, 0x81, 0x40, 0xb3,
+    0x80, 0xc7, 0x80, 0x8d, 0x00, 0x82, 0x40, 0xb3,
     0x80, 0xaa, 0x8a, 0x00, 0x40, 0xea, 0x81, 0xb5,
     0x8e, 0x9e, 0x80, 0x41, 0x04, 0x81, 0x44, 0xf3,
     0x81, 0x40, 0xab, 0x03, 0x85, 0x41, 0x36, 0x81,
     0x43, 0x14, 0x87, 0x43, 0x04, 0x80, 0xfb, 0x82,
     0xc6, 0x81, 0x40, 0x9c, 0x12, 0x80, 0xa6, 0x19,
     0x81, 0x41, 0x39, 0x81, 0x41, 0x61, 0x83, 0x40,
-    0xad, 0x08, 0x82, 0x40, 0xda, 0x84, 0xbd, 0x81,
-    0x43, 0xbb, 0x81, 0x88, 0x82, 0x4d, 0xe3, 0x80,
-    0x8c, 0x03, 0x80, 0x89, 0x00, 0x81, 0x41, 0xb0,
-    0x81, 0x60, 0x74, 0xfa, 0x81, 0x41, 0x0c, 0x82,
-    0x40, 0xe2, 0x84, 0x41, 0x7d, 0x81, 0xd5, 0x81,
-    0xde, 0x80, 0x40, 0x96, 0x82, 0x40, 0x92, 0x82,
-    0xfe, 0x80, 0x8f, 0x81, 0x40, 0xf8, 0x80, 0x60,
-    0x52, 0x63, 0x10, 0x83, 0x40, 0xa8, 0x80, 0x89,
-    0x00, 0x80, 0x8a, 0x0a, 0x80, 0xc0, 0x01, 0x80,
-    0x44, 0x39, 0x80, 0xaf, 0x80, 0x44, 0x85, 0x80,
-    0x40, 0xc6, 0x80, 0x41, 0x35, 0x81, 0x40, 0x97,
-    0x85, 0xc3, 0x85, 0xd8, 0x83, 0x43, 0xb7, 0x84,
-    0x40, 0xec, 0x86, 0xef, 0x83, 0xfe, 0x82, 0x40,
-    0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x84, 0xeb,
-    0x80, 0x41, 0xa0, 0x82, 0x8b, 0x81, 0x41, 0x65,
-    0x1a, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42,
-    0x04, 0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6, 0x0b,
-    0x81, 0x41, 0x9d, 0x82, 0xac, 0x80, 0x42, 0x84,
-    0x81, 0x45, 0x76, 0x84, 0x60, 0x45, 0xf8, 0x81,
-    0x40, 0x84, 0x80, 0xc0, 0x82, 0x89, 0x80, 0x43,
-    0x51, 0x81, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe6,
-    0x83,
+    0xad, 0x08, 0x82, 0x9c, 0x81, 0x40, 0xbb, 0x84,
+    0xbd, 0x81, 0x43, 0xbb, 0x81, 0x88, 0x82, 0x4d,
+    0xe3, 0x80, 0x8c, 0x03, 0x80, 0x89, 0x00, 0x0a,
+    0x81, 0x41, 0xab, 0x81, 0x60, 0x74, 0xfa, 0x81,
+    0x41, 0x0c, 0x82, 0x40, 0xe2, 0x84, 0x41, 0x7d,
+    0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x96, 0x82,
+    0x40, 0x92, 0x82, 0xfe, 0x80, 0x8f, 0x81, 0x40,
+    0xf8, 0x80, 0x60, 0x52, 0x63, 0x10, 0x83, 0x40,
+    0xa8, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
+    0xc0, 0x01, 0x80, 0x44, 0x39, 0x80, 0xaf, 0x80,
+    0x44, 0x85, 0x80, 0x40, 0xc6, 0x80, 0x41, 0x35,
+    0x81, 0x40, 0x97, 0x85, 0xc3, 0x85, 0xd8, 0x83,
+    0x43, 0xb7, 0x84, 0xab, 0x83, 0x40, 0xbc, 0x86,
+    0xef, 0x83, 0xfe, 0x82, 0x40, 0x80, 0x0d, 0x80,
+    0x8f, 0x81, 0xd7, 0x84, 0xeb, 0x80, 0x41, 0xa0,
+    0x82, 0x8b, 0x81, 0x41, 0x65, 0x1a, 0x8e, 0xe8,
+    0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80,
+    0x40, 0xfa, 0x81, 0xd6, 0x0b, 0x81, 0x41, 0x9d,
+    0x82, 0xac, 0x80, 0x42, 0x84, 0x81, 0x45, 0x76,
+    0x84, 0x60, 0x45, 0xf8, 0x81, 0x40, 0x84, 0x80,
+    0xc0, 0x82, 0x89, 0x80, 0x43, 0x51, 0x81, 0x60,
+    0x4e, 0x05, 0x80, 0x5d, 0xe6, 0x83,
 };
 
 static const uint8_t unicode_prop_Unified_Ideograph_table[42] = {
     0x60, 0x33, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x51,
-    0xfc, 0x60, 0x5a, 0x10, 0x08, 0x00, 0x81, 0x89,
+    0xff, 0x60, 0x5a, 0x0d, 0x08, 0x00, 0x81, 0x89,
     0x00, 0x00, 0x09, 0x82, 0x61, 0x05, 0xd5, 0x60,
-    0xa6, 0xdd, 0xa1, 0x50, 0x34, 0x8a, 0x40, 0xdd,
+    0xa6, 0xdf, 0x9f, 0x50, 0x38, 0x86, 0x40, 0xdd,
     0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x54, 0x1e,
     0x53, 0x4a,
 };
 
-static const uint8_t unicode_prop_Variation_Selector_table[12] = {
-    0x58, 0x0a, 0x82, 0x60, 0xe5, 0xf1, 0x8f, 0x6d,
-    0x02, 0xef, 0x40, 0xef,
+static const uint8_t unicode_prop_Variation_Selector_table[13] = {
+    0x58, 0x0a, 0x10, 0x80, 0x60, 0xe5, 0xef, 0x8f,
+    0x6d, 0x02, 0xef, 0x40, 0xef,
 };
 
 static const uint8_t unicode_prop_White_Space_table[22] = {
@@ -3994,7 +4074,7 @@ static const uint8_t unicode_prop_White_Space_table[22] = {
     0x80, 0xae, 0x80, 0x4f, 0x9f, 0x80,
 };
 
-static const uint8_t unicode_prop_Bidi_Mirrored_table[171] = {
+static const uint8_t unicode_prop_Bidi_Mirrored_table[173] = {
     0xa7, 0x81, 0x91, 0x00, 0x80, 0x9b, 0x00, 0x80,
     0x9c, 0x00, 0x80, 0xac, 0x80, 0x8e, 0x80, 0x4e,
     0x7d, 0x83, 0x47, 0x5c, 0x81, 0x49, 0x9b, 0x81,
@@ -4012,14 +4092,14 @@ static const uint8_t unicode_prop_Bidi_Mirrored_table[171] = {
     0x09, 0x0b, 0xaa, 0x0f, 0x80, 0xa7, 0x20, 0x00,
     0x14, 0x22, 0x18, 0x14, 0x00, 0x40, 0xff, 0x80,
     0x42, 0x02, 0x1a, 0x08, 0x81, 0x8d, 0x09, 0x89,
-    0x41, 0xdd, 0x89, 0x0f, 0x60, 0xce, 0x3c, 0x2c,
-    0x81, 0x40, 0xa1, 0x81, 0x91, 0x00, 0x80, 0x9b,
-    0x00, 0x80, 0x9c, 0x00, 0x00, 0x08, 0x81, 0x60,
-    0xd7, 0x76, 0x80, 0xb8, 0x80, 0xb8, 0x80, 0xb8,
-    0x80, 0xb8, 0x80,
+    0xaa, 0x87, 0x41, 0xaa, 0x89, 0x0f, 0x60, 0xce,
+    0x3c, 0x2c, 0x81, 0x40, 0xa1, 0x81, 0x91, 0x00,
+    0x80, 0x9b, 0x00, 0x80, 0x9c, 0x00, 0x00, 0x08,
+    0x81, 0x60, 0xd7, 0x76, 0x80, 0xb8, 0x80, 0xb8,
+    0x80, 0xb8, 0x80, 0xb8, 0x80,
 };
 
-static const uint8_t unicode_prop_Emoji_table[238] = {
+static const uint8_t unicode_prop_Emoji_table[239] = {
     0xa2, 0x05, 0x04, 0x89, 0xee, 0x03, 0x80, 0x5f,
     0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95,
     0x80, 0xd9, 0x85, 0x8e, 0x81, 0x41, 0x6e, 0x81,
@@ -4045,11 +4125,11 @@ static const uint8_t unicode_prop_Emoji_table[238] = {
     0xbe, 0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01,
     0x19, 0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88,
     0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05,
-    0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x3d,
-    0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2, 0x8b,
-    0x41, 0x1f, 0xae, 0x80, 0x89, 0x80, 0xb1, 0x80,
-    0xd1, 0x80, 0xb2, 0xef, 0x22, 0x14, 0x86, 0x88,
-    0x98, 0x36, 0x88, 0x82, 0x8c, 0x86,
+    0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x84,
+    0x88, 0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2,
+    0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89, 0x80,
+    0x40, 0xb8, 0xef, 0x22, 0x22, 0x86, 0x88, 0x9c,
+    0x82, 0x8a, 0x25, 0x89, 0x89, 0x2f, 0x3e,
 };
 
 static const uint8_t unicode_prop_Emoji_Component_table[28] = {
@@ -4063,7 +4143,7 @@ static const uint8_t unicode_prop_Emoji_Modifier_table[4] = {
     0x61, 0xf3, 0xfa, 0x84,
 };
 
-static const uint8_t unicode_prop_Emoji_Modifier_Base_table[66] = {
+static const uint8_t unicode_prop_Emoji_Modifier_Base_table[71] = {
     0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
     0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
     0x82, 0xf4, 0x09, 0x8a, 0x94, 0x92, 0x10, 0x1a,
@@ -4072,10 +4152,10 @@ static const uint8_t unicode_prop_Emoji_Modifier_Base_table[66] = {
     0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a, 0x80,
     0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88, 0x89,
     0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80, 0x90,
-    0x10, 0x8c,
+    0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x86,
 };
 
-static const uint8_t unicode_prop_Emoji_Presentation_table[144] = {
+static const uint8_t unicode_prop_Emoji_Presentation_table[145] = {
     0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
     0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
     0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
@@ -4090,10 +4170,11 @@ static const uint8_t unicode_prop_Emoji_Presentation_table[144] = {
     0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80,
     0x40, 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91,
     0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
-    0xc5, 0x28, 0x12, 0x0a, 0x92, 0x0e, 0x88, 0x40,
-    0xe2, 0x8b, 0x41, 0x1f, 0xae, 0x80, 0x89, 0x80,
-    0xb1, 0x80, 0xd1, 0x80, 0xb2, 0xef, 0x22, 0x14,
-    0x86, 0x88, 0x98, 0x36, 0x88, 0x82, 0x8c, 0x86,
+    0xc5, 0x28, 0x12, 0x0a, 0x22, 0x8a, 0x0e, 0x88,
+    0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80,
+    0x89, 0x80, 0x40, 0xb8, 0xef, 0x22, 0x22, 0x86,
+    0x88, 0x9c, 0x82, 0x8a, 0x25, 0x89, 0x89, 0x2f,
+    0x3e,
 };
 
 static const uint8_t unicode_prop_Extended_Pictographic_table[156] = {
@@ -4122,7 +4203,7 @@ static const uint8_t unicode_prop_Extended_Pictographic_table[156] = {
 static const uint8_t unicode_prop_Default_Ignorable_Code_Point_table[51] = {
     0x40, 0xac, 0x80, 0x42, 0xa0, 0x80, 0x42, 0xcb,
     0x80, 0x4b, 0x41, 0x81, 0x46, 0x52, 0x81, 0xd4,
-    0x83, 0x47, 0xfb, 0x84, 0x99, 0x84, 0xb0, 0x8f,
+    0x84, 0x47, 0xfa, 0x84, 0x99, 0x84, 0xb0, 0x8f,
     0x50, 0xf3, 0x80, 0x60, 0xcc, 0x9a, 0x8f, 0x40,
     0xee, 0x80, 0x40, 0x9f, 0x80, 0xce, 0x88, 0x60,
     0xbc, 0xa6, 0x83, 0x54, 0xce, 0x87, 0x6c, 0x2e,
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 3b59284e6e..52fc23940f 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -36887,6 +36887,32 @@ static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValueConst this_val,
         return JS_NewBool(ctx, ret);
 }
 
+static JSValue js_object_hasOwn(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv)
+{
+    JSValue obj;
+    JSAtom atom;
+    JSObject *p;
+    BOOL ret;
+
+    obj = JS_ToObject(ctx, argv[0]);
+    if (JS_IsException(obj))
+        return obj;
+    atom = JS_ValueToAtom(ctx, argv[1]);
+    if (unlikely(atom == JS_ATOM_NULL)) {
+        JS_FreeValue(ctx, obj);
+        return JS_EXCEPTION;
+    }
+    p = JS_VALUE_GET_OBJ(obj);
+    ret = JS_GetOwnPropertyInternal(ctx, NULL, p, atom);
+    JS_FreeAtom(ctx, atom);
+    JS_FreeValue(ctx, obj);
+    if (ret < 0)
+        return JS_EXCEPTION;
+    else
+        return JS_NewBool(ctx, ret);
+}
+
 static JSValue js_object_valueOf(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
@@ -37459,6 +37485,7 @@ static const JSCFunctionListEntry js_object_funcs[] = {
     //JS_CFUNC_DEF("__getObjectData", 1, js_object___getObjectData ),
     //JS_CFUNC_DEF("__setObjectData", 2, js_object___setObjectData ),
     JS_CFUNC_DEF("fromEntries", 1, js_object_fromEntries ),
+    JS_CFUNC_DEF("hasOwn", 2, js_object_hasOwn ),
 };
 
 static const JSCFunctionListEntry js_object_proto_funcs[] = {
@@ -37978,12 +38005,20 @@ static int JS_CopySubArray(JSContext *ctx,
                            JSValueConst obj, int64_t to_pos,
                            int64_t from_pos, int64_t count, int dir)
 {
-    int64_t i, from, to;
+    JSObject *p;
+    int64_t i, from, to, len;
     JSValue val;
     int fromPresent;
 
-    /* XXX: should special case fast arrays */
-    for (i = 0; i < count; i++) {
+    p = NULL;
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
+        p = JS_VALUE_GET_OBJ(obj);
+        if (p->class_id != JS_CLASS_ARRAY || !p->fast_array) {
+            p = NULL;
+        }
+    }
+
+    for (i = 0; i < count; ) {
         if (dir < 0) {
             from = from_pos + count - i - 1;
             to = to_pos + count - i - 1;
@@ -37991,16 +38026,43 @@ static int JS_CopySubArray(JSContext *ctx,
             from = from_pos + i;
             to = to_pos + i;
         }
-        fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
-        if (fromPresent < 0)
-            goto exception;
-
-        if (fromPresent) {
-            if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
-                goto exception;
+        if (p && p->fast_array &&
+            from >= 0 && from < (len = p->u.array.count)  &&
+            to >= 0 && to < len) {
+            int64_t l, j;
+            /* Fast path for fast arrays. Since we don't look at the
+               prototype chain, we can optimize only the cases where
+               all the elements are present in the array. */
+            l = count - i;
+            if (dir < 0) {
+                l = min_int64(l, from + 1);
+                l = min_int64(l, to + 1);
+                for(j = 0; j < l; j++) {
+                    set_value(ctx, &p->u.array.u.values[to - j],
+                              JS_DupValue(ctx, p->u.array.u.values[from - j]));
+                }
+            } else {
+                l = min_int64(l, len - from);
+                l = min_int64(l, len - to);
+                for(j = 0; j < l; j++) {
+                    set_value(ctx, &p->u.array.u.values[to + j],
+                              JS_DupValue(ctx, p->u.array.u.values[from + j]));
+                }
+            }
+            i += l;
         } else {
-            if (JS_DeletePropertyInt64(ctx, obj, to, JS_PROP_THROW) < 0)
+            fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
+            if (fromPresent < 0)
                 goto exception;
+            
+            if (fromPresent) {
+                if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
+                    goto exception;
+            } else {
+                if (JS_DeletePropertyInt64(ctx, obj, to, JS_PROP_THROW) < 0)
+                    goto exception;
+            }
+            i++;
         }
     }
     return 0;
@@ -38962,64 +39024,27 @@ static JSValue js_array_push(JSContext *ctx, JSValueConst this_val,
     int64_t len, from, newLen;
 
     obj = JS_ToObject(ctx, this_val);
-
-    if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
-        JSObject *p = JS_VALUE_GET_OBJ(obj);
-        if (p->class_id != JS_CLASS_ARRAY ||
-            !p->fast_array || !p->extensible)
-            goto generic_case;
-        /* length must be writable */
-        if (unlikely(!(get_shape_prop(p->shape)->flags & JS_PROP_WRITABLE)))
-            goto generic_case;
-        /* check the length */
-        if (unlikely(JS_VALUE_GET_TAG(p->prop[0].u.value) != JS_TAG_INT))
-            goto generic_case;
-        len = JS_VALUE_GET_INT(p->prop[0].u.value);
-        /* we don't support holes */
-        if (unlikely(len != p->u.array.count))
-            goto generic_case;
-        newLen = len + argc;
-        if (unlikely(newLen > INT32_MAX))
-            goto generic_case;
-        if (newLen > p->u.array.u1.size) {
-            if (expand_fast_array(ctx, p, newLen))
-                goto exception;
-        }
-        if (unshift && argc > 0) {
-            memmove(p->u.array.u.values + argc, p->u.array.u.values,
-                    len * sizeof(p->u.array.u.values[0]));
-            from = 0;
-        } else {
-            from = len;
-        }
-        for(i = 0; i < argc; i++) {
-            p->u.array.u.values[from + i] = JS_DupValue(ctx, argv[i]);
-        }
-        p->u.array.count = newLen;
-        p->prop[0].u.value = JS_NewInt32(ctx, newLen);
-    } else {
-    generic_case:
-        if (js_get_length64(ctx, &len, obj))
-            goto exception;
-        newLen = len + argc;
-        if (newLen > MAX_SAFE_INTEGER) {
-            JS_ThrowTypeError(ctx, "Array loo long");
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+    newLen = len + argc;
+    if (newLen > MAX_SAFE_INTEGER) {
+        JS_ThrowTypeError(ctx, "Array loo long");
+        goto exception;
+    }
+    from = len;
+    if (unshift && argc > 0) {
+        if (JS_CopySubArray(ctx, obj, argc, 0, len, -1))
             goto exception;
-        }
-        from = len;
-        if (unshift && argc > 0) {
-            if (JS_CopySubArray(ctx, obj, argc, 0, len, -1))
-                goto exception;
-            from = 0;
-        }
-        for(i = 0; i < argc; i++) {
-            if (JS_SetPropertyInt64(ctx, obj, from + i,
-                                    JS_DupValue(ctx, argv[i])) < 0)
-                goto exception;
-        }
-        if (JS_SetProperty(ctx, obj, JS_ATOM_length, JS_NewInt64(ctx, newLen)) < 0)
+        from = 0;
+    }
+    for(i = 0; i < argc; i++) {
+        if (JS_SetPropertyInt64(ctx, obj, from + i,
+                                JS_DupValue(ctx, argv[i])) < 0)
             goto exception;
     }
+    if (JS_SetProperty(ctx, obj, JS_ATOM_length, JS_NewInt64(ctx, newLen)) < 0)
+        goto exception;
+
     JS_FreeValue(ctx, obj);
     return JS_NewInt64(ctx, newLen);
 

From 381e13e4f9e2951defe70f7d32ce2ca1a5087e4a Mon Sep 17 00:00:00 2001
From: dodola <dinophp@gmail.com>
Date: Fri, 17 Jun 2022 12:59:01 +0800
Subject: [PATCH 172/185] [Test]add enum support test

(cherry picked from commit c9daf823aab1fa90513a482812423293933af62d)
---
 test/CMakeLists.txt |  1 +
 test/enum.cpp       | 71 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 test/enum.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 575f1e9588..9e63673d5e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,6 +10,7 @@ endmacro()
 
 foreach(test
         value class exception example multicontext conversions point variant function_call inheritance jobs unhandled_rejection module_loader
+        enum
         )
 make_test(${test})
 endforeach()
diff --git a/test/enum.cpp b/test/enum.cpp
new file mode 100644
index 0000000000..ef3b28cbf1
--- /dev/null
+++ b/test/enum.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <stdio.h>
+#include "quickjspp.hpp"
+
+enum TestEnum {
+    TestEnum_A,
+    TestEnum_B,
+    TestEnum_C,
+};
+
+namespace qjs {
+
+#define ENUM_DEF(type)                                          \
+   template <>                                                   \
+   struct js_traits<type> {                                      \
+     static type unwrap(JSContext* ctx, JSValue v) noexcept {    \
+       uint32_t t;                                               \
+       JS_ToUint32(ctx, &t, v);                                  \
+       return type((uint16_t)t);                                 \
+     }                                                           \
+                                                                 \
+     static JSValue wrap(JSContext* ctx, type opcode) noexcept { \
+       return JS_NewUint32(ctx, opcode);                         \
+     }                                                           \
+   }
+
+    ENUM_DEF(TestEnum);
+
+}  // namespace qjs
+
+class TestClass {
+public:
+    TestEnum e = TestEnum_C;
+
+    TestEnum getE() {
+        return e;
+    }
+};
+
+void println(qjs::rest<std::string> args) {
+    for (auto const &arg: args) std::cout << arg << " ";
+    std::cout << "\n";
+}
+
+int main() {
+    qjs::Runtime runtime;
+    qjs::Context context(runtime);
+    try {
+        auto &module = context.addModule("MyModule");
+        module.function<&println>("println");
+        module.class_<TestClass>("TestClass")
+                .constructor<>()
+                .fun<&TestClass::getE>("getE");
+        // import module
+        context.eval(R"xxx(
+            import * as my from 'MyModule';
+            globalThis.my = my;
+        )xxx",
+                     "<import>", JS_EVAL_TYPE_MODULE);
+        context.eval(R"xxx(
+            let v1 = new my.TestClass();
+            let e = v1.getE();
+            my.println("enum value "+e);
+        )xxx");
+    } catch (qjs::exception) {
+        auto exc = context.getException();
+        std::cerr << (std::string) exc << std::endl;
+        if ((bool) exc["stack"]) std::cerr << (std::string) exc["stack"] << std::endl;
+        return 1;
+    }
+}

From 595e2ee9e60f213c484a7ba8f8b8c9b901caf9a9 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 20 Jun 2022 17:59:28 +0300
Subject: [PATCH 173/185] fix js_traits<T *>

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index f5942a03e9..fa3a248704 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1021,7 +1021,7 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
             return nullptr;
         }
         auto ptr = js_traits<std::shared_ptr<T>>::unwrap(ctx, v);
-        return ptr->get();
+        return ptr.get();
     }
 };
 

From 04b1649a6ba0e614d9171012a46bc111a8d7a8c9 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 20 Jun 2022 20:15:52 +0300
Subject: [PATCH 174/185] mark unimplemented js_traits as deleted

---
 quickjspp.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index fa3a248704..009eaa2eca 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -58,13 +58,13 @@ struct js_traits
      * @param v This value is passed as JSValueConst so it should be freed by the caller.
      * @throws exception in case of conversion error
      */
-    static R unwrap(JSContext * ctx, JSValueConst v);
+    static R unwrap(JSContext * ctx, JSValueConst v) = delete;
 
     /** Create JSValue from an object of type R and JSContext.
      * This function is intentionally not implemented. User should implement this function for their own type.
      * @return Returns JSValue which should be freed by the caller or JS_EXCEPTION in case of error.
      */
-    static JSValue wrap(JSContext * ctx, R value);
+    static JSValue wrap(JSContext * ctx, R value) = delete;
 };
 
 /** Conversion traits for JSValue (identity).

From 0b725022bd9126a6cf4b862430ea113ac612b350 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 20 Jun 2022 20:22:43 +0300
Subject: [PATCH 175/185] simple enum support

---
 quickjspp.hpp | 13 +++++++++++++
 test/enum.cpp | 25 +++----------------------
 2 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 009eaa2eca..69f1c0daa8 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1025,6 +1025,19 @@ struct js_traits<T *, std::enable_if_t<std::is_class_v<T>>>
     }
 };
 
+/** Conversions for enums. */
+template <typename E>
+struct js_traits<E, std::enable_if_t<std::is_enum_v<E>>> {
+    using T = std::underlying_type_t<E>;
+    static E unwrap(JSContext* ctx, JSValue v) noexcept {
+        return static_cast<E>(js_traits<T>::unwrap(ctx, v));
+    }
+
+    static JSValue wrap(JSContext* ctx, E t) noexcept {
+        return js_traits<T>::wrap(ctx, static_cast<T>(t));;
+    }
+};
+
 namespace detail {
 /** A faster std::function-like object with type erasure.
  * Used to convert any callable objects (including lambdas) to JSValue.
diff --git a/test/enum.cpp b/test/enum.cpp
index ef3b28cbf1..2e9e19000d 100644
--- a/test/enum.cpp
+++ b/test/enum.cpp
@@ -2,32 +2,12 @@
 #include <stdio.h>
 #include "quickjspp.hpp"
 
-enum TestEnum {
+enum TestEnum : int64_t{
     TestEnum_A,
-    TestEnum_B,
+    TestEnum_B = (1ll << 51),
     TestEnum_C,
 };
 
-namespace qjs {
-
-#define ENUM_DEF(type)                                          \
-   template <>                                                   \
-   struct js_traits<type> {                                      \
-     static type unwrap(JSContext* ctx, JSValue v) noexcept {    \
-       uint32_t t;                                               \
-       JS_ToUint32(ctx, &t, v);                                  \
-       return type((uint16_t)t);                                 \
-     }                                                           \
-                                                                 \
-     static JSValue wrap(JSContext* ctx, type opcode) noexcept { \
-       return JS_NewUint32(ctx, opcode);                         \
-     }                                                           \
-   }
-
-    ENUM_DEF(TestEnum);
-
-}  // namespace qjs
-
 class TestClass {
 public:
     TestEnum e = TestEnum_C;
@@ -62,6 +42,7 @@ int main() {
             let e = v1.getE();
             my.println("enum value "+e);
         )xxx");
+        assert(context.eval("e").as<TestEnum>() == TestEnum_C);
     } catch (qjs::exception) {
         auto exc = context.getException();
         std::cerr << (std::string) exc << std::endl;

From e2555831d4e86486cf307d49bda803ffca9f0f43 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Mon, 20 Jun 2022 21:13:06 +0300
Subject: [PATCH 176/185] static member object support

---
 quickjspp.hpp  | 36 +++++++++++++++++++++++++++++++-----
 test/class.cpp |  4 +++-
 2 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 69f1c0daa8..6411e4a763 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1213,6 +1213,7 @@ struct property_proxy
 template <auto M>
 struct get_set {};
 
+// M -  member object
 template <class T, typename R, R T::*M>
 struct get_set<M>
 {
@@ -1230,6 +1231,24 @@ struct get_set<M>
 
 };
 
+// M - static member object
+template <typename R, R *M>
+struct get_set<M>
+{
+    using is_const = std::is_const<R>;
+
+    static const R& get(bool)
+    {
+        return *M;
+    }
+
+    static R& set(bool, R value)
+    {
+        return *M = std::move(value);
+    }
+
+};
+
 } // namespace detail
 
 /** JSValue with RAAI semantics.
@@ -1341,7 +1360,7 @@ class Value
     // add<&f>("f");
     // add<&T::f>("f");
     template <auto F>
-    std::enable_if_t<!std::is_member_object_pointer_v<decltype(F)>, Value&>
+    std::enable_if_t<std::is_member_function_pointer_v<decltype(F)> || std::is_function_v<std::remove_pointer_t<decltype(F)>>, Value&>
     add(const char * name)
     {
         (*this)[name] = fwrapper<F>{name};
@@ -1389,13 +1408,20 @@ class Value
     add(const char * name)
     {
         if constexpr (detail::get_set<M>::is_const::value)
-        {
             return add_getter<detail::get_set<M>::get>(name);
-        }
         else
-        {
             return add_getter_setter<detail::get_set<M>::get, detail::get_set<M>::set>(name);
-        }
+    }
+
+    // add<&T::static_member>("static_member");
+    template <auto M>
+    std::enable_if_t<std::is_pointer_v<decltype(M)> && !std::is_function_v<std::remove_pointer_t<decltype(M)>> , Value&>
+    add(const char * name)
+    {
+        if constexpr (detail::get_set<M>::is_const::value)
+            return add_getter<detail::get_set<M>::get>(name);
+        else
+            return add_getter_setter<detail::get_set<M>::get, detail::get_set<M>::set>(name);
     }
 
     std::string
diff --git a/test/class.cpp b/test/class.cpp
index 16a501f3db..6ceee95e0c 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -49,8 +49,9 @@ class test : public base_test
 
 
     static void fstatic(TYPES) {}
+    static bool bstatic;
 };
-
+bool test::bstatic;
 
 void f(TYPES) {}
 
@@ -74,6 +75,7 @@ void qjs_glue(qjs::Context::Module& m) {
             .fun<&::test::fs>("fs") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
             .fun<&::test::f>("f") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
             .fun<&::test::fstatic>("fstatic") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test>const &, ::std::string, ::std::string const &)
+            .fun<&::test::bstatic>("bstatic") // bool
             .fun<&::test::b>("b") // bool
             .fun<&::test::i>("i") // ::int32_t
             .fun<&::test::d>("d") // double

From 07050bbfc8ca1dfc9d16491d19c4b2a48849dc21 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 3 Jul 2022 17:04:34 +0300
Subject: [PATCH 177/185] fix functions with arguments

---
 quickjspp.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 6411e4a763..86fc649099 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1870,7 +1870,7 @@ struct js_traits<std::function<R(Args...)>, int>
         }
         else
         {
-            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args&& ... args) -> R {
+            return [jsfun_obj = Value{ctx, JS_DupValue(ctx, fun_obj)}](Args ... args) -> R {
                 const int argc = sizeof...(Args);
                 JSValue argv[argc];
                 detail::wrap_args(jsfun_obj.ctx, argv, std::forward<Args>(args)...);

From 31451d2534f08a79fcbd0383a8f762be1f81a9f8 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 3 Jul 2022 17:04:59 +0300
Subject: [PATCH 178/185] example passing c++ objects to js code

---
 test/example.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/example.cpp b/test/example.cpp
index 1c8ba816b0..47f2529958 100644
--- a/test/example.cpp
+++ b/test/example.cpp
@@ -48,6 +48,11 @@ int main()
         // callback
         auto cb = (std::function<void(const std::string&)>) context.eval("my_callback");
         cb("world");
+
+        // passing c++ objects to JS
+        auto lambda = context.eval("x=>my.println(x.member_function('lambda'))").as<std::function<void(qjs::shared_ptr<MyClass>)>>();
+        auto v3 = qjs::make_shared<MyClass>(context.ctx, std::vector{1,2,3});
+        lambda(v3);
     }
     catch(qjs::exception)
     {

From 4fa7d73f7bbe6185672a2fe28f221ec76170e813 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Sun, 3 Jul 2022 21:49:32 +0300
Subject: [PATCH 179/185] define qjs::shared_ptr,make_shared for forward
 compatibility

---
 quickjspp.hpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 86fc649099..c32abea772 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -47,6 +47,15 @@ class exception {
     Value get();
 };
 
+/** std::shared_ptr, for compatibility with quickjspp v2. */
+template <class T> using shared_ptr = std::shared_ptr<T>;
+/** std::make_shared, for compatibility with quickjspp v2. */
+template <class T, typename... Args>
+shared_ptr<T> make_shared(JSContext *, Args&&... args)
+{
+    return std::make_shared<T>(std::forward<Args>(args)...);
+}
+
 /** Javascript conversion traits.
  * Describes how to convert type R to/from JSValue. Second template argument can be used for SFINAE/enable_if type filters.
  */

From 014fc0db4714eb7a7b503f72a43905c856562eb0 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 21 Jul 2022 16:18:33 +0300
Subject: [PATCH 180/185] support for call and exotic methods same as
 8cfdb243e7113099484e277cebec76d1330198c7 example:
 5feb2b1079d7790f7bf701d63284960bac80c609

---
 quickjspp.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index c32abea772..7376a4a0ec 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -886,9 +886,12 @@ struct js_traits<std::shared_ptr<T>>
      * @param ctx context
      * @param name class name
      * @param proto class prototype or JS_NULL
+     * @param call QJS call function. see quickjs doc
+     * @param exotic pointer to QJS exotic methods(static lifetime) which allow custom property handling. see quickjs doc
      * @throws exception
      */
-    static void register_class(JSContext * ctx, const char * name, JSValue proto = JS_NULL)
+    static void register_class(JSContext * ctx, const char * name, JSValue proto = JS_NULL,
+                               JSClassCall * call = nullptr, JSClassExoticMethods * exotic = nullptr)
     {
         if(QJSClassId == 0)
         {
@@ -921,9 +924,9 @@ struct js_traits<std::shared_ptr<T>>
                     // mark
                     marker,
                     // call
-                    nullptr,
+                    call,
                     // exotic
-                    nullptr
+                    exotic
             };
             int e = JS_NewClass(rt, QJSClassId, &def);
             if(e < 0)

From 6b3e9d896dba60fe94aa06c7e037c349f94f1503 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Fri, 22 Jul 2022 17:31:48 +0300
Subject: [PATCH 181/185] add .static_fun to class_registrar for registering JS
 static properties thanks to egoarka for reporting

---
 quickjspp.hpp  | 26 +++++++++++++++++++++++---
 test/class.cpp | 10 ++++++----
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/quickjspp.hpp b/quickjspp.hpp
index 7376a4a0ec..b1a2e3f25c 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -1619,12 +1619,14 @@ class Context
             qjs::Value prototype;
             qjs::Context::Module& module;
             qjs::Context& context;
+            qjs::Value ctor; // last added constructor
         public:
             explicit class_registrar(const char * name, qjs::Context::Module& module, qjs::Context& context) :
                     name(name),
                     prototype(context.newObject()),
                     module(module),
-                    context(context)
+                    context(context),
+                    ctor(JS_NULL)
             {
             }
 
@@ -1653,6 +1655,24 @@ class Context
                 return *this;
             }
 
+            /** Add a static member or function to the last added constructor.
+             * Example:
+             *  struct T { static int var; static int func(); }
+             *  module.class_<T>("T").contructor<>("T").static_fun<&T::var>("var").static_fun<&T::func>("func");
+             */
+            template <auto F>
+            class_registrar& static_fun(const char * name)
+            {
+                assert(!JS_IsNull(ctor.v) && "You should call .constructor before .static_fun");
+                js_traits<qjs::shared_ptr<T>>::template ensureCanCastToBase<F>();
+                ctor.add<F>(name);
+                return *this;
+            }
+
+            /** Add a property with custom getter and setter.
+             * Example:
+             * module.class_<T>("T").property<&T::getX, &T::setX>("x");
+             */
             template <auto FGet, auto FSet = nullptr>
             class_registrar& property(const char * name)
             {
@@ -1674,9 +1694,9 @@ class Context
             {
                 if(!name)
                     name = this->name;
-                Value ctor = context.newValue(qjs::ctor_wrapper<T, Args...>{name});
+                ctor = context.newValue(qjs::ctor_wrapper<T, Args...>{name});
                 JS_SetConstructor(context.ctx, ctor.v, prototype.v);
-                module.add(name, std::move(ctor));
+                module.add(name, qjs::Value{ctor});
                 return *this;
             }
 
diff --git a/test/class.cpp b/test/class.cpp
index 6ceee95e0c..158996a516 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -51,7 +51,7 @@ class test : public base_test
     static void fstatic(TYPES) {}
     static bool bstatic;
 };
-bool test::bstatic;
+bool test::bstatic = true;
 
 void f(TYPES) {}
 
@@ -66,7 +66,9 @@ void qjs_glue(qjs::Context::Module& m) {
 
     m.class_<::test>("test")
             //.base<::base_test>()
-            .constructor<::int32_t, bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &>("Test")
+            .constructor<::int32_t, bool, ::int32_t, double, ::qjs::shared_ptr<test>, ::qjs::shared_ptr<test> const &, ::std::string, ::std::string const &>("Test")
+            .static_fun<&::test::fstatic>("fstatic") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test>const &, ::std::string, ::std::string const &)
+            .static_fun<&::test::bstatic>("bstatic") // bool
             .constructor<::int32_t>("TestSimple")
             .fun<&::test::fi>("fi") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
             .fun<&::test::fb>("fb") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
@@ -74,8 +76,6 @@ void qjs_glue(qjs::Context::Module& m) {
             .fun<&::test::fspt>("fspt") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const&, ::std::string, ::std::string const &)
             .fun<&::test::fs>("fs") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
             .fun<&::test::f>("f") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test> const &, ::std::string, ::std::string const &)
-            .fun<&::test::fstatic>("fstatic") // (bool, ::int32_t, double, ::std::shared_ptr<test>, ::std::shared_ptr<test>const &, ::std::string, ::std::string const &)
-            .fun<&::test::bstatic>("bstatic") // bool
             .fun<&::test::b>("b") // bool
             .fun<&::test::i>("i") // ::int32_t
             .fun<&::test::d>("d") // double
@@ -159,6 +159,8 @@ int main()
                                "q.i"
                                );
         assert(zzz == 23);
+
+        assert((bool)context.eval("test.Test.bstatic === true"));
     }
     catch(exception)
     {

From 9cee4b4d27271d54b95f6f42bfdc534ebeaaeb72 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 21 Jul 2022 18:04:43 +0300
Subject: [PATCH 182/185] fix getclassid patch (JSValue->JSValueConst) from
 c57f5026d96a74857ef8ce6b19262423524979b4

---
 quickjs/patches/getclassid.patch | 2 +-
 quickjs/quickjs.c                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickjs/patches/getclassid.patch b/quickjs/patches/getclassid.patch
index 991f749e8a..bfe6f218fa 100644
--- a/quickjs/patches/getclassid.patch
+++ b/quickjs/patches/getclassid.patch
@@ -7,7 +7,7 @@ index 48aeffc62..8afc4caa1 100644
  #endif
  }
 +
-+JSClassID JS_GetClassID(JSValue v)
++JSClassID JS_GetClassID(JSValueConst v)
 +{
 +    JSObject *p;
 +
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 52fc23940f..1984561a0e 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -54083,7 +54083,7 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
 #endif
 }
 
-JSClassID JS_GetClassID(JSValue v)
+JSClassID JS_GetClassID(JSValueConst v)
 {
     JSObject *p;
 

From 80b6226d1a2eed3bf5f9a34afade5b181779d262 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 21 Dec 2023 13:27:17 +0300
Subject: [PATCH 183/185] update quickjs to 2023-12-09

---
 quickjs/VERSION            |    2 +-
 quickjs/libbf.c            |   41 +-
 quickjs/libregexp.c        |   23 +-
 quickjs/libunicode-table.h | 2435 ++++++++++++++++++------------------
 quickjs/quickjs-atom.h     |    6 +-
 quickjs/quickjs-opcode.h   |    2 +-
 quickjs/quickjs.c          | 2159 ++++++++++++++------------------
 quickjs/quickjs.h          |    6 +-
 8 files changed, 2223 insertions(+), 2451 deletions(-)

diff --git a/quickjs/VERSION b/quickjs/VERSION
index 22ffec1847..08d122201d 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2021-03-27
+2023-12-09
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
index fe1628e797..234b956b4d 100644
--- a/quickjs/libbf.c
+++ b/quickjs/libbf.c
@@ -37,10 +37,12 @@
 
 /* enable it to check the multiplication result */
 //#define USE_MUL_CHECK
+#ifdef CONFIG_BIGNUM
 /* enable it to use FFT/NTT multiplication */
 #define USE_FFT_MUL
 /* enable decimal floating point support */
 #define USE_BF_DEC
+#endif
 
 //#define inline __attribute__((always_inline))
 
@@ -164,6 +166,21 @@ static inline slimb_t sat_add(slimb_t a, slimb_t b)
     return r;
 }
 
+static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
+{
+    if (shift != 0)
+        low = (low >> shift) | (high << (LIMB_BITS - shift));
+    return low;
+}
+
+static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
+{
+    if (shift != 0)
+        return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
+    else
+        return a1;
+}
+
 #define malloc(s) malloc_is_forbidden(s)
 #define free(p) free_is_forbidden(p)
 #define realloc(p, s) realloc_is_forbidden(p, s)
@@ -236,7 +253,7 @@ int bf_set_ui(bf_t *r, uint64_t a)
         a1 = a >> 32;
         shift = clz(a1);
         r->tab[0] = a0 << shift;
-        r->tab[1] = (a1 << shift) | (a0 >> (LIMB_BITS - shift));
+        r->tab[1] = shld(a1, a0, shift);
         r->expn = 2 * LIMB_BITS - shift;
     }
 #endif
@@ -1585,7 +1602,9 @@ int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                 r = &tmp;
             }
             if (bf_resize(r, a_len + b_len)) {
+#ifdef USE_FFT_MUL
             fail:
+#endif                
                 bf_set_nan(r);
                 ret = BF_ST_MEM_ERROR;
                 goto done;
@@ -2282,11 +2301,14 @@ static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
     bf_t a;
     int ret;
     
+#ifdef USE_BF_DEC
     if (a1 == 10 && b <= LIMB_DIGITS) {
         /* use precomputed powers. We do not round at this point
            because we expect the caller to do it */
         ret = bf_set_ui(r, mp_pow_dec[b]);
-    } else {
+    } else
+#endif        
+    {
         bf_init(r->ctx, &a);
         ret = bf_set_ui(&a, a1);
         ret |= bf_pow_ui(r, &a, b, prec, flags);
@@ -5392,21 +5414,6 @@ int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 
 #endif /* LIMB_BITS != 64 */
 
-static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
-{
-    if (shift != 0)
-        low = (low >> shift) | (high << (LIMB_BITS - shift));
-    return low;
-}
-
-static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
-{
-    if (shift != 0)
-        return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
-    else
-        return a1;
-}
-
 #if LIMB_DIGITS == 19
 
 /* WARNING: hardcoded for b = 1e19. It is assumed that:
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index 379bfc7a95..dab8fa1e2e 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -1071,11 +1071,10 @@ static int re_is_simple_quantifier(const uint8_t *bc_buf, int bc_buf_len)
 }
 
 /* '*pp' is the first char after '<' */
-static int re_parse_group_name(char *buf, int buf_size,
-                               const uint8_t **pp, BOOL is_utf16)
+static int re_parse_group_name(char *buf, int buf_size, const uint8_t **pp)
 {
-    const uint8_t *p;
-    uint32_t c;
+    const uint8_t *p, *p1;
+    uint32_t c, d;
     char *q;
 
     p = *pp;
@@ -1086,11 +1085,18 @@ static int re_parse_group_name(char *buf, int buf_size,
             p++;
             if (*p != 'u')
                 return -1;
-            c = lre_parse_escape(&p, is_utf16 * 2);
+            c = lre_parse_escape(&p, 2); // accept surrogate pairs
         } else if (c == '>') {
             break;
         } else if (c >= 128) {
             c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+            if (c >= 0xD800 && c <= 0xDBFF) {
+                d = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
+                if (d >= 0xDC00 && d <= 0xDFFF) {
+                    c = 0x10000 + 0x400 * (c - 0xD800) + (d - 0xDC00);
+                    p = p1;
+                }
+            }
         } else {
             p++;
         }
@@ -1140,8 +1146,7 @@ static int re_parse_captures(REParseState *s, int *phas_named_captures,
                     /* potential named capture */
                     if (capture_name) {
                         p += 3;
-                        if (re_parse_group_name(name, sizeof(name), &p,
-                                                s->is_utf16) == 0) {
+                        if (re_parse_group_name(name, sizeof(name), &p) == 0) {
                             if (!strcmp(name, capture_name))
                                 return capture_index;
                         }
@@ -1314,7 +1319,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             } else if (p[2] == '<') {
                 p += 3;
                 if (re_parse_group_name(s->u.tmp_buf, sizeof(s->u.tmp_buf),
-                                        &p, s->is_utf16)) {
+                                        &p)) {
                     return re_parse_error(s, "invalid group name");
                 }
                 if (find_group_name(s, s->u.tmp_buf) > 0) {
@@ -1378,7 +1383,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 }
                 p1 += 3;
                 if (re_parse_group_name(s->u.tmp_buf, sizeof(s->u.tmp_buf),
-                                        &p1, s->is_utf16)) {
+                                        &p1)) {
                     if (s->is_utf16 || re_has_named_captures(s))
                         return re_parse_error(s, "invalid group name");
                     else
diff --git a/quickjs/libunicode-table.h b/quickjs/libunicode-table.h
index 1727525fb3..b64178b488 100644
--- a/quickjs/libunicode-table.h
+++ b/quickjs/libunicode-table.h
@@ -160,40 +160,41 @@ static const uint16_t case_conv_ext[58] = {
     0x006b, 0x00e5,
 };
 
-static const uint8_t unicode_prop_Cased1_table[188] = {
+static const uint8_t unicode_prop_Cased1_table[196] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0xfc, 0x80, 0xd3,
     0x80, 0x8c, 0x80, 0x8d, 0x81, 0x8d, 0x02, 0x80,
     0xe1, 0x80, 0x91, 0x85, 0x9a, 0x01, 0x00, 0x01,
     0x11, 0x00, 0x01, 0x04, 0x08, 0x01, 0x08, 0x30,
     0x08, 0x01, 0x15, 0x20, 0x00, 0x39, 0x99, 0x31,
     0x9d, 0x84, 0x40, 0x94, 0x80, 0xd6, 0x82, 0xa6,
-    0x80, 0x41, 0x62, 0x80, 0xa6, 0x80, 0x57, 0x76,
-    0xf8, 0x02, 0x80, 0x8f, 0x80, 0xb0, 0x40, 0xdb,
-    0x08, 0x80, 0x41, 0xd0, 0x80, 0x8c, 0x80, 0x8f,
-    0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x14, 0x28,
-    0x10, 0x11, 0x02, 0x01, 0x18, 0x0b, 0x24, 0x4b,
-    0x26, 0x01, 0x01, 0x86, 0xe5, 0x80, 0x60, 0x79,
-    0xb6, 0x81, 0x40, 0x91, 0x81, 0xbd, 0x88, 0x94,
-    0x05, 0x80, 0x98, 0x80, 0xa2, 0x00, 0x80, 0xa1,
-    0x82, 0x43, 0x34, 0xa2, 0x06, 0x80, 0x8c, 0x60,
-    0x5c, 0x16, 0x01, 0x10, 0xa9, 0x80, 0x88, 0x60,
-    0xcc, 0x44, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09,
-    0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03,
-    0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16,
-    0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80,
+    0x80, 0x41, 0x62, 0x80, 0xa6, 0x80, 0x4b, 0x72,
+    0x80, 0x4c, 0x02, 0xf8, 0x02, 0x80, 0x8f, 0x80,
+    0xb0, 0x40, 0xdb, 0x08, 0x80, 0x41, 0xd0, 0x80,
+    0x8c, 0x80, 0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89,
+    0x00, 0x14, 0x28, 0x10, 0x11, 0x02, 0x01, 0x18,
+    0x0b, 0x24, 0x4b, 0x26, 0x01, 0x01, 0x86, 0xe5,
+    0x80, 0x60, 0x79, 0xb6, 0x81, 0x40, 0x91, 0x81,
+    0xbd, 0x88, 0x94, 0x05, 0x80, 0x98, 0x80, 0xa2,
+    0x00, 0x80, 0x9b, 0x12, 0x82, 0x43, 0x34, 0xa2,
+    0x06, 0x80, 0x8d, 0x60, 0x5c, 0x15, 0x01, 0x10,
+    0xa9, 0x80, 0x88, 0x60, 0xcc, 0x44, 0xd4, 0x80,
+    0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00,
+    0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b,
+    0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81,
+    0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
     0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07,
-    0x47, 0x33, 0x89, 0x80, 0x93, 0x52, 0x10, 0x99,
+    0x9e, 0x80, 0x98, 0x07, 0x47, 0x33, 0x89, 0x80,
+    0x93, 0x2d, 0x41, 0x04, 0xbd, 0x50, 0xc1, 0x99,
     0x85, 0x99, 0x85, 0x99,
 };
 
-static const uint8_t unicode_prop_Cased1_index[18] = {
-    0xb9, 0x02, 0xe0, 0xa0, 0x1e, 0x40, 0x9e, 0xa6,
-    0x40, 0x55, 0xd4, 0x61, 0xfb, 0xd6, 0x21, 0x8a,
-    0xf1, 0x01,
+static const uint8_t unicode_prop_Cased1_index[21] = {
+    0xb9, 0x02, 0xe0, 0xc0, 0x1d, 0x20, 0xe5, 0x2c,
+    0x20, 0xb1, 0x07, 0x21, 0xc1, 0xd6, 0x21, 0x4a,
+    0xf1, 0x01, 0x8a, 0xf1, 0x01,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_table[720] = {
+static const uint8_t unicode_prop_Case_Ignorable_table[737] = {
     0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80,
     0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
     0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40,
@@ -215,7 +216,7 @@ static const uint8_t unicode_prop_Case_Ignorable_table[720] = {
     0x01, 0x05, 0x04, 0x81, 0x93, 0x81, 0x9b, 0x81,
     0xb8, 0x0b, 0x1f, 0x80, 0x93, 0x81, 0x9c, 0x80,
     0xc7, 0x06, 0x10, 0x80, 0xd9, 0x01, 0x86, 0x8a,
-    0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x85, 0xc9,
+    0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x86, 0xc8,
     0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d, 0x04,
     0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe5,
     0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82, 0x8f,
@@ -256,34 +257,37 @@ static const uint8_t unicode_prop_Case_Ignorable_table[720] = {
     0x80, 0x40, 0x94, 0x84, 0x44, 0x04, 0x28, 0xa9,
     0x80, 0x88, 0x42, 0x45, 0x10, 0x0c, 0x83, 0xa7,
     0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x83,
-    0x41, 0x82, 0x81, 0x40, 0x98, 0x8a, 0xb0, 0x83,
-    0xfa, 0x80, 0xb5, 0x8e, 0xa8, 0x01, 0x81, 0x89,
-    0x82, 0xb0, 0x19, 0x09, 0x03, 0x80, 0x89, 0x80,
-    0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b,
-    0x81, 0xb3, 0x88, 0x89, 0x19, 0x80, 0xde, 0x11,
-    0x00, 0x0d, 0x80, 0x40, 0x9f, 0x02, 0x87, 0x94,
-    0x81, 0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0x40,
-    0xc2, 0x39, 0x10, 0x80, 0x96, 0x80, 0xd3, 0x28,
-    0x03, 0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81,
-    0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00,
-    0x01, 0x28, 0x80, 0xe4, 0x11, 0x18, 0x84, 0x41,
-    0x02, 0x88, 0x01, 0x40, 0xff, 0x08, 0x03, 0x80,
-    0x40, 0x8f, 0x19, 0x0b, 0x80, 0x9f, 0x89, 0xa7,
-    0x29, 0x1f, 0x80, 0x88, 0x29, 0x82, 0xad, 0x8c,
-    0x01, 0x41, 0x95, 0x30, 0x28, 0x80, 0xd1, 0x95,
-    0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00, 0x08, 0x30,
-    0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41, 0x5a, 0x81,
-    0x55, 0x3a, 0x88, 0x60, 0x36, 0xb6, 0x84, 0xba,
-    0x86, 0x88, 0x83, 0x44, 0x0a, 0x80, 0xbe, 0x90,
-    0xbf, 0x08, 0x81, 0x60, 0x40, 0x0a, 0x18, 0x30,
-    0x81, 0x4c, 0x9d, 0x08, 0x83, 0x52, 0x5b, 0xad,
-    0x81, 0x96, 0x42, 0x1f, 0x82, 0x88, 0x8f, 0x0e,
-    0x9d, 0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6,
-    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
-    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x41,
-    0x04, 0x8d, 0x41, 0x6f, 0x80, 0xbc, 0x83, 0x45,
-    0xdf, 0x86, 0xec, 0x87, 0x4a, 0xae, 0x84, 0x6c,
-    0x0c, 0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40, 0xef,
+    0x41, 0x82, 0x81, 0xcf, 0x82, 0xc5, 0x8a, 0xb0,
+    0x83, 0xfa, 0x80, 0xb5, 0x8e, 0xa8, 0x01, 0x81,
+    0x89, 0x82, 0xb0, 0x19, 0x09, 0x03, 0x80, 0x89,
+    0x80, 0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80,
+    0x8b, 0x81, 0xb3, 0x88, 0x89, 0x19, 0x80, 0xde,
+    0x11, 0x00, 0x0d, 0x01, 0x80, 0x40, 0x9c, 0x02,
+    0x87, 0x94, 0x81, 0xb8, 0x0a, 0x80, 0xa4, 0x32,
+    0x84, 0x40, 0xc2, 0x39, 0x10, 0x80, 0x96, 0x80,
+    0xd3, 0x28, 0x03, 0x08, 0x81, 0x40, 0xed, 0x1d,
+    0x08, 0x81, 0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81,
+    0xe9, 0x00, 0x01, 0x28, 0x80, 0xe4, 0x11, 0x18,
+    0x84, 0x41, 0x02, 0x88, 0x01, 0x40, 0xff, 0x08,
+    0x03, 0x80, 0x40, 0x8f, 0x19, 0x0b, 0x80, 0x9f,
+    0x89, 0xa7, 0x29, 0x1f, 0x80, 0x88, 0x29, 0x82,
+    0xad, 0x8c, 0x01, 0x41, 0x95, 0x30, 0x28, 0x80,
+    0xd1, 0x95, 0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00,
+    0x08, 0x30, 0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41,
+    0x5a, 0x81, 0x8a, 0x81, 0xb3, 0x24, 0x00, 0x80,
+    0x54, 0xec, 0x90, 0x85, 0x8e, 0x60, 0x36, 0x99,
+    0x84, 0xba, 0x86, 0x88, 0x83, 0x44, 0x0a, 0x80,
+    0xbe, 0x90, 0xbf, 0x08, 0x81, 0x60, 0x40, 0x0a,
+    0x18, 0x30, 0x81, 0x4c, 0x9d, 0x08, 0x83, 0x52,
+    0x5b, 0xad, 0x81, 0x96, 0x42, 0x1f, 0x82, 0x88,
+    0x8f, 0x0e, 0x9d, 0x83, 0x40, 0x93, 0x82, 0x47,
+    0xba, 0xb6, 0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95,
+    0x20, 0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01,
+    0x04, 0x84, 0xbd, 0xa0, 0x80, 0x40, 0x9f, 0x8d,
+    0x41, 0x6f, 0x80, 0xbc, 0x83, 0x41, 0xfa, 0x84,
+    0x43, 0xdf, 0x86, 0xec, 0x87, 0x4a, 0xae, 0x84,
+    0x6c, 0x0c, 0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40,
+    0xef,
 };
 
 static const uint8_t unicode_prop_Case_Ignorable_index[69] = {
@@ -292,13 +296,13 @@ static const uint8_t unicode_prop_Case_Ignorable_index[69] = {
     0x10, 0x80, 0xd4, 0x17, 0x40, 0xcf, 0x1a, 0x20,
     0xf5, 0x1c, 0x00, 0x80, 0x20, 0x00, 0x16, 0xa0,
     0x00, 0xc6, 0xa8, 0x00, 0xc2, 0xaa, 0x60, 0x56,
-    0xfe, 0x20, 0xb1, 0x07, 0x01, 0x82, 0x10, 0x21,
-    0x02, 0x13, 0x21, 0xb8, 0x16, 0x61, 0x97, 0x1a,
-    0x01, 0x37, 0x6b, 0x21, 0x8c, 0xd1, 0x01, 0xd7,
-    0xe8, 0x41, 0xf0, 0x01, 0x0e,
+    0xfe, 0x20, 0xb1, 0x07, 0x01, 0x75, 0x10, 0x01,
+    0xeb, 0x12, 0x21, 0x41, 0x16, 0x01, 0x5c, 0x1a,
+    0x01, 0x43, 0x1f, 0x01, 0x2e, 0xcf, 0x41, 0x25,
+    0xe0, 0x01, 0xf0, 0x01, 0x0e,
 };
 
-static const uint8_t unicode_prop_ID_Start_table[1079] = {
+static const uint8_t unicode_prop_ID_Start_table[1100] = {
     0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03,
     0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
     0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20,
@@ -392,51 +396,54 @@ static const uint8_t unicode_prop_ID_Start_table[1079] = {
     0xad, 0x94, 0x9a, 0x96, 0x8b, 0xb4, 0xb8, 0x09,
     0x80, 0x8c, 0xac, 0x9f, 0x98, 0x99, 0xa3, 0x9c,
     0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d, 0x83,
-    0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98, 0xd3,
-    0x30, 0x00, 0x18, 0x8e, 0x80, 0x89, 0x86, 0xae,
-    0xa5, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10,
-    0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d, 0xb4, 0x91,
-    0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93, 0x08, 0x80,
-    0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3, 0xaf, 0x93,
-    0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6, 0x9a, 0xa4,
-    0x86, 0x40, 0xb8, 0xab, 0xf3, 0xbf, 0x9e, 0x39,
-    0x01, 0x38, 0x08, 0x97, 0x8e, 0x00, 0x80, 0xdd,
-    0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b, 0x80, 0x89,
-    0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad, 0x92, 0x80,
-    0x91, 0xc8, 0x41, 0x06, 0x88, 0x80, 0xa4, 0x90,
-    0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08, 0xa5, 0x94,
-    0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d, 0x80, 0x41,
-    0x46, 0x92, 0x40, 0xbc, 0x80, 0xce, 0x43, 0x99,
-    0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0x4b, 0xe0,
-    0x8e, 0x44, 0x2e, 0x4f, 0xd0, 0x42, 0x46, 0x60,
+    0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98, 0x92,
+    0x81, 0xbe, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89,
+    0x86, 0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01,
+    0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d,
+    0xb4, 0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93,
+    0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3,
+    0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6,
+    0x9a, 0xa4, 0x86, 0x40, 0xb8, 0xab, 0xf3, 0xbf,
+    0x9e, 0x39, 0x01, 0x38, 0x08, 0x97, 0x8e, 0x00,
+    0x80, 0xdd, 0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b,
+    0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad,
+    0x92, 0x80, 0x91, 0xc8, 0x41, 0x06, 0x88, 0x80,
+    0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08,
+    0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d,
+    0x80, 0x41, 0x46, 0x92, 0x8e, 0x00, 0x8c, 0x80,
+    0xa1, 0xfb, 0x80, 0xce, 0x43, 0x99, 0xe5, 0xee,
+    0x90, 0x40, 0xc3, 0x4a, 0x4b, 0xe0, 0x8e, 0x44,
+    0x2f, 0x90, 0x85, 0x4f, 0xb8, 0x42, 0x46, 0x60,
     0x21, 0xb8, 0x42, 0x38, 0x86, 0x9e, 0x90, 0xce,
     0x90, 0x9d, 0x91, 0xaf, 0x8f, 0x83, 0x9e, 0x94,
     0x84, 0x92, 0x42, 0xaf, 0xbf, 0xff, 0xca, 0x20,
     0xc1, 0x8c, 0xbf, 0x08, 0x80, 0x9b, 0x57, 0xf7,
     0x87, 0x44, 0xd5, 0xa9, 0x88, 0x60, 0x22, 0xe6,
-    0x18, 0x30, 0x08, 0x41, 0x22, 0xac, 0x82, 0x90,
-    0x1f, 0x41, 0x8b, 0x49, 0x03, 0xea, 0x84, 0x8c,
-    0x82, 0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80,
-    0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00,
-    0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b,
-    0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81,
-    0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x07, 0x47, 0x33, 0x9e, 0x41,
-    0xe0, 0xac, 0x89, 0x86, 0x8f, 0x80, 0x41, 0x40,
-    0x9d, 0x91, 0xab, 0x44, 0xf3, 0x30, 0x18, 0x08,
-    0x8e, 0x80, 0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44,
-    0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89,
-    0x03, 0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02,
-    0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
-    0x00, 0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89,
-    0x80, 0x90, 0x22, 0x04, 0x80, 0x90, 0x51, 0x43,
-    0x60, 0xa6, 0xdf, 0x9f, 0x50, 0x38, 0x86, 0x40,
-    0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x4c,
-    0x1e, 0x42, 0x1d, 0x45, 0xe1, 0x53, 0x4a,
+    0x18, 0x30, 0x08, 0x41, 0x22, 0x8e, 0x80, 0x9c,
+    0x11, 0x80, 0x8d, 0x1f, 0x41, 0x8b, 0x49, 0x03,
+    0xea, 0x84, 0x8c, 0x82, 0x88, 0x86, 0x89, 0x57,
+    0x65, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b,
+    0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f,
+    0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16, 0x80,
+    0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80, 0x9e,
+    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
+    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07, 0x47,
+    0x33, 0x9e, 0x2d, 0x41, 0x04, 0xbd, 0x40, 0x91,
+    0xac, 0x89, 0x86, 0x8f, 0x80, 0x41, 0x40, 0x9d,
+    0x91, 0xab, 0x41, 0xe3, 0x9b, 0x42, 0xf3, 0x30,
+    0x18, 0x08, 0x8e, 0x80, 0x40, 0xc4, 0xba, 0xc3,
+    0x30, 0x44, 0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08,
+    0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00,
+    0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00,
+    0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
+    0x51, 0x43, 0x60, 0xa6, 0xdf, 0x9f, 0x50, 0x39,
+    0x85, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d,
+    0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1, 0x53,
+    0x4a, 0x84, 0x50, 0x5f,
 };
 
-static const uint8_t unicode_prop_ID_Start_index[102] = {
+static const uint8_t unicode_prop_ID_Start_index[105] = {
     0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xa9, 0x09,
     0x20, 0xb1, 0x0a, 0x00, 0xba, 0x0b, 0x20, 0x3b,
     0x0d, 0x20, 0xc7, 0x0e, 0x20, 0x49, 0x12, 0x00,
@@ -445,14 +452,15 @@ static const uint8_t unicode_prop_ID_Start_index[102] = {
     0x32, 0x00, 0xda, 0xa7, 0x00, 0x4c, 0xaa, 0x20,
     0xc7, 0xd7, 0x20, 0xfc, 0xfd, 0x20, 0x9d, 0x02,
     0x21, 0x96, 0x05, 0x01, 0xf3, 0x08, 0x01, 0xb3,
-    0x0c, 0x21, 0x73, 0x11, 0x61, 0x3e, 0x13, 0x01,
-    0x47, 0x17, 0x21, 0x9e, 0x1a, 0x01, 0x9a, 0x23,
-    0x01, 0x78, 0x6b, 0x01, 0xfc, 0xb2, 0x61, 0x3a,
-    0xd5, 0x01, 0x2d, 0xe1, 0x41, 0x33, 0xee, 0x01,
-    0xe0, 0xa6, 0x62, 0x4b, 0x13, 0x03,
+    0x0c, 0x21, 0x73, 0x11, 0x61, 0x34, 0x13, 0x01,
+    0x1b, 0x17, 0x21, 0x8a, 0x1a, 0x01, 0x34, 0x1f,
+    0x21, 0xbf, 0x6a, 0x01, 0x23, 0xb1, 0xa1, 0xad,
+    0xd4, 0x01, 0x6f, 0xd7, 0x01, 0xff, 0xe7, 0x61,
+    0x5e, 0xee, 0x01, 0xe1, 0xeb, 0x22, 0xb0, 0x23,
+    0x03,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_table[640] = {
+static const uint8_t unicode_prop_ID_Continue1_table[660] = {
     0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47,
     0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
     0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf,
@@ -470,85 +478,88 @@ static const uint8_t unicode_prop_ID_Continue1_table[640] = {
     0xba, 0x22, 0x10, 0x83, 0x88, 0x80, 0x8d, 0x89,
     0x8f, 0x84, 0xb6, 0x00, 0x30, 0x10, 0x1e, 0x81,
     0x8a, 0x09, 0x89, 0x90, 0x82, 0xb7, 0x00, 0x30,
-    0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89, 0x8f, 0x83,
-    0xb6, 0x08, 0x30, 0x10, 0x83, 0x88, 0x80, 0x89,
-    0x09, 0x89, 0x90, 0x82, 0xc5, 0x03, 0x28, 0x00,
-    0x3d, 0x89, 0x09, 0xbc, 0x01, 0x86, 0x8b, 0x38,
-    0x89, 0xd6, 0x01, 0x88, 0x8a, 0x29, 0x89, 0xbd,
-    0x0d, 0x89, 0x8a, 0x00, 0x00, 0x03, 0x81, 0xb0,
-    0x93, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80,
-    0xe3, 0x93, 0x80, 0x89, 0x8b, 0x1b, 0x10, 0x11,
-    0x32, 0x83, 0x8c, 0x8b, 0x80, 0x8e, 0x42, 0xbe,
-    0x82, 0x88, 0x88, 0x43, 0x9f, 0x83, 0x9b, 0x82,
-    0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x9f, 0x88, 0x01,
-    0x89, 0xa0, 0x10, 0x8a, 0x40, 0x8e, 0x80, 0xf5,
-    0x8b, 0x83, 0x8b, 0x89, 0x89, 0xff, 0x8a, 0xbb,
-    0x84, 0xb8, 0x89, 0x80, 0x9c, 0x81, 0x8a, 0x85,
-    0x89, 0x95, 0x8d, 0x80, 0x8f, 0xb0, 0x84, 0xae,
-    0x90, 0x8a, 0x89, 0x90, 0x88, 0x8b, 0x82, 0x9d,
-    0x8c, 0x81, 0x89, 0xab, 0x8d, 0xaf, 0x93, 0x87,
-    0x89, 0x85, 0x89, 0xf5, 0x10, 0x94, 0x18, 0x28,
-    0x0a, 0x40, 0xc5, 0xbf, 0x42, 0x3e, 0x81, 0x92,
-    0x80, 0xfa, 0x8c, 0x18, 0x82, 0x8b, 0x4b, 0xfd,
-    0x82, 0x40, 0x8c, 0x80, 0xdf, 0x9f, 0x42, 0x29,
-    0x85, 0xe8, 0x81, 0x60, 0x75, 0x84, 0x89, 0xc4,
-    0x03, 0x89, 0x9f, 0x81, 0xcf, 0x81, 0x41, 0x0f,
-    0x02, 0x03, 0x80, 0x96, 0x23, 0x80, 0xd2, 0x81,
-    0xb1, 0x91, 0x89, 0x89, 0x85, 0x91, 0x8c, 0x8a,
-    0x9b, 0x87, 0x98, 0x8c, 0xab, 0x83, 0xae, 0x8d,
-    0x8e, 0x89, 0x8a, 0x80, 0x89, 0x89, 0xae, 0x8d,
-    0x8b, 0x07, 0x09, 0x89, 0xa0, 0x82, 0xb1, 0x00,
-    0x11, 0x0c, 0x08, 0x80, 0xa8, 0x24, 0x81, 0x40,
-    0xeb, 0x38, 0x09, 0x89, 0x60, 0x4f, 0x23, 0x80,
-    0x42, 0xe0, 0x8f, 0x8f, 0x8f, 0x11, 0x97, 0x82,
-    0x40, 0xbf, 0x89, 0xa4, 0x80, 0x42, 0xbc, 0x80,
-    0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x41, 0x24,
-    0x89, 0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7, 0x13,
-    0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f, 0x89,
-    0x41, 0x70, 0x81, 0x40, 0x98, 0x8a, 0xb0, 0x83,
-    0xf9, 0x82, 0xb4, 0x8e, 0x9e, 0x8a, 0x09, 0x89,
-    0x83, 0xac, 0x8a, 0x30, 0xac, 0x89, 0x2a, 0xa3,
-    0x8d, 0x80, 0x89, 0x21, 0xab, 0x80, 0x8b, 0x82,
-    0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1, 0x8b, 0x28,
-    0x40, 0x9f, 0x8b, 0x84, 0x89, 0x2b, 0xb6, 0x08,
-    0x31, 0x09, 0x82, 0x88, 0x80, 0x89, 0x09, 0x32,
-    0x84, 0x40, 0xbf, 0x91, 0x88, 0x89, 0x18, 0xd0,
-    0x93, 0x8b, 0x89, 0x40, 0xd4, 0x31, 0x88, 0x9a,
-    0x81, 0xd1, 0x90, 0x8e, 0x89, 0xd0, 0x8c, 0x87,
-    0x89, 0xd2, 0x8e, 0x83, 0x89, 0x40, 0xf1, 0x8e,
-    0x40, 0xa4, 0x89, 0xc5, 0x28, 0x09, 0x18, 0x00,
-    0x81, 0x8b, 0x89, 0xf6, 0x31, 0x32, 0x80, 0x9b,
-    0x89, 0xa7, 0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad,
-    0x8f, 0x41, 0x94, 0x38, 0x87, 0x8f, 0x89, 0xb7,
-    0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x30,
-    0x07, 0x89, 0xaf, 0x20, 0x08, 0x27, 0x89, 0x41,
-    0x48, 0x83, 0x60, 0x4b, 0x68, 0x89, 0xd5, 0x89,
-    0xa5, 0x84, 0xba, 0x86, 0x98, 0x89, 0x43, 0xf4,
-    0x00, 0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81, 0x60,
-    0x4c, 0xaa, 0x81, 0x52, 0x60, 0xad, 0x81, 0x96,
-    0x42, 0x1d, 0x22, 0x2f, 0x39, 0x86, 0x9d, 0x83,
-    0x40, 0x93, 0x82, 0x45, 0x88, 0xb1, 0x41, 0xff,
-    0xb6, 0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20,
-    0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04,
-    0x41, 0x04, 0x86, 0x88, 0x89, 0x41, 0x63, 0x80,
-    0xbc, 0x8d, 0x45, 0xd5, 0x86, 0xec, 0x34, 0x89,
-    0x52, 0x95, 0x89, 0x6c, 0x05, 0x05, 0x40, 0xef,
+    0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89, 0x10, 0x8b,
+    0x83, 0xb6, 0x08, 0x30, 0x10, 0x83, 0x88, 0x80,
+    0x89, 0x09, 0x89, 0x90, 0x82, 0xc5, 0x03, 0x28,
+    0x00, 0x3d, 0x89, 0x09, 0xbc, 0x01, 0x86, 0x8b,
+    0x38, 0x89, 0xd6, 0x01, 0x88, 0x8a, 0x30, 0x89,
+    0xbd, 0x0d, 0x89, 0x8a, 0x00, 0x00, 0x03, 0x81,
+    0xb0, 0x93, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88,
+    0x80, 0xe3, 0x93, 0x80, 0x89, 0x8b, 0x1b, 0x10,
+    0x11, 0x32, 0x83, 0x8c, 0x8b, 0x80, 0x8e, 0x42,
+    0xbe, 0x82, 0x88, 0x88, 0x43, 0x9f, 0x83, 0x9b,
+    0x82, 0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x9f, 0x88,
+    0x01, 0x89, 0xa0, 0x10, 0x8a, 0x40, 0x8e, 0x80,
+    0xf5, 0x8b, 0x83, 0x8b, 0x89, 0x89, 0xff, 0x8a,
+    0xbb, 0x84, 0xb8, 0x89, 0x80, 0x9c, 0x81, 0x8a,
+    0x85, 0x89, 0x95, 0x8d, 0x80, 0x8f, 0xb0, 0x84,
+    0xae, 0x90, 0x8a, 0x89, 0x90, 0x88, 0x8b, 0x82,
+    0x9d, 0x8c, 0x81, 0x89, 0xab, 0x8d, 0xaf, 0x93,
+    0x87, 0x89, 0x85, 0x89, 0xf5, 0x10, 0x94, 0x18,
+    0x28, 0x0a, 0x40, 0xc5, 0xbf, 0x42, 0x3e, 0x81,
+    0x92, 0x80, 0xfa, 0x8c, 0x18, 0x82, 0x8b, 0x4b,
+    0xfd, 0x82, 0x40, 0x8c, 0x80, 0xdf, 0x9f, 0x42,
+    0x29, 0x85, 0xe8, 0x81, 0x60, 0x75, 0x84, 0x89,
+    0xc4, 0x03, 0x89, 0x9f, 0x81, 0xcf, 0x81, 0x41,
+    0x0f, 0x02, 0x03, 0x80, 0x96, 0x23, 0x80, 0xd2,
+    0x81, 0xb1, 0x91, 0x89, 0x89, 0x85, 0x91, 0x8c,
+    0x8a, 0x9b, 0x87, 0x98, 0x8c, 0xab, 0x83, 0xae,
+    0x8d, 0x8e, 0x89, 0x8a, 0x80, 0x89, 0x89, 0xae,
+    0x8d, 0x8b, 0x07, 0x09, 0x89, 0xa0, 0x82, 0xb1,
+    0x00, 0x11, 0x0c, 0x08, 0x80, 0xa8, 0x24, 0x81,
+    0x40, 0xeb, 0x38, 0x09, 0x89, 0x60, 0x4f, 0x23,
+    0x80, 0x42, 0xe0, 0x8f, 0x8f, 0x8f, 0x11, 0x97,
+    0x82, 0x40, 0xbf, 0x89, 0xa4, 0x80, 0x42, 0xbc,
+    0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x41,
+    0x24, 0x89, 0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7,
+    0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f,
+    0x89, 0x41, 0x70, 0x81, 0xcf, 0x82, 0xc5, 0x8a,
+    0xb0, 0x83, 0xf9, 0x82, 0xb4, 0x8e, 0x9e, 0x8a,
+    0x09, 0x89, 0x83, 0xac, 0x8a, 0x30, 0xac, 0x89,
+    0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21, 0xab, 0x80,
+    0x8b, 0x82, 0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1,
+    0x8b, 0x28, 0x08, 0x40, 0x9c, 0x8b, 0x84, 0x89,
+    0x2b, 0xb6, 0x08, 0x31, 0x09, 0x82, 0x88, 0x80,
+    0x89, 0x09, 0x32, 0x84, 0x40, 0xbf, 0x91, 0x88,
+    0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89, 0x40, 0xd4,
+    0x31, 0x88, 0x9a, 0x81, 0xd1, 0x90, 0x8e, 0x89,
+    0xd0, 0x8c, 0x87, 0x89, 0xd2, 0x8e, 0x83, 0x89,
+    0x40, 0xf1, 0x8e, 0x40, 0xa4, 0x89, 0xc5, 0x28,
+    0x09, 0x18, 0x00, 0x81, 0x8b, 0x89, 0xf6, 0x31,
+    0x32, 0x80, 0x9b, 0x89, 0xa7, 0x30, 0x1f, 0x80,
+    0x88, 0x8a, 0xad, 0x8f, 0x41, 0x94, 0x38, 0x87,
+    0x8f, 0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a,
+    0x00, 0x08, 0x30, 0x07, 0x89, 0xaf, 0x20, 0x08,
+    0x27, 0x89, 0x41, 0x48, 0x83, 0x88, 0x08, 0x80,
+    0xaf, 0x32, 0x84, 0x8c, 0x89, 0x54, 0xe5, 0x05,
+    0x8e, 0x60, 0x36, 0x09, 0x89, 0xd5, 0x89, 0xa5,
+    0x84, 0xba, 0x86, 0x98, 0x89, 0x43, 0xf4, 0x00,
+    0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81, 0x60, 0x4c,
+    0xaa, 0x81, 0x52, 0x60, 0xad, 0x81, 0x96, 0x42,
+    0x1d, 0x22, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x40,
+    0x93, 0x82, 0x45, 0x88, 0xb1, 0x41, 0xff, 0xb6,
+    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
+    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0xe3,
+    0x80, 0x40, 0x9f, 0x86, 0x88, 0x89, 0x41, 0x63,
+    0x80, 0xbc, 0x8d, 0x41, 0xf1, 0x8d, 0x43, 0xd5,
+    0x86, 0xec, 0x34, 0x89, 0x52, 0x95, 0x89, 0x6c,
+    0x05, 0x05, 0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_index[60] = {
+static const uint8_t unicode_prop_ID_Continue1_index[63] = {
     0xfa, 0x06, 0x00, 0x70, 0x09, 0x00, 0xf0, 0x0a,
-    0x40, 0x57, 0x0c, 0x00, 0xf0, 0x0d, 0x40, 0xc7,
-    0x0f, 0x00, 0xea, 0x17, 0x20, 0x45, 0x1b, 0x20,
-    0x55, 0x20, 0x20, 0x0c, 0xa8, 0x60, 0x37, 0xaa,
-    0x00, 0x50, 0xfe, 0x00, 0x3a, 0x0d, 0x01, 0x83,
-    0x11, 0x01, 0xc4, 0x14, 0x21, 0x44, 0x19, 0x21,
-    0x5a, 0x1d, 0x41, 0x9f, 0xbc, 0x61, 0xb0, 0xda,
-    0x21, 0xf0, 0x01, 0x0e,
+    0x40, 0x57, 0x0c, 0x00, 0xf0, 0x0d, 0x60, 0xc7,
+    0x0f, 0x20, 0xea, 0x17, 0x40, 0x05, 0x1b, 0x00,
+    0x41, 0x20, 0x00, 0x0c, 0xa8, 0x80, 0x37, 0xaa,
+    0x20, 0x50, 0xfe, 0x20, 0x3a, 0x0d, 0x21, 0x74,
+    0x11, 0x01, 0x5a, 0x14, 0x21, 0x44, 0x19, 0x81,
+    0x5a, 0x1d, 0xa1, 0xf5, 0x6a, 0x21, 0x45, 0xd2,
+    0x41, 0xaf, 0xe2, 0x21, 0xf0, 0x01, 0x0e,
 };
 
 #ifdef CONFIG_ALL_UNICODE
 
-static const uint8_t unicode_cc_table[881] = {
+static const uint8_t unicode_cc_table[899] = {
     0xb2, 0xcf, 0xd4, 0x00, 0xe8, 0x03, 0xdc, 0x00,
     0xe8, 0x00, 0xd8, 0x04, 0xdc, 0x01, 0xca, 0x03,
     0xdc, 0x01, 0xca, 0x0a, 0xdc, 0x04, 0x01, 0x03,
@@ -631,38 +642,40 @@ static const uint8_t unicode_cc_table[881] = {
     0xb6, 0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0,
     0x00, 0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0,
     0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1,
-    0x52, 0xc1, 0xb0, 0x68, 0x01, 0xdc, 0xc2, 0x00,
-    0xdc, 0xc0, 0x03, 0xdc, 0xb0, 0x00, 0xc0, 0x00,
-    0xdc, 0xc0, 0x00, 0xdc, 0xb0, 0x8f, 0x00, 0x09,
-    0xa8, 0x00, 0x09, 0x8d, 0x00, 0x09, 0xb0, 0x08,
-    0x00, 0x09, 0x00, 0x07, 0xb0, 0x14, 0xc2, 0xaf,
-    0x01, 0x09, 0xb0, 0x0d, 0x00, 0x07, 0xb0, 0x1b,
-    0x00, 0x09, 0x88, 0x00, 0x07, 0xb0, 0x39, 0x00,
-    0x09, 0x00, 0x07, 0xb0, 0x81, 0x00, 0x07, 0x00,
-    0x09, 0xb0, 0x1f, 0x01, 0x07, 0x8f, 0x00, 0x09,
-    0x97, 0xc6, 0x82, 0xc4, 0xb0, 0x9c, 0x00, 0x09,
-    0x82, 0x00, 0x07, 0x96, 0xc0, 0xb0, 0x32, 0x00,
-    0x09, 0x00, 0x07, 0xb0, 0xca, 0x00, 0x09, 0x00,
-    0x07, 0xb0, 0x4d, 0x00, 0x09, 0xb0, 0x45, 0x00,
-    0x09, 0x00, 0x07, 0xb0, 0x42, 0x00, 0x09, 0xb0,
-    0xdc, 0x00, 0x09, 0x00, 0x07, 0xb0, 0xd1, 0x01,
-    0x09, 0x83, 0x00, 0x07, 0xb0, 0x6b, 0x00, 0x09,
-    0xb0, 0x22, 0x00, 0x09, 0x91, 0x00, 0x09, 0xb0,
-    0x20, 0x00, 0x09, 0xb1, 0x74, 0x00, 0x09, 0xb0,
-    0xd1, 0x00, 0x07, 0x80, 0x01, 0x09, 0xb0, 0x20,
-    0x00, 0x09, 0xb8, 0x45, 0x27, 0x04, 0x01, 0xb0,
+    0x52, 0xc1, 0xb0, 0x1f, 0x02, 0xdc, 0xb0, 0x15,
+    0x01, 0xdc, 0xc2, 0x00, 0xdc, 0xc0, 0x03, 0xdc,
+    0xb0, 0x00, 0xc0, 0x00, 0xdc, 0xc0, 0x00, 0xdc,
+    0xb0, 0x8f, 0x00, 0x09, 0xa8, 0x00, 0x09, 0x8d,
+    0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0, 0x0d,
+    0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88, 0x00,
+    0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f, 0x01,
+    0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82, 0xc4,
+    0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07, 0x96,
+    0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00,
+    0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07, 0xb0,
+    0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00,
+    0x07, 0xb0, 0xd1, 0x01, 0x09, 0x83, 0x00, 0x07,
+    0xb0, 0x6b, 0x00, 0x09, 0xb0, 0x22, 0x00, 0x09,
+    0x91, 0x00, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1,
+    0x74, 0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07, 0x80,
+    0x01, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1, 0x78,
+    0x01, 0x09, 0xb8, 0x43, 0x7c, 0x04, 0x01, 0xb0,
     0x0a, 0xc6, 0xb4, 0x88, 0x01, 0x06, 0xb8, 0x44,
     0x7b, 0x00, 0x01, 0xb8, 0x0c, 0x95, 0x01, 0xd8,
     0x02, 0x01, 0x82, 0x00, 0xe2, 0x04, 0xd8, 0x87,
     0x07, 0xdc, 0x81, 0xc4, 0x01, 0xdc, 0x9d, 0xc3,
     0xb0, 0x63, 0xc2, 0xb8, 0x05, 0x8a, 0xc6, 0x80,
     0xd0, 0x81, 0xc6, 0x80, 0xc1, 0x80, 0xc4, 0xb0,
-    0xd4, 0xc6, 0xb1, 0x46, 0xc0, 0xb0, 0x0c, 0xc3,
-    0xb5, 0xaf, 0x06, 0xdc, 0xb0, 0x3c, 0xc5, 0x00,
-    0x07,
+    0x33, 0xc0, 0xb0, 0x6f, 0xc6, 0xb1, 0x46, 0xc0,
+    0xb0, 0x0c, 0xc3, 0xb1, 0xcb, 0x01, 0xe8, 0x00,
+    0xdc, 0xc0, 0xb3, 0xaf, 0x06, 0xdc, 0xb0, 0x3c,
+    0xc5, 0x00, 0x07,
 };
 
-static const uint8_t unicode_cc_index[84] = {
+static const uint8_t unicode_cc_index[87] = {
     0x4d, 0x03, 0x00, 0x97, 0x05, 0x20, 0xc6, 0x05,
     0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0x9c,
     0x08, 0x00, 0x4d, 0x09, 0x00, 0x3c, 0x0b, 0x00,
@@ -670,13 +683,13 @@ static const uint8_t unicode_cc_index[84] = {
     0x20, 0x3a, 0x19, 0x00, 0xcb, 0x1a, 0x20, 0xd3,
     0x1c, 0x00, 0xcf, 0x1d, 0x00, 0xe2, 0x20, 0x00,
     0x2e, 0x30, 0x20, 0x2b, 0xa9, 0x20, 0xed, 0xab,
-    0x00, 0x39, 0x0a, 0x01, 0x84, 0x0f, 0x21, 0xc0,
-    0x11, 0x01, 0x43, 0x14, 0x01, 0x39, 0x18, 0x21,
-    0x42, 0x1d, 0x21, 0x67, 0xd1, 0x01, 0x30, 0xe1,
-    0x21, 0x4b, 0xe9, 0x01,
+    0x00, 0x39, 0x0a, 0x01, 0x51, 0x0f, 0x01, 0x73,
+    0x11, 0x01, 0x75, 0x13, 0x01, 0x2b, 0x17, 0x21,
+    0x3f, 0x1c, 0x21, 0x9e, 0xbc, 0x21, 0x08, 0xe0,
+    0x01, 0x44, 0xe9, 0x01, 0x4b, 0xe9, 0x01,
 };
 
-static const uint32_t unicode_decomp_table1[693] = {
+static const uint32_t unicode_decomp_table1[699] = {
     0x00280081, 0x002a0097, 0x002a8081, 0x002bc097,
     0x002c8115, 0x002d0097, 0x002d4081, 0x002e0097,
     0x002e4115, 0x002f0199, 0x00302016, 0x00400842,
@@ -840,20 +853,21 @@ static const uint32_t unicode_decomp_table1[693] = {
     0x75e24081, 0x75e2832d, 0x75e4089f, 0x75e84081,
     0x75e8839f, 0x75ea4081, 0x75ea8c9f, 0x75f0c081,
     0x75f1042d, 0x75f3851f, 0x75f6051f, 0x75f8851f,
-    0x75fb051f, 0x75fd851f, 0x7b80022d, 0x7b814dad,
-    0x7b884203, 0x7b89c081, 0x7b8a452d, 0x7b8d0403,
-    0x7b908081, 0x7b91dc03, 0x7ba0052d, 0x7ba2c8ad,
-    0x7ba84483, 0x7baac8ad, 0x7c400097, 0x7c404521,
-    0x7c440d25, 0x7c4a8087, 0x7c4ac115, 0x7c4b4117,
-    0x7c4c0d1f, 0x7c528217, 0x7c538099, 0x7c53c097,
-    0x7c5a8197, 0x7c640097, 0x7c80012f, 0x7c808081,
-    0x7c841603, 0x7c9004c1, 0x7c940103, 0x7efc051f,
-    0xbe0001ac, 0xbe00d110, 0xbe0947ac, 0xbe0d3910,
-    0xbe29872c, 0xbe2d022c, 0xbe2e3790, 0xbe49ff90,
-    0xbe69bc10,
+    0x75fb051f, 0x75fd851f, 0x780c049f, 0x780e419f,
+    0x780f059f, 0x7811c203, 0x7812d0ad, 0x781b0103,
+    0x7b80022d, 0x7b814dad, 0x7b884203, 0x7b89c081,
+    0x7b8a452d, 0x7b8d0403, 0x7b908081, 0x7b91dc03,
+    0x7ba0052d, 0x7ba2c8ad, 0x7ba84483, 0x7baac8ad,
+    0x7c400097, 0x7c404521, 0x7c440d25, 0x7c4a8087,
+    0x7c4ac115, 0x7c4b4117, 0x7c4c0d1f, 0x7c528217,
+    0x7c538099, 0x7c53c097, 0x7c5a8197, 0x7c640097,
+    0x7c80012f, 0x7c808081, 0x7c841603, 0x7c9004c1,
+    0x7c940103, 0x7efc051f, 0xbe0001ac, 0xbe00d110,
+    0xbe0947ac, 0xbe0d3910, 0xbe29872c, 0xbe2d022c,
+    0xbe2e3790, 0xbe49ff90, 0xbe69bc10,
 };
 
-static const uint16_t unicode_decomp_table2[693] = {
+static const uint16_t unicode_decomp_table2[699] = {
     0x0020, 0x0000, 0x0061, 0x0002, 0x0004, 0x0006, 0x03bc, 0x0008,
     0x000a, 0x000c, 0x0015, 0x0095, 0x00a5, 0x00b9, 0x00c1, 0x00c3,
     0x00c7, 0x00cb, 0x00d1, 0x00d7, 0x00dd, 0x00e0, 0x00e6, 0x00f8,
@@ -935,15 +949,16 @@ static const uint16_t unicode_decomp_table2[693] = {
     0x2207, 0x1dc8, 0x2202, 0x1dca, 0x1dd2, 0x03f4, 0x1dd4, 0x2207,
     0x1dd6, 0x2202, 0x1dd8, 0x1de0, 0x03f4, 0x1de2, 0x2207, 0x1de4,
     0x2202, 0x1de6, 0x1dee, 0x03f4, 0x1df0, 0x2207, 0x1df2, 0x2202,
-    0x1df4, 0x1dfe, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 0x1e0e,
-    0x1e2b, 0x062d, 0x1e33, 0x1e3f, 0x062c, 0x1e4f, 0x1ebf, 0x1ecb,
-    0x1ede, 0x1ef0, 0x1f03, 0x1f05, 0x1f09, 0x1f0f, 0x1f15, 0x1f17,
-    0x1f1b, 0x1f1d, 0x1f25, 0x1f28, 0x1f2a, 0x1f30, 0x1f32, 0x30b5,
-    0x1f38, 0x1f90, 0x1fa6, 0x1faa, 0x1fac, 0x1fb1, 0x1ffe, 0x200f,
-    0x2110, 0x2120, 0x2126, 0x2220, 0x233e,
+    0x1df4, 0x1dfe, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 0x1e0a,
+    0x1e0c, 0x1e0e, 0x1e16, 0x1e39, 0x1e3d, 0x1e43, 0x1e60, 0x062d,
+    0x1e68, 0x1e74, 0x062c, 0x1e84, 0x1ef4, 0x1f00, 0x1f13, 0x1f25,
+    0x1f38, 0x1f3a, 0x1f3e, 0x1f44, 0x1f4a, 0x1f4c, 0x1f50, 0x1f52,
+    0x1f5a, 0x1f5d, 0x1f5f, 0x1f65, 0x1f67, 0x30b5, 0x1f6d, 0x1fc5,
+    0x1fdb, 0x1fdf, 0x1fe1, 0x1fe6, 0x2033, 0x2044, 0x2145, 0x2155,
+    0x215b, 0x2255, 0x2373,
 };
 
-static const uint8_t unicode_decomp_data[9292] = {
+static const uint8_t unicode_decomp_data[9345] = {
     0x20, 0x88, 0x20, 0x84, 0x32, 0x33, 0x20, 0x81,
     0x20, 0xa7, 0x31, 0x6f, 0x31, 0xd0, 0x34, 0x31,
     0xd0, 0x32, 0x33, 0xd0, 0x34, 0x41, 0x80, 0x41,
@@ -1905,207 +1920,214 @@ static const uint8_t unicode_decomp_data[9292] = {
     0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
     0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30, 0x00,
     0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
-    0x27, 0x06, 0x00, 0x01, 0x05, 0x08, 0x2a, 0x06,
-    0x1e, 0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a, 0x1b,
-    0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a,
-    0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x44,
-    0x90, 0x77, 0x45, 0x28, 0x06, 0x2c, 0x06, 0x00,
-    0x00, 0x47, 0x06, 0x33, 0x06, 0x17, 0x10, 0x11,
-    0x12, 0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f, 0x34,
-    0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00,
-    0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x2d,
-    0x06, 0x00, 0x00, 0x4a, 0x06, 0x00, 0x00, 0x44,
-    0x06, 0x00, 0x00, 0x46, 0x06, 0x33, 0x06, 0x39,
-    0x06, 0x00, 0x00, 0x35, 0x06, 0x42, 0x06, 0x00,
-    0x00, 0x34, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2e,
-    0x06, 0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a,
-    0x06, 0x00, 0x00, 0xba, 0x06, 0x00, 0x00, 0x6f,
-    0x06, 0x00, 0x00, 0x28, 0x06, 0x2c, 0x06, 0x00,
-    0x00, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2d,
-    0x06, 0x37, 0x06, 0x4a, 0x06, 0x43, 0x06, 0x00,
-    0x00, 0x45, 0x06, 0x46, 0x06, 0x33, 0x06, 0x39,
-    0x06, 0x41, 0x06, 0x35, 0x06, 0x42, 0x06, 0x00,
-    0x00, 0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e,
-    0x06, 0x00, 0x00, 0x36, 0x06, 0x38, 0x06, 0x3a,
-    0x06, 0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06, 0x27,
-    0x06, 0x00, 0x01, 0x05, 0x08, 0x20, 0x21, 0x0b,
-    0x06, 0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b, 0x1c,
-    0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00,
-    0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28, 0x06,
-    0x2c, 0x06, 0x2f, 0x06, 0x00, 0x00, 0x48, 0x06,
-    0x32, 0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06,
+    0x30, 0x04, 0x3a, 0x04, 0x3e, 0x04, 0x4b, 0x04,
+    0x4d, 0x04, 0x4e, 0x04, 0x89, 0xa6, 0x30, 0x04,
+    0xa9, 0x26, 0x28, 0xb9, 0x7f, 0x9f, 0x00, 0x01,
+    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a,
+    0x0b, 0x0e, 0x0f, 0x11, 0x13, 0x14, 0x15, 0x16,
+    0x17, 0x18, 0x1a, 0x1b, 0x61, 0x26, 0x25, 0x2f,
+    0x7b, 0x51, 0xa6, 0xb1, 0x04, 0x27, 0x06, 0x00,
+    0x01, 0x05, 0x08, 0x2a, 0x06, 0x1e, 0x08, 0x03,
+    0x0d, 0x20, 0x19, 0x1a, 0x1b, 0x1c, 0x09, 0x0f,
+    0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04,
+    0x06, 0x0c, 0x0e, 0x10, 0x44, 0x90, 0x77, 0x45,
+    0x28, 0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06,
+    0x33, 0x06, 0x17, 0x10, 0x11, 0x12, 0x13, 0x00,
+    0x06, 0x0e, 0x02, 0x0f, 0x34, 0x06, 0x2a, 0x06,
+    0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00, 0x36, 0x06,
+    0x00, 0x00, 0x3a, 0x06, 0x2d, 0x06, 0x00, 0x00,
+    0x4a, 0x06, 0x00, 0x00, 0x44, 0x06, 0x00, 0x00,
+    0x46, 0x06, 0x33, 0x06, 0x39, 0x06, 0x00, 0x00,
+    0x35, 0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x2e, 0x06, 0x00, 0x00,
+    0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x00, 0x00,
+    0xba, 0x06, 0x00, 0x00, 0x6f, 0x06, 0x00, 0x00,
+    0x28, 0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x2d, 0x06, 0x37, 0x06,
+    0x4a, 0x06, 0x43, 0x06, 0x00, 0x00, 0x45, 0x06,
+    0x46, 0x06, 0x33, 0x06, 0x39, 0x06, 0x41, 0x06,
+    0x35, 0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06,
+    0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00,
+    0x36, 0x06, 0x38, 0x06, 0x3a, 0x06, 0x6e, 0x06,
+    0x00, 0x00, 0xa1, 0x06, 0x27, 0x06, 0x00, 0x01,
+    0x05, 0x08, 0x20, 0x21, 0x0b, 0x06, 0x10, 0x23,
     0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
     0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06,
-    0x0c, 0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00, 0x2c,
-    0x00, 0x28, 0x00, 0x41, 0x00, 0x29, 0x00, 0x14,
-    0x30, 0x53, 0x00, 0x15, 0x30, 0x43, 0x52, 0x43,
-    0x44, 0x57, 0x5a, 0x41, 0x00, 0x48, 0x56, 0x4d,
-    0x56, 0x53, 0x44, 0x53, 0x53, 0x50, 0x50, 0x56,
-    0x57, 0x43, 0x4d, 0x43, 0x4d, 0x44, 0x4d, 0x52,
-    0x44, 0x4a, 0x4b, 0x30, 0x30, 0x00, 0x68, 0x68,
-    0x4b, 0x62, 0x57, 0x5b, 0xcc, 0x53, 0xc7, 0x30,
-    0x8c, 0x4e, 0x1a, 0x59, 0xe3, 0x89, 0x29, 0x59,
-    0xa4, 0x4e, 0x20, 0x66, 0x21, 0x71, 0x99, 0x65,
-    0x4d, 0x52, 0x8c, 0x5f, 0x8d, 0x51, 0xb0, 0x65,
-    0x1d, 0x52, 0x42, 0x7d, 0x1f, 0x75, 0xa9, 0x8c,
-    0xf0, 0x58, 0x39, 0x54, 0x14, 0x6f, 0x95, 0x62,
-    0x55, 0x63, 0x00, 0x4e, 0x09, 0x4e, 0x4a, 0x90,
-    0xe6, 0x5d, 0x2d, 0x4e, 0xf3, 0x53, 0x07, 0x63,
-    0x70, 0x8d, 0x53, 0x62, 0x81, 0x79, 0x7a, 0x7a,
-    0x08, 0x54, 0x80, 0x6e, 0x09, 0x67, 0x08, 0x67,
-    0x33, 0x75, 0x72, 0x52, 0xb6, 0x55, 0x4d, 0x91,
-    0x14, 0x30, 0x15, 0x30, 0x2c, 0x67, 0x09, 0x4e,
-    0x8c, 0x4e, 0x89, 0x5b, 0xb9, 0x70, 0x53, 0x62,
-    0xd7, 0x76, 0xdd, 0x52, 0x57, 0x65, 0x97, 0x5f,
-    0xef, 0x53, 0x30, 0x00, 0x38, 0x4e, 0x05, 0x00,
-    0x09, 0x22, 0x01, 0x60, 0x4f, 0xae, 0x4f, 0xbb,
-    0x4f, 0x02, 0x50, 0x7a, 0x50, 0x99, 0x50, 0xe7,
-    0x50, 0xcf, 0x50, 0x9e, 0x34, 0x3a, 0x06, 0x4d,
-    0x51, 0x54, 0x51, 0x64, 0x51, 0x77, 0x51, 0x1c,
-    0x05, 0xb9, 0x34, 0x67, 0x51, 0x8d, 0x51, 0x4b,
-    0x05, 0x97, 0x51, 0xa4, 0x51, 0xcc, 0x4e, 0xac,
-    0x51, 0xb5, 0x51, 0xdf, 0x91, 0xf5, 0x51, 0x03,
-    0x52, 0xdf, 0x34, 0x3b, 0x52, 0x46, 0x52, 0x72,
-    0x52, 0x77, 0x52, 0x15, 0x35, 0x02, 0x00, 0x20,
-    0x80, 0x80, 0x00, 0x08, 0x00, 0x00, 0xc7, 0x52,
-    0x00, 0x02, 0x1d, 0x33, 0x3e, 0x3f, 0x50, 0x82,
-    0x8a, 0x93, 0xac, 0xb6, 0xb8, 0xb8, 0xb8, 0x2c,
-    0x0a, 0x70, 0x70, 0xca, 0x53, 0xdf, 0x53, 0x63,
-    0x0b, 0xeb, 0x53, 0xf1, 0x53, 0x06, 0x54, 0x9e,
-    0x54, 0x38, 0x54, 0x48, 0x54, 0x68, 0x54, 0xa2,
-    0x54, 0xf6, 0x54, 0x10, 0x55, 0x53, 0x55, 0x63,
-    0x55, 0x84, 0x55, 0x84, 0x55, 0x99, 0x55, 0xab,
-    0x55, 0xb3, 0x55, 0xc2, 0x55, 0x16, 0x57, 0x06,
-    0x56, 0x17, 0x57, 0x51, 0x56, 0x74, 0x56, 0x07,
-    0x52, 0xee, 0x58, 0xce, 0x57, 0xf4, 0x57, 0x0d,
-    0x58, 0x8b, 0x57, 0x32, 0x58, 0x31, 0x58, 0xac,
-    0x58, 0xe4, 0x14, 0xf2, 0x58, 0xf7, 0x58, 0x06,
-    0x59, 0x1a, 0x59, 0x22, 0x59, 0x62, 0x59, 0xa8,
-    0x16, 0xea, 0x16, 0xec, 0x59, 0x1b, 0x5a, 0x27,
-    0x5a, 0xd8, 0x59, 0x66, 0x5a, 0xee, 0x36, 0xfc,
-    0x36, 0x08, 0x5b, 0x3e, 0x5b, 0x3e, 0x5b, 0xc8,
-    0x19, 0xc3, 0x5b, 0xd8, 0x5b, 0xe7, 0x5b, 0xf3,
-    0x5b, 0x18, 0x1b, 0xff, 0x5b, 0x06, 0x5c, 0x53,
-    0x5f, 0x22, 0x5c, 0x81, 0x37, 0x60, 0x5c, 0x6e,
-    0x5c, 0xc0, 0x5c, 0x8d, 0x5c, 0xe4, 0x1d, 0x43,
-    0x5d, 0xe6, 0x1d, 0x6e, 0x5d, 0x6b, 0x5d, 0x7c,
-    0x5d, 0xe1, 0x5d, 0xe2, 0x5d, 0x2f, 0x38, 0xfd,
-    0x5d, 0x28, 0x5e, 0x3d, 0x5e, 0x69, 0x5e, 0x62,
-    0x38, 0x83, 0x21, 0x7c, 0x38, 0xb0, 0x5e, 0xb3,
-    0x5e, 0xb6, 0x5e, 0xca, 0x5e, 0x92, 0xa3, 0xfe,
-    0x5e, 0x31, 0x23, 0x31, 0x23, 0x01, 0x82, 0x22,
-    0x5f, 0x22, 0x5f, 0xc7, 0x38, 0xb8, 0x32, 0xda,
-    0x61, 0x62, 0x5f, 0x6b, 0x5f, 0xe3, 0x38, 0x9a,
-    0x5f, 0xcd, 0x5f, 0xd7, 0x5f, 0xf9, 0x5f, 0x81,
-    0x60, 0x3a, 0x39, 0x1c, 0x39, 0x94, 0x60, 0xd4,
-    0x26, 0xc7, 0x60, 0x02, 0x02, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00,
-    0x00, 0x02, 0x08, 0x00, 0x80, 0x08, 0x00, 0x00,
-    0x08, 0x80, 0x28, 0x80, 0x02, 0x00, 0x00, 0x02,
-    0x48, 0x61, 0x00, 0x04, 0x06, 0x04, 0x32, 0x46,
-    0x6a, 0x5c, 0x67, 0x96, 0xaa, 0xae, 0xc8, 0xd3,
-    0x5d, 0x62, 0x00, 0x54, 0x77, 0xf3, 0x0c, 0x2b,
-    0x3d, 0x63, 0xfc, 0x62, 0x68, 0x63, 0x83, 0x63,
-    0xe4, 0x63, 0xf1, 0x2b, 0x22, 0x64, 0xc5, 0x63,
-    0xa9, 0x63, 0x2e, 0x3a, 0x69, 0x64, 0x7e, 0x64,
-    0x9d, 0x64, 0x77, 0x64, 0x6c, 0x3a, 0x4f, 0x65,
-    0x6c, 0x65, 0x0a, 0x30, 0xe3, 0x65, 0xf8, 0x66,
-    0x49, 0x66, 0x19, 0x3b, 0x91, 0x66, 0x08, 0x3b,
-    0xe4, 0x3a, 0x92, 0x51, 0x95, 0x51, 0x00, 0x67,
-    0x9c, 0x66, 0xad, 0x80, 0xd9, 0x43, 0x17, 0x67,
-    0x1b, 0x67, 0x21, 0x67, 0x5e, 0x67, 0x53, 0x67,
-    0xc3, 0x33, 0x49, 0x3b, 0xfa, 0x67, 0x85, 0x67,
-    0x52, 0x68, 0x85, 0x68, 0x6d, 0x34, 0x8e, 0x68,
-    0x1f, 0x68, 0x14, 0x69, 0x9d, 0x3b, 0x42, 0x69,
-    0xa3, 0x69, 0xea, 0x69, 0xa8, 0x6a, 0xa3, 0x36,
-    0xdb, 0x6a, 0x18, 0x3c, 0x21, 0x6b, 0xa7, 0x38,
-    0x54, 0x6b, 0x4e, 0x3c, 0x72, 0x6b, 0x9f, 0x6b,
-    0xba, 0x6b, 0xbb, 0x6b, 0x8d, 0x3a, 0x0b, 0x1d,
-    0xfa, 0x3a, 0x4e, 0x6c, 0xbc, 0x3c, 0xbf, 0x6c,
-    0xcd, 0x6c, 0x67, 0x6c, 0x16, 0x6d, 0x3e, 0x6d,
-    0x77, 0x6d, 0x41, 0x6d, 0x69, 0x6d, 0x78, 0x6d,
-    0x85, 0x6d, 0x1e, 0x3d, 0x34, 0x6d, 0x2f, 0x6e,
-    0x6e, 0x6e, 0x33, 0x3d, 0xcb, 0x6e, 0xc7, 0x6e,
-    0xd1, 0x3e, 0xf9, 0x6d, 0x6e, 0x6f, 0x5e, 0x3f,
-    0x8e, 0x3f, 0xc6, 0x6f, 0x39, 0x70, 0x1e, 0x70,
-    0x1b, 0x70, 0x96, 0x3d, 0x4a, 0x70, 0x7d, 0x70,
-    0x77, 0x70, 0xad, 0x70, 0x25, 0x05, 0x45, 0x71,
-    0x63, 0x42, 0x9c, 0x71, 0xab, 0x43, 0x28, 0x72,
-    0x35, 0x72, 0x50, 0x72, 0x08, 0x46, 0x80, 0x72,
-    0x95, 0x72, 0x35, 0x47, 0x02, 0x20, 0x00, 0x00,
-    0x20, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80, 0x00,
-    0x00, 0x02, 0x02, 0x80, 0x8a, 0x00, 0x00, 0x20,
-    0x00, 0x08, 0x0a, 0x00, 0x80, 0x88, 0x80, 0x20,
-    0x14, 0x48, 0x7a, 0x73, 0x8b, 0x73, 0xac, 0x3e,
-    0xa5, 0x73, 0xb8, 0x3e, 0xb8, 0x3e, 0x47, 0x74,
-    0x5c, 0x74, 0x71, 0x74, 0x85, 0x74, 0xca, 0x74,
-    0x1b, 0x3f, 0x24, 0x75, 0x36, 0x4c, 0x3e, 0x75,
-    0x92, 0x4c, 0x70, 0x75, 0x9f, 0x21, 0x10, 0x76,
-    0xa1, 0x4f, 0xb8, 0x4f, 0x44, 0x50, 0xfc, 0x3f,
-    0x08, 0x40, 0xf4, 0x76, 0xf3, 0x50, 0xf2, 0x50,
-    0x19, 0x51, 0x33, 0x51, 0x1e, 0x77, 0x1f, 0x77,
-    0x1f, 0x77, 0x4a, 0x77, 0x39, 0x40, 0x8b, 0x77,
-    0x46, 0x40, 0x96, 0x40, 0x1d, 0x54, 0x4e, 0x78,
-    0x8c, 0x78, 0xcc, 0x78, 0xe3, 0x40, 0x26, 0x56,
-    0x56, 0x79, 0x9a, 0x56, 0xc5, 0x56, 0x8f, 0x79,
-    0xeb, 0x79, 0x2f, 0x41, 0x40, 0x7a, 0x4a, 0x7a,
-    0x4f, 0x7a, 0x7c, 0x59, 0xa7, 0x5a, 0xa7, 0x5a,
-    0xee, 0x7a, 0x02, 0x42, 0xab, 0x5b, 0xc6, 0x7b,
-    0xc9, 0x7b, 0x27, 0x42, 0x80, 0x5c, 0xd2, 0x7c,
-    0xa0, 0x42, 0xe8, 0x7c, 0xe3, 0x7c, 0x00, 0x7d,
-    0x86, 0x5f, 0x63, 0x7d, 0x01, 0x43, 0xc7, 0x7d,
-    0x02, 0x7e, 0x45, 0x7e, 0x34, 0x43, 0x28, 0x62,
-    0x47, 0x62, 0x59, 0x43, 0xd9, 0x62, 0x7a, 0x7f,
-    0x3e, 0x63, 0x95, 0x7f, 0xfa, 0x7f, 0x05, 0x80,
-    0xda, 0x64, 0x23, 0x65, 0x60, 0x80, 0xa8, 0x65,
-    0x70, 0x80, 0x5f, 0x33, 0xd5, 0x43, 0xb2, 0x80,
-    0x03, 0x81, 0x0b, 0x44, 0x3e, 0x81, 0xb5, 0x5a,
-    0xa7, 0x67, 0xb5, 0x67, 0x93, 0x33, 0x9c, 0x33,
-    0x01, 0x82, 0x04, 0x82, 0x9e, 0x8f, 0x6b, 0x44,
-    0x91, 0x82, 0x8b, 0x82, 0x9d, 0x82, 0xb3, 0x52,
-    0xb1, 0x82, 0xb3, 0x82, 0xbd, 0x82, 0xe6, 0x82,
-    0x3c, 0x6b, 0xe5, 0x82, 0x1d, 0x83, 0x63, 0x83,
-    0xad, 0x83, 0x23, 0x83, 0xbd, 0x83, 0xe7, 0x83,
-    0x57, 0x84, 0x53, 0x83, 0xca, 0x83, 0xcc, 0x83,
-    0xdc, 0x83, 0x36, 0x6c, 0x6b, 0x6d, 0x02, 0x00,
-    0x00, 0x20, 0x22, 0x2a, 0xa0, 0x0a, 0x00, 0x20,
-    0x80, 0x28, 0x00, 0xa8, 0x20, 0x20, 0x00, 0x02,
-    0x80, 0x22, 0x02, 0x8a, 0x08, 0x00, 0xaa, 0x00,
-    0x00, 0x00, 0x02, 0x00, 0x00, 0x28, 0xd5, 0x6c,
-    0x2b, 0x45, 0xf1, 0x84, 0xf3, 0x84, 0x16, 0x85,
-    0xca, 0x73, 0x64, 0x85, 0x2c, 0x6f, 0x5d, 0x45,
-    0x61, 0x45, 0xb1, 0x6f, 0xd2, 0x70, 0x6b, 0x45,
-    0x50, 0x86, 0x5c, 0x86, 0x67, 0x86, 0x69, 0x86,
-    0xa9, 0x86, 0x88, 0x86, 0x0e, 0x87, 0xe2, 0x86,
-    0x79, 0x87, 0x28, 0x87, 0x6b, 0x87, 0x86, 0x87,
-    0xd7, 0x45, 0xe1, 0x87, 0x01, 0x88, 0xf9, 0x45,
-    0x60, 0x88, 0x63, 0x88, 0x67, 0x76, 0xd7, 0x88,
-    0xde, 0x88, 0x35, 0x46, 0xfa, 0x88, 0xbb, 0x34,
-    0xae, 0x78, 0x66, 0x79, 0xbe, 0x46, 0xc7, 0x46,
-    0xa0, 0x8a, 0xed, 0x8a, 0x8a, 0x8b, 0x55, 0x8c,
-    0xa8, 0x7c, 0xab, 0x8c, 0xc1, 0x8c, 0x1b, 0x8d,
-    0x77, 0x8d, 0x2f, 0x7f, 0x04, 0x08, 0xcb, 0x8d,
-    0xbc, 0x8d, 0xf0, 0x8d, 0xde, 0x08, 0xd4, 0x8e,
-    0x38, 0x8f, 0xd2, 0x85, 0xed, 0x85, 0x94, 0x90,
-    0xf1, 0x90, 0x11, 0x91, 0x2e, 0x87, 0x1b, 0x91,
-    0x38, 0x92, 0xd7, 0x92, 0xd8, 0x92, 0x7c, 0x92,
-    0xf9, 0x93, 0x15, 0x94, 0xfa, 0x8b, 0x8b, 0x95,
-    0x95, 0x49, 0xb7, 0x95, 0x77, 0x8d, 0xe6, 0x49,
-    0xc3, 0x96, 0xb2, 0x5d, 0x23, 0x97, 0x45, 0x91,
-    0x1a, 0x92, 0x6e, 0x4a, 0x76, 0x4a, 0xe0, 0x97,
-    0x0a, 0x94, 0xb2, 0x4a, 0x96, 0x94, 0x0b, 0x98,
-    0x0b, 0x98, 0x29, 0x98, 0xb6, 0x95, 0xe2, 0x98,
-    0x33, 0x4b, 0x29, 0x99, 0xa7, 0x99, 0xc2, 0x99,
-    0xfe, 0x99, 0xce, 0x4b, 0x30, 0x9b, 0x12, 0x9b,
-    0x40, 0x9c, 0xfd, 0x9c, 0xce, 0x4c, 0xed, 0x4c,
-    0x67, 0x9d, 0xce, 0xa0, 0xf8, 0x4c, 0x05, 0xa1,
-    0x0e, 0xa2, 0x91, 0xa2, 0xbb, 0x9e, 0x56, 0x4d,
-    0xf9, 0x9e, 0xfe, 0x9e, 0x05, 0x9f, 0x0f, 0x9f,
-    0x16, 0x9f, 0x3b, 0x9f, 0x00, 0xa6, 0x02, 0x88,
-    0xa0, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x28,
-    0x00, 0x08, 0xa0, 0x80, 0xa0, 0x80, 0x00, 0x80,
-    0x80, 0x00, 0x0a, 0x88, 0x80, 0x00, 0x80, 0x00,
-    0x20, 0x2a, 0x00, 0x80,
+    0x0c, 0x0e, 0x10, 0x28, 0x06, 0x2c, 0x06, 0x2f,
+    0x06, 0x00, 0x00, 0x48, 0x06, 0x32, 0x06, 0x2d,
+    0x06, 0x37, 0x06, 0x4a, 0x06, 0x2a, 0x06, 0x1a,
+    0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07,
+    0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10,
+    0x30, 0x2e, 0x30, 0x00, 0x2c, 0x00, 0x28, 0x00,
+    0x41, 0x00, 0x29, 0x00, 0x14, 0x30, 0x53, 0x00,
+    0x15, 0x30, 0x43, 0x52, 0x43, 0x44, 0x57, 0x5a,
+    0x41, 0x00, 0x48, 0x56, 0x4d, 0x56, 0x53, 0x44,
+    0x53, 0x53, 0x50, 0x50, 0x56, 0x57, 0x43, 0x4d,
+    0x43, 0x4d, 0x44, 0x4d, 0x52, 0x44, 0x4a, 0x4b,
+    0x30, 0x30, 0x00, 0x68, 0x68, 0x4b, 0x62, 0x57,
+    0x5b, 0xcc, 0x53, 0xc7, 0x30, 0x8c, 0x4e, 0x1a,
+    0x59, 0xe3, 0x89, 0x29, 0x59, 0xa4, 0x4e, 0x20,
+    0x66, 0x21, 0x71, 0x99, 0x65, 0x4d, 0x52, 0x8c,
+    0x5f, 0x8d, 0x51, 0xb0, 0x65, 0x1d, 0x52, 0x42,
+    0x7d, 0x1f, 0x75, 0xa9, 0x8c, 0xf0, 0x58, 0x39,
+    0x54, 0x14, 0x6f, 0x95, 0x62, 0x55, 0x63, 0x00,
+    0x4e, 0x09, 0x4e, 0x4a, 0x90, 0xe6, 0x5d, 0x2d,
+    0x4e, 0xf3, 0x53, 0x07, 0x63, 0x70, 0x8d, 0x53,
+    0x62, 0x81, 0x79, 0x7a, 0x7a, 0x08, 0x54, 0x80,
+    0x6e, 0x09, 0x67, 0x08, 0x67, 0x33, 0x75, 0x72,
+    0x52, 0xb6, 0x55, 0x4d, 0x91, 0x14, 0x30, 0x15,
+    0x30, 0x2c, 0x67, 0x09, 0x4e, 0x8c, 0x4e, 0x89,
+    0x5b, 0xb9, 0x70, 0x53, 0x62, 0xd7, 0x76, 0xdd,
+    0x52, 0x57, 0x65, 0x97, 0x5f, 0xef, 0x53, 0x30,
+    0x00, 0x38, 0x4e, 0x05, 0x00, 0x09, 0x22, 0x01,
+    0x60, 0x4f, 0xae, 0x4f, 0xbb, 0x4f, 0x02, 0x50,
+    0x7a, 0x50, 0x99, 0x50, 0xe7, 0x50, 0xcf, 0x50,
+    0x9e, 0x34, 0x3a, 0x06, 0x4d, 0x51, 0x54, 0x51,
+    0x64, 0x51, 0x77, 0x51, 0x1c, 0x05, 0xb9, 0x34,
+    0x67, 0x51, 0x8d, 0x51, 0x4b, 0x05, 0x97, 0x51,
+    0xa4, 0x51, 0xcc, 0x4e, 0xac, 0x51, 0xb5, 0x51,
+    0xdf, 0x91, 0xf5, 0x51, 0x03, 0x52, 0xdf, 0x34,
+    0x3b, 0x52, 0x46, 0x52, 0x72, 0x52, 0x77, 0x52,
+    0x15, 0x35, 0x02, 0x00, 0x20, 0x80, 0x80, 0x00,
+    0x08, 0x00, 0x00, 0xc7, 0x52, 0x00, 0x02, 0x1d,
+    0x33, 0x3e, 0x3f, 0x50, 0x82, 0x8a, 0x93, 0xac,
+    0xb6, 0xb8, 0xb8, 0xb8, 0x2c, 0x0a, 0x70, 0x70,
+    0xca, 0x53, 0xdf, 0x53, 0x63, 0x0b, 0xeb, 0x53,
+    0xf1, 0x53, 0x06, 0x54, 0x9e, 0x54, 0x38, 0x54,
+    0x48, 0x54, 0x68, 0x54, 0xa2, 0x54, 0xf6, 0x54,
+    0x10, 0x55, 0x53, 0x55, 0x63, 0x55, 0x84, 0x55,
+    0x84, 0x55, 0x99, 0x55, 0xab, 0x55, 0xb3, 0x55,
+    0xc2, 0x55, 0x16, 0x57, 0x06, 0x56, 0x17, 0x57,
+    0x51, 0x56, 0x74, 0x56, 0x07, 0x52, 0xee, 0x58,
+    0xce, 0x57, 0xf4, 0x57, 0x0d, 0x58, 0x8b, 0x57,
+    0x32, 0x58, 0x31, 0x58, 0xac, 0x58, 0xe4, 0x14,
+    0xf2, 0x58, 0xf7, 0x58, 0x06, 0x59, 0x1a, 0x59,
+    0x22, 0x59, 0x62, 0x59, 0xa8, 0x16, 0xea, 0x16,
+    0xec, 0x59, 0x1b, 0x5a, 0x27, 0x5a, 0xd8, 0x59,
+    0x66, 0x5a, 0xee, 0x36, 0xfc, 0x36, 0x08, 0x5b,
+    0x3e, 0x5b, 0x3e, 0x5b, 0xc8, 0x19, 0xc3, 0x5b,
+    0xd8, 0x5b, 0xe7, 0x5b, 0xf3, 0x5b, 0x18, 0x1b,
+    0xff, 0x5b, 0x06, 0x5c, 0x53, 0x5f, 0x22, 0x5c,
+    0x81, 0x37, 0x60, 0x5c, 0x6e, 0x5c, 0xc0, 0x5c,
+    0x8d, 0x5c, 0xe4, 0x1d, 0x43, 0x5d, 0xe6, 0x1d,
+    0x6e, 0x5d, 0x6b, 0x5d, 0x7c, 0x5d, 0xe1, 0x5d,
+    0xe2, 0x5d, 0x2f, 0x38, 0xfd, 0x5d, 0x28, 0x5e,
+    0x3d, 0x5e, 0x69, 0x5e, 0x62, 0x38, 0x83, 0x21,
+    0x7c, 0x38, 0xb0, 0x5e, 0xb3, 0x5e, 0xb6, 0x5e,
+    0xca, 0x5e, 0x92, 0xa3, 0xfe, 0x5e, 0x31, 0x23,
+    0x31, 0x23, 0x01, 0x82, 0x22, 0x5f, 0x22, 0x5f,
+    0xc7, 0x38, 0xb8, 0x32, 0xda, 0x61, 0x62, 0x5f,
+    0x6b, 0x5f, 0xe3, 0x38, 0x9a, 0x5f, 0xcd, 0x5f,
+    0xd7, 0x5f, 0xf9, 0x5f, 0x81, 0x60, 0x3a, 0x39,
+    0x1c, 0x39, 0x94, 0x60, 0xd4, 0x26, 0xc7, 0x60,
+    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x08,
+    0x00, 0x80, 0x08, 0x00, 0x00, 0x08, 0x80, 0x28,
+    0x80, 0x02, 0x00, 0x00, 0x02, 0x48, 0x61, 0x00,
+    0x04, 0x06, 0x04, 0x32, 0x46, 0x6a, 0x5c, 0x67,
+    0x96, 0xaa, 0xae, 0xc8, 0xd3, 0x5d, 0x62, 0x00,
+    0x54, 0x77, 0xf3, 0x0c, 0x2b, 0x3d, 0x63, 0xfc,
+    0x62, 0x68, 0x63, 0x83, 0x63, 0xe4, 0x63, 0xf1,
+    0x2b, 0x22, 0x64, 0xc5, 0x63, 0xa9, 0x63, 0x2e,
+    0x3a, 0x69, 0x64, 0x7e, 0x64, 0x9d, 0x64, 0x77,
+    0x64, 0x6c, 0x3a, 0x4f, 0x65, 0x6c, 0x65, 0x0a,
+    0x30, 0xe3, 0x65, 0xf8, 0x66, 0x49, 0x66, 0x19,
+    0x3b, 0x91, 0x66, 0x08, 0x3b, 0xe4, 0x3a, 0x92,
+    0x51, 0x95, 0x51, 0x00, 0x67, 0x9c, 0x66, 0xad,
+    0x80, 0xd9, 0x43, 0x17, 0x67, 0x1b, 0x67, 0x21,
+    0x67, 0x5e, 0x67, 0x53, 0x67, 0xc3, 0x33, 0x49,
+    0x3b, 0xfa, 0x67, 0x85, 0x67, 0x52, 0x68, 0x85,
+    0x68, 0x6d, 0x34, 0x8e, 0x68, 0x1f, 0x68, 0x14,
+    0x69, 0x9d, 0x3b, 0x42, 0x69, 0xa3, 0x69, 0xea,
+    0x69, 0xa8, 0x6a, 0xa3, 0x36, 0xdb, 0x6a, 0x18,
+    0x3c, 0x21, 0x6b, 0xa7, 0x38, 0x54, 0x6b, 0x4e,
+    0x3c, 0x72, 0x6b, 0x9f, 0x6b, 0xba, 0x6b, 0xbb,
+    0x6b, 0x8d, 0x3a, 0x0b, 0x1d, 0xfa, 0x3a, 0x4e,
+    0x6c, 0xbc, 0x3c, 0xbf, 0x6c, 0xcd, 0x6c, 0x67,
+    0x6c, 0x16, 0x6d, 0x3e, 0x6d, 0x77, 0x6d, 0x41,
+    0x6d, 0x69, 0x6d, 0x78, 0x6d, 0x85, 0x6d, 0x1e,
+    0x3d, 0x34, 0x6d, 0x2f, 0x6e, 0x6e, 0x6e, 0x33,
+    0x3d, 0xcb, 0x6e, 0xc7, 0x6e, 0xd1, 0x3e, 0xf9,
+    0x6d, 0x6e, 0x6f, 0x5e, 0x3f, 0x8e, 0x3f, 0xc6,
+    0x6f, 0x39, 0x70, 0x1e, 0x70, 0x1b, 0x70, 0x96,
+    0x3d, 0x4a, 0x70, 0x7d, 0x70, 0x77, 0x70, 0xad,
+    0x70, 0x25, 0x05, 0x45, 0x71, 0x63, 0x42, 0x9c,
+    0x71, 0xab, 0x43, 0x28, 0x72, 0x35, 0x72, 0x50,
+    0x72, 0x08, 0x46, 0x80, 0x72, 0x95, 0x72, 0x35,
+    0x47, 0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00,
+    0x00, 0x00, 0x08, 0x80, 0x00, 0x00, 0x02, 0x02,
+    0x80, 0x8a, 0x00, 0x00, 0x20, 0x00, 0x08, 0x0a,
+    0x00, 0x80, 0x88, 0x80, 0x20, 0x14, 0x48, 0x7a,
+    0x73, 0x8b, 0x73, 0xac, 0x3e, 0xa5, 0x73, 0xb8,
+    0x3e, 0xb8, 0x3e, 0x47, 0x74, 0x5c, 0x74, 0x71,
+    0x74, 0x85, 0x74, 0xca, 0x74, 0x1b, 0x3f, 0x24,
+    0x75, 0x36, 0x4c, 0x3e, 0x75, 0x92, 0x4c, 0x70,
+    0x75, 0x9f, 0x21, 0x10, 0x76, 0xa1, 0x4f, 0xb8,
+    0x4f, 0x44, 0x50, 0xfc, 0x3f, 0x08, 0x40, 0xf4,
+    0x76, 0xf3, 0x50, 0xf2, 0x50, 0x19, 0x51, 0x33,
+    0x51, 0x1e, 0x77, 0x1f, 0x77, 0x1f, 0x77, 0x4a,
+    0x77, 0x39, 0x40, 0x8b, 0x77, 0x46, 0x40, 0x96,
+    0x40, 0x1d, 0x54, 0x4e, 0x78, 0x8c, 0x78, 0xcc,
+    0x78, 0xe3, 0x40, 0x26, 0x56, 0x56, 0x79, 0x9a,
+    0x56, 0xc5, 0x56, 0x8f, 0x79, 0xeb, 0x79, 0x2f,
+    0x41, 0x40, 0x7a, 0x4a, 0x7a, 0x4f, 0x7a, 0x7c,
+    0x59, 0xa7, 0x5a, 0xa7, 0x5a, 0xee, 0x7a, 0x02,
+    0x42, 0xab, 0x5b, 0xc6, 0x7b, 0xc9, 0x7b, 0x27,
+    0x42, 0x80, 0x5c, 0xd2, 0x7c, 0xa0, 0x42, 0xe8,
+    0x7c, 0xe3, 0x7c, 0x00, 0x7d, 0x86, 0x5f, 0x63,
+    0x7d, 0x01, 0x43, 0xc7, 0x7d, 0x02, 0x7e, 0x45,
+    0x7e, 0x34, 0x43, 0x28, 0x62, 0x47, 0x62, 0x59,
+    0x43, 0xd9, 0x62, 0x7a, 0x7f, 0x3e, 0x63, 0x95,
+    0x7f, 0xfa, 0x7f, 0x05, 0x80, 0xda, 0x64, 0x23,
+    0x65, 0x60, 0x80, 0xa8, 0x65, 0x70, 0x80, 0x5f,
+    0x33, 0xd5, 0x43, 0xb2, 0x80, 0x03, 0x81, 0x0b,
+    0x44, 0x3e, 0x81, 0xb5, 0x5a, 0xa7, 0x67, 0xb5,
+    0x67, 0x93, 0x33, 0x9c, 0x33, 0x01, 0x82, 0x04,
+    0x82, 0x9e, 0x8f, 0x6b, 0x44, 0x91, 0x82, 0x8b,
+    0x82, 0x9d, 0x82, 0xb3, 0x52, 0xb1, 0x82, 0xb3,
+    0x82, 0xbd, 0x82, 0xe6, 0x82, 0x3c, 0x6b, 0xe5,
+    0x82, 0x1d, 0x83, 0x63, 0x83, 0xad, 0x83, 0x23,
+    0x83, 0xbd, 0x83, 0xe7, 0x83, 0x57, 0x84, 0x53,
+    0x83, 0xca, 0x83, 0xcc, 0x83, 0xdc, 0x83, 0x36,
+    0x6c, 0x6b, 0x6d, 0x02, 0x00, 0x00, 0x20, 0x22,
+    0x2a, 0xa0, 0x0a, 0x00, 0x20, 0x80, 0x28, 0x00,
+    0xa8, 0x20, 0x20, 0x00, 0x02, 0x80, 0x22, 0x02,
+    0x8a, 0x08, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x28, 0xd5, 0x6c, 0x2b, 0x45, 0xf1,
+    0x84, 0xf3, 0x84, 0x16, 0x85, 0xca, 0x73, 0x64,
+    0x85, 0x2c, 0x6f, 0x5d, 0x45, 0x61, 0x45, 0xb1,
+    0x6f, 0xd2, 0x70, 0x6b, 0x45, 0x50, 0x86, 0x5c,
+    0x86, 0x67, 0x86, 0x69, 0x86, 0xa9, 0x86, 0x88,
+    0x86, 0x0e, 0x87, 0xe2, 0x86, 0x79, 0x87, 0x28,
+    0x87, 0x6b, 0x87, 0x86, 0x87, 0xd7, 0x45, 0xe1,
+    0x87, 0x01, 0x88, 0xf9, 0x45, 0x60, 0x88, 0x63,
+    0x88, 0x67, 0x76, 0xd7, 0x88, 0xde, 0x88, 0x35,
+    0x46, 0xfa, 0x88, 0xbb, 0x34, 0xae, 0x78, 0x66,
+    0x79, 0xbe, 0x46, 0xc7, 0x46, 0xa0, 0x8a, 0xed,
+    0x8a, 0x8a, 0x8b, 0x55, 0x8c, 0xa8, 0x7c, 0xab,
+    0x8c, 0xc1, 0x8c, 0x1b, 0x8d, 0x77, 0x8d, 0x2f,
+    0x7f, 0x04, 0x08, 0xcb, 0x8d, 0xbc, 0x8d, 0xf0,
+    0x8d, 0xde, 0x08, 0xd4, 0x8e, 0x38, 0x8f, 0xd2,
+    0x85, 0xed, 0x85, 0x94, 0x90, 0xf1, 0x90, 0x11,
+    0x91, 0x2e, 0x87, 0x1b, 0x91, 0x38, 0x92, 0xd7,
+    0x92, 0xd8, 0x92, 0x7c, 0x92, 0xf9, 0x93, 0x15,
+    0x94, 0xfa, 0x8b, 0x8b, 0x95, 0x95, 0x49, 0xb7,
+    0x95, 0x77, 0x8d, 0xe6, 0x49, 0xc3, 0x96, 0xb2,
+    0x5d, 0x23, 0x97, 0x45, 0x91, 0x1a, 0x92, 0x6e,
+    0x4a, 0x76, 0x4a, 0xe0, 0x97, 0x0a, 0x94, 0xb2,
+    0x4a, 0x96, 0x94, 0x0b, 0x98, 0x0b, 0x98, 0x29,
+    0x98, 0xb6, 0x95, 0xe2, 0x98, 0x33, 0x4b, 0x29,
+    0x99, 0xa7, 0x99, 0xc2, 0x99, 0xfe, 0x99, 0xce,
+    0x4b, 0x30, 0x9b, 0x12, 0x9b, 0x40, 0x9c, 0xfd,
+    0x9c, 0xce, 0x4c, 0xed, 0x4c, 0x67, 0x9d, 0xce,
+    0xa0, 0xf8, 0x4c, 0x05, 0xa1, 0x0e, 0xa2, 0x91,
+    0xa2, 0xbb, 0x9e, 0x56, 0x4d, 0xf9, 0x9e, 0xfe,
+    0x9e, 0x05, 0x9f, 0x0f, 0x9f, 0x16, 0x9f, 0x3b,
+    0x9f, 0x00, 0xa6, 0x02, 0x88, 0xa0, 0x00, 0x00,
+    0x00, 0x00, 0x80, 0x00, 0x28, 0x00, 0x08, 0xa0,
+    0x80, 0xa0, 0x80, 0x00, 0x80, 0x80, 0x00, 0x0a,
+    0x88, 0x80, 0x00, 0x80, 0x00, 0x20, 0x2a, 0x00,
+    0x80,
 };
 
 static const uint16_t unicode_comp_table[945] = {
@@ -2313,7 +2335,7 @@ static const char unicode_gc_name_table[] =
     "C,Other"                  "\0"
 ;
 
-static const uint8_t unicode_gc_table[3897] = {
+static const uint8_t unicode_gc_table[3948] = {
     0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13,
     0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
     0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e,
@@ -2399,409 +2421,415 @@ static const uint8_t unicode_gc_table[3897] = {
     0x85, 0x20, 0x06, 0x05, 0x07, 0x06, 0x87, 0x00,
     0x06, 0x27, 0x00, 0x27, 0x26, 0xc0, 0x27, 0xa0,
     0x25, 0x00, 0x25, 0x26, 0x20, 0xe9, 0x02, 0x00,
-    0x25, 0xe0, 0x05, 0x26, 0x27, 0xe5, 0x01, 0x00,
-    0x45, 0x00, 0xe5, 0x21, 0x26, 0x05, 0x47, 0x66,
-    0x00, 0x47, 0x00, 0x47, 0x06, 0x05, 0x0f, 0x60,
-    0x45, 0x07, 0xcb, 0x45, 0x26, 0x20, 0xe9, 0x02,
-    0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06, 0x27, 0x00,
-    0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00, 0xe5, 0x01,
-    0x00, 0x05, 0x20, 0xc5, 0x40, 0x06, 0x60, 0x47,
-    0x46, 0x00, 0x06, 0x00, 0xe7, 0x00, 0xa0, 0xe9,
-    0x02, 0x20, 0x27, 0x16, 0xe0, 0x04, 0xe5, 0x28,
-    0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5, 0x04, 0xe6,
-    0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0, 0x1d, 0x25,
-    0x00, 0x05, 0x00, 0x85, 0x00, 0xe5, 0x10, 0x00,
-    0x05, 0x00, 0xe5, 0x02, 0x06, 0x25, 0xe6, 0x01,
-    0x05, 0x20, 0x85, 0x00, 0x04, 0x00, 0xa6, 0x20,
-    0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18, 0x05, 0x4f,
-    0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26, 0xaf, 0xe9,
-    0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f, 0x06, 0x0f,
-    0x06, 0x12, 0x13, 0x12, 0x13, 0x27, 0xe5, 0x00,
-    0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06, 0x07, 0x86,
-    0x16, 0x26, 0x85, 0xe6, 0x03, 0x00, 0xe6, 0x1c,
-    0x00, 0xef, 0x00, 0x06, 0xaf, 0x00, 0x2f, 0x96,
-    0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23, 0x27, 0x66,
-    0x07, 0xa6, 0x07, 0x26, 0x27, 0x26, 0x05, 0xe9,
-    0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65, 0x46, 0x05,
-    0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5, 0x05, 0x06,
-    0x27, 0x26, 0xa7, 0x06, 0x05, 0x07, 0xe9, 0x02,
-    0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00, 0x01, 0x80,
-    0x01, 0x20, 0xe2, 0x23, 0x16, 0x04, 0x42, 0xe5,
-    0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
-    0x00, 0x65, 0x20, 0xe5, 0x21, 0x00, 0x65, 0x20,
-    0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
-    0x00, 0x65, 0x20, 0xe5, 0x07, 0x00, 0xe5, 0x31,
-    0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20, 0x46, 0xf6,
-    0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08, 0xef, 0x02,
-    0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20, 0x11, 0xe5,
-    0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09, 0x17, 0xe5,
-    0x12, 0x12, 0x13, 0x40, 0xe5, 0x43, 0x56, 0x4a,
-    0xe5, 0x00, 0xc0, 0xe5, 0x0a, 0x46, 0x07, 0xe0,
-    0x01, 0xe5, 0x0b, 0x26, 0x07, 0x36, 0xe0, 0x01,
-    0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5, 0x05, 0x00,
-    0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5, 0x2c, 0x26,
-    0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27, 0xe6, 0x03,
-    0x56, 0x04, 0x56, 0x0d, 0x05, 0x06, 0x20, 0xe9,
-    0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6, 0x11, 0x76,
-    0x46, 0x1b, 0x06, 0xe9, 0x02, 0xa0, 0xe5, 0x1b,
-    0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26, 0xe5, 0x1a,
-    0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0, 0x02, 0xe5,
-    0x17, 0x00, 0x46, 0x67, 0x26, 0x47, 0x60, 0x27,
-    0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40, 0x36, 0xe9,
-    0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0, 0x03, 0xe5,
-    0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9, 0x02, 0x0b,
-    0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26, 0x27, 0x06,
-    0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06, 0x07, 0xc6,
-    0x00, 0x06, 0x07, 0x06, 0x27, 0xe6, 0x00, 0xa7,
-    0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02, 0xa0, 0xe9,
-    0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20, 0xe6, 0x06,
-    0x08, 0xe6, 0x08, 0xe0, 0x29, 0x66, 0x07, 0xe5,
-    0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87, 0x06,
-    0x27, 0xe5, 0x00, 0x40, 0xe9, 0x02, 0xd6, 0xef,
-    0x02, 0xe6, 0x01, 0xef, 0x01, 0x36, 0x00, 0x26,
-    0x07, 0xe5, 0x16, 0x07, 0x66, 0x27, 0x26, 0x07,
-    0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06, 0x07,
-    0x26, 0x47, 0x06, 0x07, 0x46, 0x27, 0xe0, 0x00,
-    0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00, 0x27,
-    0x26, 0x40, 0x96, 0xe9, 0x02, 0x40, 0x45, 0xe9,
-    0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01, 0xc0,
-    0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0, 0x00,
-    0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65, 0x06,
-    0xa5, 0x06, 0x25, 0x07, 0x26, 0x05, 0x80, 0xe2,
-    0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2, 0x1a,
-    0xe4, 0x1d, 0xe6, 0x38, 0xff, 0x80, 0x0e, 0xe2,
-    0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00, 0xa2,
-    0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00, 0xe2,
-    0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2,
-    0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-    0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20, 0xe2,
-    0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0xe2,
-    0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61, 0x03,
-    0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61, 0x03,
-    0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e, 0xe2,
-    0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22, 0x61,
-    0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1, 0x36,
-    0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14, 0xf6,
-    0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01, 0x14,
-    0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13, 0xf6,
-    0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17, 0x9b,
-    0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab, 0x4c,
-    0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12, 0x13,
-    0x00, 0xe4, 0x05, 0x40, 0xed, 0x19, 0xe0, 0x07,
-    0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04, 0xe0,
-    0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02, 0x41,
-    0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c, 0x81,
-    0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f, 0x61,
-    0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f, 0x22,
-    0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f, 0x02,
-    0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a, 0x0b,
-    0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c, 0x2f,
-    0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17, 0x2c,
-    0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec, 0x80,
-    0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13, 0xef,
-    0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49, 0x0c,
-    0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac, 0xef,
-    0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d, 0xeb,
-    0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80, 0x2f,
-    0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec, 0x00,
-    0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef, 0x24,
-    0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec,
-    0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x25, 0x07, 0xe0, 0x04, 0x26, 0x27, 0xe5, 0x01,
+    0x00, 0x45, 0x00, 0xe5, 0x21, 0x26, 0x05, 0x47,
+    0x66, 0x00, 0x47, 0x00, 0x47, 0x06, 0x05, 0x0f,
+    0x60, 0x45, 0x07, 0xcb, 0x45, 0x26, 0x20, 0xe9,
+    0x02, 0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06, 0x27,
+    0x00, 0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00, 0xe5,
+    0x01, 0x00, 0x05, 0x20, 0xc5, 0x40, 0x06, 0x60,
+    0x47, 0x46, 0x00, 0x06, 0x00, 0xe7, 0x00, 0xa0,
+    0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0, 0x04, 0xe5,
+    0x28, 0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5, 0x04,
+    0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0, 0x1d,
+    0x25, 0x00, 0x05, 0x00, 0x85, 0x00, 0xe5, 0x10,
+    0x00, 0x05, 0x00, 0xe5, 0x02, 0x06, 0x25, 0xe6,
+    0x01, 0x05, 0x20, 0x85, 0x00, 0x04, 0x00, 0xc6,
+    0x00, 0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18, 0x05,
+    0x4f, 0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26, 0xaf,
+    0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f, 0x06,
+    0x0f, 0x06, 0x12, 0x13, 0x12, 0x13, 0x27, 0xe5,
+    0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06, 0x07,
+    0x86, 0x16, 0x26, 0x85, 0xe6, 0x03, 0x00, 0xe6,
+    0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf, 0x00, 0x2f,
+    0x96, 0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23, 0x27,
+    0x66, 0x07, 0xa6, 0x07, 0x26, 0x27, 0x26, 0x05,
+    0xe9, 0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65, 0x46,
+    0x05, 0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5, 0x05,
+    0x06, 0x27, 0x26, 0xa7, 0x06, 0x05, 0x07, 0xe9,
+    0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00, 0x01,
+    0x80, 0x01, 0x20, 0xe2, 0x23, 0x16, 0x04, 0x42,
+    0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5, 0x00,
+    0x05, 0x00, 0x65, 0x20, 0xe5, 0x21, 0x00, 0x65,
+    0x20, 0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5, 0x00,
+    0x05, 0x00, 0x65, 0x20, 0xe5, 0x07, 0x00, 0xe5,
+    0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20, 0x46,
+    0xf6, 0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08, 0xef,
+    0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20, 0x11,
+    0xe5, 0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09, 0x17,
+    0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5, 0x43, 0x56,
+    0x4a, 0xe5, 0x00, 0xc0, 0xe5, 0x0a, 0x46, 0x07,
+    0xe0, 0x01, 0xe5, 0x0b, 0x26, 0x07, 0x36, 0xe0,
+    0x01, 0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5, 0x05,
+    0x00, 0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5, 0x2c,
+    0x26, 0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27, 0xe6,
+    0x03, 0x56, 0x04, 0x56, 0x0d, 0x05, 0x06, 0x20,
+    0xe9, 0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6, 0x11,
+    0x76, 0x46, 0x1b, 0x06, 0xe9, 0x02, 0xa0, 0xe5,
+    0x1b, 0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26, 0xe5,
+    0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0, 0x02,
+    0xe5, 0x17, 0x00, 0x46, 0x67, 0x26, 0x47, 0x60,
+    0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40, 0x36,
+    0xe9, 0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0, 0x03,
+    0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9, 0x02,
+    0x0b, 0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26, 0x27,
+    0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06, 0x07,
+    0xc6, 0x00, 0x06, 0x07, 0x06, 0x27, 0xe6, 0x00,
+    0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02, 0xa0,
+    0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20, 0xe6,
+    0x06, 0x08, 0xe6, 0x08, 0xe0, 0x29, 0x66, 0x07,
+    0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87,
+    0x06, 0x27, 0xe5, 0x00, 0x40, 0xe9, 0x02, 0xd6,
+    0xef, 0x02, 0xe6, 0x01, 0xef, 0x01, 0x36, 0x00,
+    0x26, 0x07, 0xe5, 0x16, 0x07, 0x66, 0x27, 0x26,
+    0x07, 0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06,
+    0x07, 0x26, 0x47, 0x06, 0x07, 0x46, 0x27, 0xe0,
+    0x00, 0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00,
+    0x27, 0x26, 0x40, 0x96, 0xe9, 0x02, 0x40, 0x45,
+    0xe9, 0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01,
+    0xc0, 0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0,
+    0x00, 0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65,
+    0x06, 0xa5, 0x06, 0x25, 0x07, 0x26, 0x05, 0x80,
+    0xe2, 0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2,
+    0x1a, 0xe4, 0x1d, 0xe6, 0x38, 0xff, 0x80, 0x0e,
+    0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00,
+    0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00,
+    0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20,
+    0xe2, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+    0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20,
+    0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00,
+    0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61,
+    0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61,
+    0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e,
+    0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22,
+    0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1,
+    0x36, 0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14,
+    0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01,
+    0x14, 0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13,
+    0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17,
+    0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab,
+    0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12,
+    0x13, 0x00, 0xe4, 0x05, 0x40, 0xed, 0x19, 0xe0,
+    0x07, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04,
+    0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02,
+    0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c,
+    0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f,
+    0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f,
+    0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f,
+    0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a,
+    0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c,
+    0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17,
+    0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec,
+    0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13,
+    0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49,
+    0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac,
+    0xef, 0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d,
+    0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80,
+    0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec,
+    0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef,
+    0x24, 0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12, 0x13,
-    0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec, 0x80,
-    0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac, 0xef,
-    0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61, 0xe1,
-    0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22, 0xdf, 0x41,
-    0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24, 0x41, 0x02,
-    0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f, 0x80,
-    0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00, 0x02, 0x80,
-    0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16, 0xe0,
-    0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01, 0xc5, 0x00,
-    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00,
-    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xe6, 0x18,
-    0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14, 0x15,
-    0x16, 0x14, 0x15, 0xf6, 0x01, 0x11, 0x36, 0x11,
-    0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x96, 0x04,
-    0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12, 0xf6,
-    0x05, 0x2f, 0x56, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a, 0xef, 0x12,
-    0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80, 0x4e,
-    0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56, 0x0f,
-    0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0x12,
-    0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11, 0x84,
-    0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00, 0xe5,
-    0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5,
-    0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23, 0x00,
-    0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5,
-    0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08, 0xef,
-    0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb, 0x00,
-    0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02, 0xef,
-    0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5, 0x99,
-    0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11, 0x8d, 0x04,
-    0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01,
-    0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84, 0x04,
-    0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c,
-    0xff, 0x26, 0x05, 0x06, 0x48, 0x16, 0xe6, 0x02,
-    0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e,
-    0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee, 0x0f,
-    0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36,
-    0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04, 0x2e,
-    0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02,
-    0x81, 0x02, 0xff, 0x07, 0x41, 0x02, 0x3f, 0x80,
-    0x3f, 0x00, 0x02, 0x00, 0x02, 0x7f, 0xe0, 0x10,
-    0x44, 0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06, 0x45,
-    0x06, 0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26, 0x07,
-    0x6f, 0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f, 0xa0,
-    0xe5, 0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5, 0x2a,
-    0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9, 0x02,
-    0xa0, 0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16, 0x25,
-    0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00, 0x36,
-    0xe5, 0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03, 0x16,
-    0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5, 0x27, 0x06,
-    0x27, 0x66, 0x27, 0x26, 0x47, 0xf6, 0x05, 0x00,
-    0x04, 0xe9, 0x02, 0x60, 0x36, 0x85, 0x06, 0x04,
-    0xe5, 0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5, 0x21,
-    0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0, 0x01, 0x45,
-    0x06, 0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9, 0x02,
-    0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f, 0x05,
-    0x07, 0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05, 0x46,
-    0x25, 0x26, 0x85, 0x26, 0x05, 0x06, 0x05, 0xe0,
-    0x10, 0x25, 0x04, 0x36, 0xe5, 0x03, 0x07, 0x26,
-    0x27, 0x36, 0x05, 0x24, 0x07, 0x06, 0xe0, 0x02,
-    0xa5, 0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01, 0xc5,
-    0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64, 0xe2,
-    0x01, 0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5, 0x1b,
-    0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06,
-    0x20, 0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c, 0xe0,
-    0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc,
-    0x87, 0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80, 0xe6,
-    0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04,
-    0x82, 0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c, 0xe5,
-    0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00,
-    0x25, 0x00, 0xe5, 0x64, 0xee, 0x09, 0xe0, 0x08,
-    0xe5, 0x80, 0xe3, 0x13, 0x12, 0xef, 0x08, 0xe5,
-    0x38, 0x20, 0xe5, 0x2e, 0xc0, 0x0f, 0xe0, 0x18,
-    0xe5, 0x04, 0x0d, 0x4f, 0xe6, 0x08, 0xd6, 0x12,
-    0x13, 0x16, 0xa0, 0xe6, 0x08, 0x16, 0x31, 0x30,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x36, 0x12, 0x13, 0x76, 0x50, 0x56, 0x00, 0x76,
-    0x11, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x56,
-    0x0c, 0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60,
-    0x85, 0x00, 0xe5, 0x7f, 0x20, 0x1b, 0x00, 0x56,
-    0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16, 0x11,
-    0x36, 0xe9, 0x02, 0x36, 0x4c, 0x36, 0xe1, 0x12,
-    0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12,
-    0x12, 0x0c, 0x13, 0x0c, 0x12, 0x13, 0x16, 0x12,
-    0x13, 0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24,
-    0xe5, 0x17, 0x40, 0xa5, 0x20, 0xa5, 0x20, 0xa5,
-    0x20, 0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d,
-    0x00, 0x0f, 0x6c, 0x2f, 0xe0, 0x02, 0x5b, 0x2f,
-    0x20, 0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5,
-    0x0b, 0x00, 0x25, 0x00, 0xe5, 0x07, 0x20, 0xe5,
-    0x06, 0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60,
-    0xeb, 0x25, 0x40, 0xef, 0x01, 0xea, 0x2d, 0x6b,
-    0xef, 0x09, 0x2b, 0x4f, 0x00, 0xef, 0x05, 0x40,
-    0x0f, 0xe0, 0x27, 0xef, 0x25, 0x06, 0xe0, 0x7a,
-    0xe5, 0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06,
-    0xeb, 0x13, 0x60, 0xe5, 0x18, 0x6b, 0xe0, 0x01,
-    0xe5, 0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5,
-    0x1e, 0x86, 0x80, 0xe5, 0x16, 0x00, 0x16, 0xe5,
-    0x1c, 0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22,
-    0xe1, 0x20, 0xe2, 0x20, 0xe5, 0x46, 0x20, 0xe9,
-    0x02, 0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60,
-    0xe5, 0x20, 0xe0, 0x00, 0xe5, 0x2c, 0xe0, 0x03,
-    0x16, 0xe1, 0x03, 0x00, 0xe1, 0x07, 0x00, 0xc1,
-    0x00, 0x21, 0x00, 0xe2, 0x03, 0x00, 0xe2, 0x07,
-    0x00, 0xc2, 0x00, 0x22, 0xe0, 0x3b, 0xe5, 0x80,
-    0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02, 0xe5,
-    0x00, 0xe0, 0x10, 0xa4, 0x00, 0xe4, 0x22, 0x00,
-    0xe4, 0x01, 0xe0, 0x3d, 0xa5, 0x20, 0x05, 0x00,
-    0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20, 0xe5,
-    0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f, 0x2f,
-    0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01, 0xe0,
-    0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b, 0xe5,
-    0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80, 0x16,
-    0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25, 0xeb,
-    0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00, 0x26,
-    0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5, 0x15,
-    0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0, 0xf6,
-    0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5, 0x15,
-    0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5, 0x14,
-    0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5, 0x2e,
-    0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00, 0xe5,
-    0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0, 0x76,
-    0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41, 0xe0,
-    0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b, 0xc0,
-    0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9, 0x02,
-    0xe0, 0x80, 0x9e, 0xeb, 0x17, 0x00, 0xe5, 0x22,
-    0x00, 0x26, 0x11, 0x20, 0x25, 0xe0, 0x46, 0xe5,
-    0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00, 0xe5, 0x0e,
-    0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x0e, 0xe5, 0x0a,
-    0x66, 0x76, 0xe0, 0x1e, 0xe5, 0x0d, 0xcb, 0xe0,
-    0x0c, 0xe5, 0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07,
-    0xe5, 0x2d, 0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c,
-    0xe9, 0x02, 0x06, 0x25, 0x26, 0x05, 0xe0, 0x01,
-    0x46, 0x07, 0xe5, 0x25, 0x47, 0x66, 0x27, 0x26,
-    0x36, 0x1b, 0x76, 0x06, 0xe0, 0x02, 0x1b, 0x20,
-    0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0, 0x46, 0xe5,
-    0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9, 0x02,
-    0x76, 0x05, 0x27, 0x05, 0xe0, 0x00, 0xe5, 0x1b,
-    0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07, 0xe5,
-    0x28, 0x47, 0xe6, 0x01, 0x27, 0x65, 0x76, 0x66,
-    0x16, 0x07, 0x06, 0xe9, 0x02, 0x05, 0x16, 0x05,
-    0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a,
-    0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07,
-    0x26, 0xb6, 0x06, 0xe0, 0x39, 0xc5, 0x00, 0x05,
-    0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02,
-    0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00,
-    0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5,
-    0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5,
-    0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27,
-    0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05,
-    0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40,
-    0x86, 0xe0, 0x80, 0x03, 0xe5, 0x2d, 0x47, 0xe6,
-    0x00, 0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9,
-    0x02, 0x36, 0x00, 0x16, 0x06, 0x45, 0xe0, 0x16,
-    0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06, 0x67, 0x26,
-    0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9,
-    0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47, 0x66,
-    0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f, 0x65,
-    0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6, 0x00,
-    0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03,
-    0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b, 0xe5,
-    0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06,
-    0x05, 0x16, 0xa0, 0xe9, 0x02, 0xe0, 0x2e, 0xe5,
-    0x13, 0x20, 0x46, 0x27, 0x66, 0x07, 0x86, 0x60,
-    0xe9, 0x02, 0x2b, 0x56, 0x0f, 0xc5, 0xe0, 0x80,
-    0x31, 0xe5, 0x24, 0x47, 0xe6, 0x01, 0x07, 0x26,
-    0x16, 0xe0, 0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9,
-    0x02, 0xeb, 0x01, 0xe0, 0x04, 0xe5, 0x00, 0x20,
-    0x05, 0x20, 0xe5, 0x00, 0x00, 0x25, 0x00, 0xe5,
-    0x10, 0xa7, 0x00, 0x27, 0x20, 0x26, 0x07, 0x06,
-    0x05, 0x07, 0x05, 0x07, 0x06, 0x56, 0xe0, 0x01,
-    0xe9, 0x02, 0xe0, 0x3e, 0xe5, 0x00, 0x20, 0xe5,
-    0x1f, 0x47, 0x66, 0x20, 0x26, 0x67, 0x06, 0x05,
-    0x16, 0x05, 0x07, 0xe0, 0x13, 0x05, 0xe6, 0x02,
-    0xe5, 0x20, 0xa6, 0x07, 0x05, 0x66, 0xf6, 0x00,
-    0x06, 0xe0, 0x00, 0x05, 0xa6, 0x27, 0x46, 0xe5,
-    0x26, 0xe6, 0x05, 0x07, 0x26, 0x56, 0x05, 0x96,
-    0xe0, 0x05, 0xe5, 0x41, 0xe0, 0x80, 0x7f, 0xe5,
-    0x01, 0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6,
-    0x07, 0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02,
-    0xeb, 0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6,
-    0x0e, 0x00, 0x07, 0xc6, 0x07, 0x26, 0x07, 0x26,
-    0xe0, 0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e,
-    0xa6, 0x40, 0x06, 0x00, 0x26, 0x00, 0xc6, 0x05,
-    0x06, 0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00,
-    0x25, 0x00, 0xe5, 0x18, 0x87, 0x00, 0x26, 0x00,
-    0x27, 0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02,
-    0xe0, 0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36,
-    0xe0, 0x80, 0x2f, 0x05, 0xe0, 0x07, 0xeb, 0x0d,
-    0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16,
-    0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea, 0x67, 0x00,
-    0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x89,
-    0xc4, 0xe5, 0x59, 0x36, 0xe0, 0x05, 0xe5, 0x83,
-    0xa7, 0x00, 0xfb, 0x01, 0xe0, 0x8f, 0x3f, 0xe5,
-    0x81, 0xbf, 0xe0, 0xa1, 0x31, 0xe5, 0x81, 0xb1,
-    0xc0, 0xe5, 0x17, 0x00, 0xe9, 0x02, 0x60, 0x36,
-    0xe5, 0x47, 0x00, 0xe9, 0x02, 0xa0, 0xe5, 0x16,
-    0x20, 0x86, 0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6,
-    0x96, 0x6f, 0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9,
-    0x02, 0x00, 0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5,
-    0x0b, 0xe0, 0x82, 0x28, 0xe1, 0x18, 0xe2, 0x18,
-    0xeb, 0x0f, 0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60,
-    0x06, 0x05, 0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05,
-    0xe0, 0x38, 0x24, 0x16, 0x04, 0x06, 0xe0, 0x03,
-    0x27, 0xe0, 0x06, 0xe5, 0x97, 0x70, 0xe0, 0x00,
-    0xe5, 0x84, 0x4e, 0xe0, 0x22, 0xe5, 0x01, 0xe0,
-    0xa2, 0x5f, 0x64, 0x00, 0xc4, 0x00, 0x24, 0x00,
-    0xe5, 0x80, 0x9b, 0xe0, 0x25, 0x45, 0xe0, 0x09,
-    0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0, 0x88,
-    0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05, 0x40, 0xe5,
-    0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26, 0x16,
-    0x7b, 0xe0, 0x91, 0xd4, 0xe6, 0x26, 0x20, 0xe6,
-    0x0f, 0xe0, 0x01, 0xef, 0x6c, 0xe0, 0x34, 0xef,
-    0x80, 0x6e, 0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef,
-    0x34, 0x27, 0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6,
-    0x00, 0x2f, 0xc6, 0xef, 0x16, 0x66, 0xef, 0x35,
-    0xe0, 0x0d, 0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x80,
-    0x12, 0xeb, 0x0c, 0xe0, 0x04, 0xef, 0x4f, 0xe0,
-    0x01, 0xeb, 0x11, 0xe0, 0x7f, 0xe1, 0x12, 0xe2,
-    0x12, 0xe1, 0x12, 0xc2, 0x00, 0xe2, 0x0a, 0xe1,
-    0x12, 0xe2, 0x12, 0x01, 0x00, 0x21, 0x20, 0x01,
-    0x20, 0x21, 0x20, 0x61, 0x00, 0xe1, 0x00, 0x62,
-    0x00, 0x02, 0x00, 0xc2, 0x00, 0xe2, 0x03, 0xe1,
-    0x12, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x20, 0xe1,
-    0x00, 0x00, 0xc1, 0x00, 0xe2, 0x12, 0x21, 0x00,
-    0x61, 0x00, 0x81, 0x00, 0x01, 0x40, 0xc1, 0x00,
-    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
-    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
-    0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
-    0xe2, 0x14, 0x20, 0xe1, 0x11, 0x0c, 0xe2, 0x11,
-    0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c,
-    0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2,
+    0xec, 0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12,
+    0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec,
+    0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac,
+    0xef, 0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61,
+    0xe1, 0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22, 0xdf,
+    0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24, 0x41,
+    0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f,
+    0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00, 0x02,
+    0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16,
+    0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01, 0xc5,
+    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
+    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xe6,
+    0x18, 0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14,
+    0x15, 0x16, 0x14, 0x15, 0xf6, 0x01, 0x11, 0x36,
+    0x11, 0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x96,
+    0x04, 0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12,
+    0xf6, 0x05, 0x2f, 0x56, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a, 0xef,
+    0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80,
+    0x4e, 0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56,
+    0x0f, 0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11,
+    0x12, 0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11,
+    0x84, 0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00,
+    0xe5, 0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11,
+    0xe5, 0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23,
+    0x00, 0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02,
+    0xe5, 0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08,
+    0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb,
+    0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02,
+    0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5,
+    0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11, 0x8d,
+    0x04, 0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0,
+    0x01, 0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84,
+    0x04, 0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0,
+    0x0c, 0xff, 0x26, 0x05, 0x06, 0x48, 0x16, 0xe6,
+    0x02, 0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5,
+    0x3e, 0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee,
+    0x0f, 0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff,
+    0x36, 0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04,
+    0x2e, 0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61,
+    0x02, 0x81, 0x02, 0xff, 0x07, 0x41, 0x02, 0x3f,
+    0x80, 0x3f, 0x00, 0x02, 0x00, 0x02, 0x7f, 0xe0,
+    0x10, 0x44, 0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06,
+    0x45, 0x06, 0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26,
+    0x07, 0x6f, 0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f,
+    0xa0, 0xe5, 0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5,
+    0x2a, 0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9,
+    0x02, 0xa0, 0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16,
+    0x25, 0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00,
+    0x36, 0xe5, 0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03,
+    0x16, 0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5, 0x27,
+    0x06, 0x27, 0x66, 0x27, 0x26, 0x47, 0xf6, 0x05,
+    0x00, 0x04, 0xe9, 0x02, 0x60, 0x36, 0x85, 0x06,
+    0x04, 0xe5, 0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5,
+    0x21, 0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0, 0x01,
+    0x45, 0x06, 0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9,
+    0x02, 0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f,
+    0x05, 0x07, 0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05,
+    0x46, 0x25, 0x26, 0x85, 0x26, 0x05, 0x06, 0x05,
+    0xe0, 0x10, 0x25, 0x04, 0x36, 0xe5, 0x03, 0x07,
+    0x26, 0x27, 0x36, 0x05, 0x24, 0x07, 0x06, 0xe0,
+    0x02, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01,
+    0xc5, 0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64,
+    0xe2, 0x01, 0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5,
+    0x1b, 0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07,
+    0x06, 0x20, 0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c,
+    0xe0, 0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60,
+    0xfc, 0x87, 0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80,
+    0xe6, 0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0,
+    0x04, 0x82, 0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c,
+    0xe5, 0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25,
+    0x00, 0x25, 0x00, 0xe5, 0x64, 0xee, 0x09, 0xe0,
+    0x08, 0xe5, 0x80, 0xe3, 0x13, 0x12, 0xef, 0x08,
+    0xe5, 0x38, 0x20, 0xe5, 0x2e, 0xc0, 0x0f, 0xe0,
+    0x18, 0xe5, 0x04, 0x0d, 0x4f, 0xe6, 0x08, 0xd6,
+    0x12, 0x13, 0x16, 0xa0, 0xe6, 0x08, 0x16, 0x31,
+    0x30, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x13, 0x36, 0x12, 0x13, 0x76, 0x50, 0x56, 0x00,
+    0x76, 0x11, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36,
+    0x60, 0x85, 0x00, 0xe5, 0x7f, 0x20, 0x1b, 0x00,
+    0x56, 0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16,
+    0x11, 0x36, 0xe9, 0x02, 0x36, 0x4c, 0x36, 0xe1,
+    0x12, 0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2,
+    0x12, 0x12, 0x0c, 0x13, 0x0c, 0x12, 0x13, 0x16,
+    0x12, 0x13, 0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25,
+    0x24, 0xe5, 0x17, 0x40, 0xa5, 0x20, 0xa5, 0x20,
+    0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f,
+    0x2d, 0x00, 0x0f, 0x6c, 0x2f, 0xe0, 0x02, 0x5b,
+    0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00,
+    0xe5, 0x0b, 0x00, 0x25, 0x00, 0xe5, 0x07, 0x20,
+    0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56,
+    0x60, 0xeb, 0x25, 0x40, 0xef, 0x01, 0xea, 0x2d,
+    0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00, 0xef, 0x05,
+    0x40, 0x0f, 0xe0, 0x27, 0xef, 0x25, 0x06, 0xe0,
+    0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07,
+    0x06, 0xeb, 0x13, 0x60, 0xe5, 0x18, 0x6b, 0xe0,
+    0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80,
+    0xe5, 0x1e, 0x86, 0x80, 0xe5, 0x16, 0x00, 0x16,
+    0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0,
+    0x22, 0xe1, 0x20, 0xe2, 0x20, 0xe5, 0x46, 0x20,
+    0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c,
+    0x60, 0xe5, 0x20, 0xe0, 0x00, 0xe5, 0x2c, 0xe0,
+    0x03, 0x16, 0xe1, 0x03, 0x00, 0xe1, 0x07, 0x00,
+    0xc1, 0x00, 0x21, 0x00, 0xe2, 0x03, 0x00, 0xe2,
+    0x07, 0x00, 0xc2, 0x00, 0x22, 0xe0, 0x3b, 0xe5,
+    0x80, 0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02,
+    0xe5, 0x00, 0xe0, 0x10, 0xa4, 0x00, 0xe4, 0x22,
+    0x00, 0xe4, 0x01, 0xe0, 0x3d, 0xa5, 0x20, 0x05,
+    0x00, 0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20,
+    0xe5, 0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f,
+    0x2f, 0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01,
+    0xe0, 0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b,
+    0xe5, 0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80,
+    0x16, 0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25,
+    0xeb, 0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00,
+    0x26, 0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5,
+    0x15, 0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0,
+    0xf6, 0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5,
+    0x15, 0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5,
+    0x14, 0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5,
+    0x2e, 0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00,
+    0xe5, 0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0,
+    0x76, 0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41,
+    0xe0, 0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b,
+    0xc0, 0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9,
+    0x02, 0xe0, 0x80, 0x9e, 0xeb, 0x17, 0x00, 0xe5,
+    0x22, 0x00, 0x26, 0x11, 0x20, 0x25, 0xe0, 0x43,
+    0x46, 0xe5, 0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00,
+    0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x0e,
+    0xe5, 0x0a, 0x66, 0x76, 0xe0, 0x1e, 0xe5, 0x0d,
+    0xcb, 0xe0, 0x0c, 0xe5, 0x0f, 0xe0, 0x01, 0x07,
+    0x06, 0x07, 0xe5, 0x2d, 0xe6, 0x07, 0xd6, 0x60,
+    0xeb, 0x0c, 0xe9, 0x02, 0x06, 0x25, 0x26, 0x05,
+    0xe0, 0x01, 0x46, 0x07, 0xe5, 0x25, 0x47, 0x66,
+    0x27, 0x26, 0x36, 0x1b, 0x76, 0x06, 0xe0, 0x02,
+    0x1b, 0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0,
+    0x46, 0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00,
+    0xe9, 0x02, 0x76, 0x05, 0x27, 0x05, 0xe0, 0x00,
+    0xe5, 0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26,
+    0x07, 0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27, 0x65,
+    0x76, 0x66, 0x16, 0x07, 0x06, 0xe9, 0x02, 0x05,
+    0x16, 0x05, 0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03,
+    0xe5, 0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46, 0x27,
+    0x06, 0x07, 0x26, 0xb6, 0x06, 0x25, 0x06, 0xe0,
+    0x36, 0xc5, 0x00, 0x05, 0x00, 0x65, 0x00, 0xe5,
+    0x07, 0x00, 0xe5, 0x02, 0x16, 0xa0, 0xe5, 0x27,
+    0x06, 0x47, 0xe6, 0x00, 0x80, 0xe9, 0x02, 0xa0,
+    0x26, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25, 0x20,
+    0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x85,
+    0x00, 0x26, 0x05, 0x27, 0x06, 0x67, 0x20, 0x27,
+    0x20, 0x47, 0x20, 0x05, 0xa0, 0x07, 0x80, 0x85,
+    0x27, 0x20, 0xc6, 0x40, 0x86, 0xe0, 0x80, 0x03,
+    0xe5, 0x2d, 0x47, 0xe6, 0x00, 0x27, 0x46, 0x07,
+    0x06, 0x65, 0x96, 0xe9, 0x02, 0x36, 0x00, 0x16,
+    0x06, 0x45, 0xe0, 0x16, 0xe5, 0x28, 0x47, 0xa6,
+    0x07, 0x06, 0x67, 0x26, 0x07, 0x26, 0x25, 0x16,
+    0x05, 0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x1e,
+    0xe5, 0x27, 0x47, 0x66, 0x20, 0x67, 0x26, 0x07,
+    0x26, 0xf6, 0x0f, 0x65, 0x26, 0xe0, 0x1a, 0xe5,
+    0x28, 0x47, 0xe6, 0x00, 0x27, 0x06, 0x07, 0x26,
+    0x56, 0x05, 0xe0, 0x03, 0xe9, 0x02, 0xa0, 0xf6,
+    0x05, 0xe0, 0x0b, 0xe5, 0x23, 0x06, 0x07, 0x06,
+    0x27, 0xa6, 0x07, 0x06, 0x05, 0x16, 0xa0, 0xe9,
+    0x02, 0xe0, 0x2e, 0xe5, 0x13, 0x20, 0x46, 0x27,
+    0x66, 0x07, 0x86, 0x60, 0xe9, 0x02, 0x2b, 0x56,
+    0x0f, 0xc5, 0xe0, 0x80, 0x31, 0xe5, 0x24, 0x47,
+    0xe6, 0x01, 0x07, 0x26, 0x16, 0xe0, 0x5c, 0xe1,
+    0x18, 0xe2, 0x18, 0xe9, 0x02, 0xeb, 0x01, 0xe0,
+    0x04, 0xe5, 0x00, 0x20, 0x05, 0x20, 0xe5, 0x00,
+    0x00, 0x25, 0x00, 0xe5, 0x10, 0xa7, 0x00, 0x27,
+    0x20, 0x26, 0x07, 0x06, 0x05, 0x07, 0x05, 0x07,
+    0x06, 0x56, 0xe0, 0x01, 0xe9, 0x02, 0xe0, 0x3e,
+    0xe5, 0x00, 0x20, 0xe5, 0x1f, 0x47, 0x66, 0x20,
+    0x26, 0x67, 0x06, 0x05, 0x16, 0x05, 0x07, 0xe0,
+    0x13, 0x05, 0xe6, 0x02, 0xe5, 0x20, 0xa6, 0x07,
+    0x05, 0x66, 0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05,
+    0xa6, 0x27, 0x46, 0xe5, 0x26, 0xe6, 0x05, 0x07,
+    0x26, 0x56, 0x05, 0x96, 0xe0, 0x05, 0xe5, 0x41,
+    0xc0, 0xf6, 0x02, 0xe0, 0x80, 0x6e, 0xe5, 0x01,
+    0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6, 0x07,
+    0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02, 0xeb,
+    0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6, 0x0e,
+    0x00, 0x07, 0xc6, 0x07, 0x26, 0x07, 0x26, 0xe0,
+    0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e, 0xa6,
+    0x40, 0x06, 0x00, 0x26, 0x00, 0xc6, 0x05, 0x06,
+    0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00, 0x25,
+    0x00, 0xe5, 0x18, 0x87, 0x00, 0x26, 0x00, 0x27,
+    0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02, 0xe0,
+    0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36, 0xc0,
+    0x26, 0x05, 0x07, 0xe5, 0x05, 0x00, 0xe5, 0x1a,
+    0x27, 0x86, 0x40, 0x27, 0x06, 0x07, 0x06, 0xf6,
+    0x05, 0xe9, 0x02, 0xe0, 0x4e, 0x05, 0xe0, 0x07,
+    0xeb, 0x0d, 0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0,
+    0x05, 0x16, 0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea,
+    0x67, 0x00, 0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c,
+    0xe0, 0x89, 0xc4, 0xe5, 0x59, 0x36, 0xe0, 0x05,
+    0xe5, 0x83, 0xa8, 0xfb, 0x08, 0x06, 0xa5, 0xe6,
+    0x07, 0xe0, 0x8f, 0x22, 0xe5, 0x81, 0xbf, 0xe0,
+    0xa1, 0x31, 0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17,
+    0x00, 0xe9, 0x02, 0x60, 0x36, 0xe5, 0x47, 0x00,
+    0xe9, 0x02, 0xa0, 0xe5, 0x16, 0x20, 0x86, 0x16,
+    0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f, 0x64,
+    0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00, 0xcb,
+    0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0, 0x82,
+    0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb, 0x0f, 0x76,
+    0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06, 0x05, 0xe7,
+    0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38, 0x24,
+    0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0xe0, 0x06,
+    0xe5, 0x97, 0x70, 0xe0, 0x00, 0xe5, 0x84, 0x4e,
+    0xe0, 0x22, 0xe5, 0x01, 0xe0, 0xa2, 0x5f, 0x64,
+    0x00, 0xc4, 0x00, 0x24, 0x00, 0xe5, 0x80, 0x9b,
+    0xe0, 0x07, 0x05, 0xe0, 0x15, 0x45, 0x20, 0x05,
+    0xe0, 0x06, 0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04,
+    0xe0, 0x88, 0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05,
+    0x40, 0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f,
+    0x26, 0x16, 0x7b, 0xe0, 0x91, 0xd4, 0xe6, 0x26,
+    0x20, 0xe6, 0x0f, 0xe0, 0x01, 0xef, 0x6c, 0xe0,
+    0x34, 0xef, 0x80, 0x6e, 0xe0, 0x02, 0xef, 0x1f,
+    0x20, 0xef, 0x34, 0x27, 0x46, 0x4f, 0xa7, 0xfb,
+    0x00, 0xe6, 0x00, 0x2f, 0xc6, 0xef, 0x16, 0x66,
+    0xef, 0x35, 0xe0, 0x0d, 0xef, 0x3a, 0x46, 0x0f,
+    0xe0, 0x72, 0xeb, 0x0c, 0xe0, 0x04, 0xeb, 0x0c,
+    0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11,
+    0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
+    0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12,
+    0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21, 0x20,
+    0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02, 0x00,
+    0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12,
+    0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1,
+    0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00, 0x81,
+    0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
+    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20,
     0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1,
-    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0x3f, 0x20,
-    0xe9, 0x2a, 0xef, 0x81, 0x78, 0xe6, 0x2f, 0x6f,
-    0xe6, 0x2a, 0xef, 0x00, 0x06, 0xef, 0x06, 0x06,
-    0x2f, 0x96, 0xe0, 0x07, 0x86, 0x00, 0xe6, 0x07,
-    0xe0, 0x83, 0xc8, 0xe2, 0x02, 0x05, 0xe2, 0x0c,
-    0xe0, 0x80, 0x59, 0xc6, 0x00, 0xe6, 0x09, 0x20,
-    0xc6, 0x00, 0x26, 0x00, 0x86, 0xe0, 0x80, 0x4d,
-    0xe5, 0x25, 0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02,
-    0x60, 0x05, 0x0f, 0xe0, 0x80, 0xb8, 0xe5, 0x16,
-    0x06, 0xe0, 0x09, 0xe5, 0x24, 0x66, 0xe9, 0x02,
-    0x80, 0x0d, 0xe0, 0x84, 0x58, 0xc5, 0x00, 0x65,
-    0x00, 0x25, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x80,
-    0x3d, 0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1,
-    0x1a, 0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02,
-    0x60, 0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f,
-    0x4b, 0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f,
-    0xeb, 0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5,
-    0x13, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
-    0xe5, 0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05,
-    0xa0, 0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05,
-    0x00, 0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05,
-    0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
-    0x00, 0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5,
-    0x00, 0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5,
-    0x02, 0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85,
-    0x00, 0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80,
-    0x86, 0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04,
-    0xef, 0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07,
-    0x00, 0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0xef,
-    0x80, 0x19, 0xe0, 0x30, 0xef, 0x15, 0xe0, 0x05,
-    0xef, 0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0,
-    0x06, 0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73,
-    0x8e, 0xef, 0x82, 0x50, 0x80, 0xef, 0x08, 0x40,
-    0xef, 0x05, 0x40, 0xef, 0x6c, 0xe0, 0x04, 0xef,
-    0x51, 0xc0, 0xef, 0x04, 0x60, 0x0f, 0xe0, 0x07,
-    0xef, 0x04, 0x60, 0xef, 0x30, 0xe0, 0x00, 0xef,
-    0x02, 0xa0, 0xef, 0x20, 0xe0, 0x00, 0xef, 0x16,
-    0x20, 0x2f, 0xe0, 0x46, 0xef, 0x80, 0xcc, 0xe0,
-    0x04, 0xef, 0x06, 0x20, 0x8f, 0x40, 0x8f, 0x40,
-    0xcf, 0xe0, 0x01, 0xef, 0x15, 0x40, 0xef, 0x03,
-    0x80, 0xaf, 0xe0, 0x02, 0xef, 0x02, 0xa0, 0xef,
-    0x00, 0xe0, 0x00, 0xcf, 0xe0, 0x01, 0xef, 0x80,
-    0x0b, 0x00, 0xef, 0x2f, 0xe0, 0x1d, 0xe9, 0x02,
-    0xe0, 0x83, 0x7e, 0xe5, 0xc0, 0x66, 0x58, 0xe0,
-    0x18, 0xe5, 0x8f, 0xb1, 0xc0, 0xe5, 0x80, 0x56,
-    0x20, 0xe5, 0x95, 0xfa, 0xe0, 0x06, 0xe5, 0x9c,
-    0xa9, 0xe0, 0x8b, 0x97, 0xe5, 0x81, 0x96, 0xe0,
-    0x85, 0x5a, 0xe5, 0x92, 0xc3, 0xe0, 0xca, 0xac,
-    0x2e, 0x1b, 0xe0, 0x16, 0xfb, 0x58, 0xe0, 0x78,
-    0xe6, 0x80, 0x68, 0xe0, 0xc0, 0xbd, 0x88, 0xfd,
-    0xc0, 0xbf, 0x76, 0x20, 0xfd, 0xc0, 0xbf, 0x76,
-    0x20,
+    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11,
+    0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
+    0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2,
+    0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef,
+    0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef,
+    0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0,
+    0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x83, 0xc8,
+    0xe2, 0x02, 0x05, 0xe2, 0x0c, 0xa0, 0xa2, 0xe0,
+    0x80, 0x4d, 0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6,
+    0x00, 0x26, 0x00, 0x86, 0x80, 0xe4, 0x36, 0xe0,
+    0x19, 0x06, 0xe0, 0x68, 0xe5, 0x25, 0x40, 0xc6,
+    0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05, 0x0f, 0xe0,
+    0x80, 0xb8, 0xe5, 0x16, 0x06, 0xe0, 0x09, 0xe5,
+    0x24, 0x66, 0xe9, 0x02, 0x80, 0x0d, 0xe0, 0x81,
+    0x48, 0xe5, 0x13, 0x04, 0x66, 0xe9, 0x02, 0xe0,
+    0x82, 0x5e, 0xc5, 0x00, 0x65, 0x00, 0x25, 0x00,
+    0xe5, 0x07, 0x00, 0xe5, 0x80, 0x3d, 0x20, 0xeb,
+    0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a, 0xe2, 0x1a,
+    0xc6, 0x04, 0x60, 0xe9, 0x02, 0x60, 0x36, 0xe0,
+    0x82, 0x89, 0xeb, 0x33, 0x0f, 0x4b, 0x0d, 0x6b,
+    0xe0, 0x44, 0xeb, 0x25, 0x0f, 0xeb, 0x07, 0xe0,
+    0x80, 0x3a, 0x65, 0x00, 0xe5, 0x13, 0x00, 0x25,
+    0x00, 0x05, 0x20, 0x05, 0x00, 0xe5, 0x02, 0x00,
+    0x65, 0x00, 0x05, 0x00, 0x05, 0xa0, 0x05, 0x60,
+    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x45, 0x00,
+    0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0x05, 0x00,
+    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x25, 0x00,
+    0x05, 0x20, 0x65, 0x00, 0xc5, 0x00, 0x65, 0x00,
+    0x65, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x00, 0xe5,
+    0x09, 0x80, 0x45, 0x00, 0x85, 0x00, 0xe5, 0x09,
+    0xe0, 0x2c, 0x2c, 0xe0, 0x80, 0x86, 0xef, 0x24,
+    0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef, 0x07, 0x20,
+    0xef, 0x07, 0x00, 0xef, 0x07, 0x00, 0xef, 0x1d,
+    0xe0, 0x02, 0xeb, 0x05, 0xef, 0x80, 0x19, 0xe0,
+    0x30, 0xef, 0x15, 0xe0, 0x05, 0xef, 0x24, 0x60,
+    0xef, 0x01, 0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0,
+    0x80, 0x12, 0xef, 0x80, 0x73, 0x8e, 0xef, 0x82,
+    0x50, 0x60, 0xef, 0x09, 0x40, 0xef, 0x05, 0x40,
+    0xef, 0x6f, 0x60, 0xef, 0x57, 0xa0, 0xef, 0x04,
+    0x60, 0x0f, 0xe0, 0x07, 0xef, 0x04, 0x60, 0xef,
+    0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0, 0xef, 0x20,
+    0xe0, 0x00, 0xef, 0x16, 0x20, 0x2f, 0xe0, 0x46,
+    0xef, 0x80, 0xcc, 0xe0, 0x04, 0xef, 0x06, 0x20,
+    0xef, 0x05, 0x40, 0xef, 0x01, 0xc0, 0xef, 0x26,
+    0x00, 0xcf, 0xe0, 0x00, 0xef, 0x06, 0x60, 0xef,
+    0x01, 0xc0, 0xef, 0x01, 0xc0, 0xef, 0x80, 0x0b,
+    0x00, 0xef, 0x2f, 0xe0, 0x1d, 0xe9, 0x02, 0xe0,
+    0x83, 0x7e, 0xe5, 0xc0, 0x66, 0x58, 0xe0, 0x18,
+    0xe5, 0x8f, 0xb2, 0xa0, 0xe5, 0x80, 0x56, 0x20,
+    0xe5, 0x95, 0xfa, 0xe0, 0x06, 0xe5, 0x9c, 0xa9,
+    0xe0, 0x8b, 0x97, 0xe5, 0x81, 0x96, 0xe0, 0x85,
+    0x5a, 0xe5, 0x92, 0xc3, 0x80, 0xe5, 0x8f, 0xd8,
+    0xe0, 0xca, 0x9b, 0xc9, 0x1b, 0xe0, 0x16, 0xfb,
+    0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68, 0xe0, 0xc0,
+    0xbd, 0x88, 0xfd, 0xc0, 0xbf, 0x76, 0x20, 0xfd,
+    0xc0, 0xbf, 0x76, 0x20,
 };
 
 typedef enum {
@@ -2868,6 +2896,7 @@ typedef enum {
     UNICODE_SCRIPT_Kaithi,
     UNICODE_SCRIPT_Kannada,
     UNICODE_SCRIPT_Katakana,
+    UNICODE_SCRIPT_Kawi,
     UNICODE_SCRIPT_Kayah_Li,
     UNICODE_SCRIPT_Kharoshthi,
     UNICODE_SCRIPT_Khmer,
@@ -2902,6 +2931,7 @@ typedef enum {
     UNICODE_SCRIPT_Multani,
     UNICODE_SCRIPT_Myanmar,
     UNICODE_SCRIPT_Nabataean,
+    UNICODE_SCRIPT_Nag_Mundari,
     UNICODE_SCRIPT_Nandinagari,
     UNICODE_SCRIPT_New_Tai_Lue,
     UNICODE_SCRIPT_Newa,
@@ -3033,6 +3063,7 @@ static const char unicode_script_name_table[] =
     "Kaithi,Kthi"                 "\0"
     "Kannada,Knda"                "\0"
     "Katakana,Kana"               "\0"
+    "Kawi,Kawi"                   "\0"
     "Kayah_Li,Kali"               "\0"
     "Kharoshthi,Khar"             "\0"
     "Khmer,Khmr"                  "\0"
@@ -3067,6 +3098,7 @@ static const char unicode_script_name_table[] =
     "Multani,Mult"                "\0"
     "Myanmar,Mymr"                "\0"
     "Nabataean,Nbat"              "\0"
+    "Nag_Mundari,Nagm"            "\0"
     "Nandinagari,Nand"            "\0"
     "New_Tai_Lue,Talu"            "\0"
     "Newa,Newa"                   "\0"
@@ -3134,12 +3166,12 @@ static const char unicode_script_name_table[] =
     "Zanabazar_Square,Zanb"       "\0"
 ;
 
-static const uint8_t unicode_script_table[2690] = {
-    0xc0, 0x19, 0x99, 0x46, 0x85, 0x19, 0x99, 0x46,
-    0xae, 0x19, 0x80, 0x46, 0x8e, 0x19, 0x80, 0x46,
-    0x84, 0x19, 0x96, 0x46, 0x80, 0x19, 0x9e, 0x46,
-    0x80, 0x19, 0xe1, 0x60, 0x46, 0xa6, 0x19, 0x84,
-    0x46, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
+static const uint8_t unicode_script_table[2720] = {
+    0xc0, 0x19, 0x99, 0x47, 0x85, 0x19, 0x99, 0x47,
+    0xae, 0x19, 0x80, 0x47, 0x8e, 0x19, 0x80, 0x47,
+    0x84, 0x19, 0x96, 0x47, 0x80, 0x19, 0x9e, 0x47,
+    0x80, 0x19, 0xe1, 0x60, 0x47, 0xa6, 0x19, 0x84,
+    0x47, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
     0x0f, 0x38, 0x83, 0x2c, 0x80, 0x19, 0x82, 0x2c,
     0x01, 0x83, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x03,
     0x80, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x80, 0x19,
@@ -3152,11 +3184,11 @@ static const uint8_t unicode_script_table[2690] = {
     0x80, 0x19, 0x8d, 0x04, 0x80, 0x19, 0x82, 0x04,
     0x80, 0x19, 0x9f, 0x04, 0x80, 0x19, 0x89, 0x04,
     0x8a, 0x38, 0x99, 0x04, 0x80, 0x38, 0xe0, 0x0b,
-    0x04, 0x80, 0x19, 0xa1, 0x04, 0x8d, 0x89, 0x00,
-    0xbb, 0x89, 0x01, 0x82, 0x89, 0xaf, 0x04, 0xb1,
-    0x93, 0x0d, 0xba, 0x64, 0x01, 0x82, 0x64, 0xad,
-    0x7d, 0x01, 0x8e, 0x7d, 0x00, 0x9b, 0x51, 0x01,
-    0x80, 0x51, 0x00, 0x8a, 0x89, 0x04, 0x9e, 0x04,
+    0x04, 0x80, 0x19, 0xa1, 0x04, 0x8d, 0x8b, 0x00,
+    0xbb, 0x8b, 0x01, 0x82, 0x8b, 0xaf, 0x04, 0xb1,
+    0x95, 0x0d, 0xba, 0x66, 0x01, 0x82, 0x66, 0xad,
+    0x7f, 0x01, 0x8e, 0x7f, 0x00, 0x9b, 0x52, 0x01,
+    0x80, 0x52, 0x00, 0x8a, 0x8b, 0x04, 0x9e, 0x04,
     0x00, 0x81, 0x04, 0x05, 0xc9, 0x04, 0x80, 0x19,
     0x9c, 0x04, 0xd0, 0x20, 0x83, 0x38, 0x8e, 0x20,
     0x81, 0x19, 0x99, 0x20, 0x83, 0x0b, 0x00, 0x87,
@@ -3176,43 +3208,43 @@ static const uint8_t unicode_script_table[2690] = {
     0x84, 0x2d, 0x01, 0x89, 0x2d, 0x00, 0x82, 0x2d,
     0x00, 0x82, 0x2d, 0x01, 0x80, 0x2d, 0x0e, 0x83,
     0x2d, 0x01, 0x8b, 0x2d, 0x06, 0x86, 0x2d, 0x00,
-    0x82, 0x72, 0x00, 0x87, 0x72, 0x01, 0x81, 0x72,
-    0x01, 0x95, 0x72, 0x00, 0x86, 0x72, 0x00, 0x81,
-    0x72, 0x00, 0x84, 0x72, 0x01, 0x88, 0x72, 0x01,
-    0x81, 0x72, 0x01, 0x82, 0x72, 0x06, 0x82, 0x72,
-    0x03, 0x81, 0x72, 0x00, 0x84, 0x72, 0x01, 0x91,
-    0x72, 0x09, 0x81, 0x90, 0x00, 0x85, 0x90, 0x02,
-    0x82, 0x90, 0x00, 0x83, 0x90, 0x02, 0x81, 0x90,
-    0x00, 0x80, 0x90, 0x00, 0x81, 0x90, 0x02, 0x81,
-    0x90, 0x02, 0x82, 0x90, 0x02, 0x8b, 0x90, 0x03,
-    0x84, 0x90, 0x02, 0x82, 0x90, 0x00, 0x83, 0x90,
-    0x01, 0x80, 0x90, 0x05, 0x80, 0x90, 0x0d, 0x94,
-    0x90, 0x04, 0x8c, 0x92, 0x00, 0x82, 0x92, 0x00,
-    0x96, 0x92, 0x00, 0x8f, 0x92, 0x01, 0x88, 0x92,
-    0x00, 0x82, 0x92, 0x00, 0x83, 0x92, 0x06, 0x81,
-    0x92, 0x00, 0x82, 0x92, 0x01, 0x80, 0x92, 0x01,
-    0x83, 0x92, 0x01, 0x89, 0x92, 0x06, 0x88, 0x92,
+    0x82, 0x74, 0x00, 0x87, 0x74, 0x01, 0x81, 0x74,
+    0x01, 0x95, 0x74, 0x00, 0x86, 0x74, 0x00, 0x81,
+    0x74, 0x00, 0x84, 0x74, 0x01, 0x88, 0x74, 0x01,
+    0x81, 0x74, 0x01, 0x82, 0x74, 0x06, 0x82, 0x74,
+    0x03, 0x81, 0x74, 0x00, 0x84, 0x74, 0x01, 0x91,
+    0x74, 0x09, 0x81, 0x92, 0x00, 0x85, 0x92, 0x02,
+    0x82, 0x92, 0x00, 0x83, 0x92, 0x02, 0x81, 0x92,
+    0x00, 0x80, 0x92, 0x00, 0x81, 0x92, 0x02, 0x81,
+    0x92, 0x02, 0x82, 0x92, 0x02, 0x8b, 0x92, 0x03,
+    0x84, 0x92, 0x02, 0x82, 0x92, 0x00, 0x83, 0x92,
+    0x01, 0x80, 0x92, 0x05, 0x80, 0x92, 0x0d, 0x94,
+    0x92, 0x04, 0x8c, 0x94, 0x00, 0x82, 0x94, 0x00,
+    0x96, 0x94, 0x00, 0x8f, 0x94, 0x01, 0x88, 0x94,
+    0x00, 0x82, 0x94, 0x00, 0x83, 0x94, 0x06, 0x81,
+    0x94, 0x00, 0x82, 0x94, 0x01, 0x80, 0x94, 0x01,
+    0x83, 0x94, 0x01, 0x89, 0x94, 0x06, 0x88, 0x94,
     0x8c, 0x3d, 0x00, 0x82, 0x3d, 0x00, 0x96, 0x3d,
     0x00, 0x89, 0x3d, 0x00, 0x84, 0x3d, 0x01, 0x88,
     0x3d, 0x00, 0x82, 0x3d, 0x00, 0x83, 0x3d, 0x06,
     0x81, 0x3d, 0x05, 0x81, 0x3d, 0x00, 0x83, 0x3d,
-    0x01, 0x89, 0x3d, 0x00, 0x81, 0x3d, 0x0c, 0x8c,
-    0x50, 0x00, 0x82, 0x50, 0x00, 0xb2, 0x50, 0x00,
-    0x82, 0x50, 0x00, 0x85, 0x50, 0x03, 0x8f, 0x50,
-    0x01, 0x99, 0x50, 0x00, 0x82, 0x83, 0x00, 0x91,
-    0x83, 0x02, 0x97, 0x83, 0x00, 0x88, 0x83, 0x00,
-    0x80, 0x83, 0x01, 0x86, 0x83, 0x02, 0x80, 0x83,
-    0x03, 0x85, 0x83, 0x00, 0x80, 0x83, 0x00, 0x87,
-    0x83, 0x05, 0x89, 0x83, 0x01, 0x82, 0x83, 0x0b,
-    0xb9, 0x94, 0x03, 0x80, 0x19, 0x9b, 0x94, 0x24,
-    0x81, 0x45, 0x00, 0x80, 0x45, 0x00, 0x84, 0x45,
-    0x00, 0x97, 0x45, 0x00, 0x80, 0x45, 0x00, 0x96,
-    0x45, 0x01, 0x84, 0x45, 0x00, 0x80, 0x45, 0x00,
-    0x85, 0x45, 0x01, 0x89, 0x45, 0x01, 0x83, 0x45,
-    0x1f, 0xc7, 0x95, 0x00, 0xa3, 0x95, 0x03, 0xa6,
-    0x95, 0x00, 0xa3, 0x95, 0x00, 0x8e, 0x95, 0x00,
-    0x86, 0x95, 0x83, 0x19, 0x81, 0x95, 0x24, 0xe0,
-    0x3f, 0x5f, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
+    0x01, 0x89, 0x3d, 0x00, 0x82, 0x3d, 0x0b, 0x8c,
+    0x51, 0x00, 0x82, 0x51, 0x00, 0xb2, 0x51, 0x00,
+    0x82, 0x51, 0x00, 0x85, 0x51, 0x03, 0x8f, 0x51,
+    0x01, 0x99, 0x51, 0x00, 0x82, 0x85, 0x00, 0x91,
+    0x85, 0x02, 0x97, 0x85, 0x00, 0x88, 0x85, 0x00,
+    0x80, 0x85, 0x01, 0x86, 0x85, 0x02, 0x80, 0x85,
+    0x03, 0x85, 0x85, 0x00, 0x80, 0x85, 0x00, 0x87,
+    0x85, 0x05, 0x89, 0x85, 0x01, 0x82, 0x85, 0x0b,
+    0xb9, 0x96, 0x03, 0x80, 0x19, 0x9b, 0x96, 0x24,
+    0x81, 0x46, 0x00, 0x80, 0x46, 0x00, 0x84, 0x46,
+    0x00, 0x97, 0x46, 0x00, 0x80, 0x46, 0x00, 0x96,
+    0x46, 0x01, 0x84, 0x46, 0x00, 0x80, 0x46, 0x00,
+    0x86, 0x46, 0x00, 0x89, 0x46, 0x01, 0x83, 0x46,
+    0x1f, 0xc7, 0x97, 0x00, 0xa3, 0x97, 0x03, 0xa6,
+    0x97, 0x00, 0xa3, 0x97, 0x00, 0x8e, 0x97, 0x00,
+    0x86, 0x97, 0x83, 0x19, 0x81, 0x97, 0x24, 0xe0,
+    0x3f, 0x60, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
     0x80, 0x28, 0x01, 0xaa, 0x28, 0x80, 0x19, 0x83,
     0x28, 0xe0, 0x9f, 0x31, 0xc8, 0x27, 0x00, 0x83,
     0x27, 0x01, 0x86, 0x27, 0x00, 0x80, 0x27, 0x00,
@@ -3222,32 +3254,32 @@ static const uint8_t unicode_script_table[2690] = {
     0x8e, 0x27, 0x00, 0xb8, 0x27, 0x00, 0x83, 0x27,
     0x01, 0xc2, 0x27, 0x01, 0x9f, 0x27, 0x02, 0x99,
     0x27, 0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01,
-    0xe2, 0x1f, 0x12, 0x9c, 0x67, 0x02, 0xca, 0x7c,
-    0x82, 0x19, 0x8a, 0x7c, 0x06, 0x95, 0x8a, 0x08,
-    0x80, 0x8a, 0x94, 0x33, 0x81, 0x19, 0x08, 0x93,
-    0x11, 0x0b, 0x8c, 0x8b, 0x00, 0x82, 0x8b, 0x00,
-    0x81, 0x8b, 0x0b, 0xdd, 0x41, 0x01, 0x89, 0x41,
-    0x05, 0x89, 0x41, 0x05, 0x81, 0x5c, 0x81, 0x19,
-    0x80, 0x5c, 0x80, 0x19, 0x93, 0x5c, 0x05, 0xd8,
-    0x5c, 0x06, 0xaa, 0x5c, 0x04, 0xc5, 0x12, 0x09,
-    0x9e, 0x48, 0x00, 0x8b, 0x48, 0x03, 0x8b, 0x48,
-    0x03, 0x80, 0x48, 0x02, 0x8b, 0x48, 0x9d, 0x8c,
-    0x01, 0x84, 0x8c, 0x0a, 0xab, 0x62, 0x03, 0x99,
-    0x62, 0x05, 0x8a, 0x62, 0x02, 0x81, 0x62, 0x9f,
-    0x41, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x8d,
-    0x00, 0x9c, 0x8d, 0x01, 0x8a, 0x8d, 0x05, 0x89,
-    0x8d, 0x05, 0x8d, 0x8d, 0x01, 0x9e, 0x38, 0x30,
-    0xcc, 0x07, 0x02, 0xae, 0x07, 0x00, 0xbf, 0x87,
-    0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x47, 0x02,
-    0x8e, 0x47, 0x02, 0x82, 0x47, 0xaf, 0x68, 0x88,
+    0xe2, 0x1f, 0x12, 0x9c, 0x69, 0x02, 0xca, 0x7e,
+    0x82, 0x19, 0x8a, 0x7e, 0x06, 0x95, 0x8c, 0x08,
+    0x80, 0x8c, 0x94, 0x33, 0x81, 0x19, 0x08, 0x93,
+    0x11, 0x0b, 0x8c, 0x8d, 0x00, 0x82, 0x8d, 0x00,
+    0x81, 0x8d, 0x0b, 0xdd, 0x42, 0x01, 0x89, 0x42,
+    0x05, 0x89, 0x42, 0x05, 0x81, 0x5d, 0x81, 0x19,
+    0x80, 0x5d, 0x80, 0x19, 0x93, 0x5d, 0x05, 0xd8,
+    0x5d, 0x06, 0xaa, 0x5d, 0x04, 0xc5, 0x12, 0x09,
+    0x9e, 0x49, 0x00, 0x8b, 0x49, 0x03, 0x8b, 0x49,
+    0x03, 0x80, 0x49, 0x02, 0x8b, 0x49, 0x9d, 0x8e,
+    0x01, 0x84, 0x8e, 0x0a, 0xab, 0x64, 0x03, 0x99,
+    0x64, 0x05, 0x8a, 0x64, 0x02, 0x81, 0x64, 0x9f,
+    0x42, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x8f,
+    0x00, 0x9c, 0x8f, 0x01, 0x8a, 0x8f, 0x05, 0x89,
+    0x8f, 0x05, 0x8d, 0x8f, 0x01, 0x9e, 0x38, 0x30,
+    0xcc, 0x07, 0x02, 0xae, 0x07, 0x00, 0xbf, 0x89,
+    0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x48, 0x02,
+    0x8e, 0x48, 0x02, 0x82, 0x48, 0xaf, 0x6a, 0x88,
     0x1d, 0x06, 0xaa, 0x28, 0x01, 0x82, 0x28, 0x87,
-    0x87, 0x07, 0x82, 0x38, 0x80, 0x19, 0x8c, 0x38,
+    0x89, 0x07, 0x82, 0x38, 0x80, 0x19, 0x8c, 0x38,
     0x80, 0x19, 0x86, 0x38, 0x83, 0x19, 0x80, 0x38,
     0x85, 0x19, 0x80, 0x38, 0x82, 0x19, 0x81, 0x38,
-    0x80, 0x19, 0x04, 0xa5, 0x46, 0x84, 0x2c, 0x80,
-    0x1d, 0xb0, 0x46, 0x84, 0x2c, 0x83, 0x46, 0x84,
-    0x2c, 0x8c, 0x46, 0x80, 0x1d, 0xc5, 0x46, 0x80,
-    0x2c, 0xbf, 0x38, 0xe0, 0x9f, 0x46, 0x95, 0x2c,
+    0x80, 0x19, 0x04, 0xa5, 0x47, 0x84, 0x2c, 0x80,
+    0x1d, 0xb0, 0x47, 0x84, 0x2c, 0x83, 0x47, 0x84,
+    0x2c, 0x8c, 0x47, 0x80, 0x1d, 0xc5, 0x47, 0x80,
+    0x2c, 0xbf, 0x38, 0xe0, 0x9f, 0x47, 0x95, 0x2c,
     0x01, 0x85, 0x2c, 0x01, 0xa5, 0x2c, 0x01, 0x85,
     0x2c, 0x01, 0x87, 0x2c, 0x00, 0x80, 0x2c, 0x00,
     0x80, 0x2c, 0x00, 0x80, 0x2c, 0x00, 0x9e, 0x2c,
@@ -3255,18 +3287,18 @@ static const uint8_t unicode_script_table[2690] = {
     0x2c, 0x01, 0x85, 0x2c, 0x00, 0x92, 0x2c, 0x01,
     0x82, 0x2c, 0x00, 0x88, 0x2c, 0x00, 0x8b, 0x19,
     0x81, 0x38, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80,
-    0x46, 0x01, 0x8a, 0x19, 0x80, 0x46, 0x8e, 0x19,
-    0x00, 0x8c, 0x46, 0x02, 0xa0, 0x19, 0x0e, 0xa0,
+    0x47, 0x01, 0x8a, 0x19, 0x80, 0x47, 0x8e, 0x19,
+    0x00, 0x8c, 0x47, 0x02, 0xa0, 0x19, 0x0e, 0xa0,
     0x38, 0x0e, 0xa5, 0x19, 0x80, 0x2c, 0x82, 0x19,
-    0x81, 0x46, 0x85, 0x19, 0x80, 0x46, 0x9a, 0x19,
-    0x80, 0x46, 0x90, 0x19, 0xa8, 0x46, 0x82, 0x19,
+    0x81, 0x47, 0x85, 0x19, 0x80, 0x47, 0x9a, 0x19,
+    0x80, 0x47, 0x90, 0x19, 0xa8, 0x47, 0x82, 0x19,
     0x03, 0xe2, 0x36, 0x19, 0x18, 0x8a, 0x19, 0x14,
     0xe3, 0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13,
     0x19, 0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19,
-    0xdf, 0x29, 0x9f, 0x46, 0xe0, 0x13, 0x1a, 0x04,
+    0xdf, 0x29, 0x9f, 0x47, 0xe0, 0x13, 0x1a, 0x04,
     0x86, 0x1a, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
-    0x80, 0x28, 0x01, 0xb7, 0x96, 0x06, 0x81, 0x96,
-    0x0d, 0x80, 0x96, 0x96, 0x27, 0x08, 0x86, 0x27,
+    0x80, 0x28, 0x01, 0xb7, 0x98, 0x06, 0x81, 0x98,
+    0x0d, 0x80, 0x98, 0x96, 0x27, 0x08, 0x86, 0x27,
     0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x86,
     0x27, 0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00,
     0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x9f, 0x1d,
@@ -3282,27 +3314,27 @@ static const uint8_t unicode_script_table[2690] = {
     0x9e, 0x31, 0x00, 0xbf, 0x19, 0x9e, 0x31, 0xd0,
     0x19, 0xae, 0x3e, 0x80, 0x19, 0xd7, 0x3e, 0xe0,
     0x47, 0x19, 0xf0, 0x09, 0x5f, 0x30, 0xbf, 0x19,
-    0xf0, 0x41, 0x9f, 0x30, 0xe4, 0x2c, 0xa0, 0x02,
-    0xb6, 0xa0, 0x08, 0xaf, 0x4b, 0xe0, 0xcb, 0x9b,
+    0xf0, 0x41, 0x9f, 0x30, 0xe4, 0x2c, 0xa2, 0x02,
+    0xb6, 0xa2, 0x08, 0xaf, 0x4c, 0xe0, 0xcb, 0x9d,
     0x13, 0xdf, 0x1d, 0xd7, 0x08, 0x07, 0xa1, 0x19,
-    0xe0, 0x05, 0x46, 0x82, 0x19, 0xbf, 0x46, 0x04,
-    0x81, 0x46, 0x00, 0x80, 0x46, 0x00, 0x84, 0x46,
-    0x17, 0x8d, 0x46, 0xac, 0x88, 0x02, 0x89, 0x19,
-    0x05, 0xb7, 0x78, 0x07, 0xc5, 0x7e, 0x07, 0x8b,
-    0x7e, 0x05, 0x9f, 0x20, 0xad, 0x3f, 0x80, 0x19,
-    0x80, 0x3f, 0xa3, 0x7b, 0x0a, 0x80, 0x7b, 0x9c,
+    0xe0, 0x05, 0x47, 0x82, 0x19, 0xbf, 0x47, 0x04,
+    0x81, 0x47, 0x00, 0x80, 0x47, 0x00, 0x84, 0x47,
+    0x17, 0x8d, 0x47, 0xac, 0x8a, 0x02, 0x89, 0x19,
+    0x05, 0xb7, 0x7a, 0x07, 0xc5, 0x80, 0x07, 0x8b,
+    0x80, 0x05, 0x9f, 0x20, 0xad, 0x40, 0x80, 0x19,
+    0x80, 0x40, 0xa3, 0x7d, 0x0a, 0x80, 0x7d, 0x9c,
     0x31, 0x02, 0xcd, 0x3b, 0x00, 0x80, 0x19, 0x89,
-    0x3b, 0x03, 0x81, 0x3b, 0x9e, 0x5f, 0x00, 0xb6,
+    0x3b, 0x03, 0x81, 0x3b, 0x9e, 0x60, 0x00, 0xb6,
     0x16, 0x08, 0x8d, 0x16, 0x01, 0x89, 0x16, 0x01,
-    0x83, 0x16, 0x9f, 0x5f, 0xc2, 0x8e, 0x17, 0x84,
-    0x8e, 0x96, 0x56, 0x09, 0x85, 0x27, 0x01, 0x85,
+    0x83, 0x16, 0x9f, 0x60, 0xc2, 0x90, 0x17, 0x84,
+    0x90, 0x96, 0x57, 0x09, 0x85, 0x27, 0x01, 0x85,
     0x27, 0x01, 0x85, 0x27, 0x08, 0x86, 0x27, 0x00,
-    0x86, 0x27, 0x00, 0xaa, 0x46, 0x80, 0x19, 0x88,
-    0x46, 0x80, 0x2c, 0x83, 0x46, 0x81, 0x19, 0x03,
-    0xcf, 0x17, 0xad, 0x56, 0x01, 0x89, 0x56, 0x05,
+    0x86, 0x27, 0x00, 0xaa, 0x47, 0x80, 0x19, 0x88,
+    0x47, 0x80, 0x2c, 0x83, 0x47, 0x81, 0x19, 0x03,
+    0xcf, 0x17, 0xad, 0x57, 0x01, 0x89, 0x57, 0x05,
     0xf0, 0x1b, 0x43, 0x31, 0x0b, 0x96, 0x31, 0x03,
     0xb0, 0x31, 0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x30,
-    0x01, 0xe0, 0x09, 0x30, 0x25, 0x86, 0x46, 0x0b,
+    0x01, 0xe0, 0x09, 0x30, 0x25, 0x86, 0x47, 0x0b,
     0x84, 0x05, 0x04, 0x99, 0x35, 0x00, 0x84, 0x35,
     0x00, 0x80, 0x35, 0x00, 0x81, 0x35, 0x00, 0x81,
     0x35, 0x00, 0x89, 0x35, 0xe0, 0x12, 0x04, 0x0f,
@@ -3311,130 +3343,134 @@ static const uint8_t unicode_script_table[2690] = {
     0x8f, 0x38, 0x89, 0x19, 0x05, 0x8d, 0x38, 0x81,
     0x1d, 0xa2, 0x19, 0x00, 0x92, 0x19, 0x00, 0x83,
     0x19, 0x03, 0x84, 0x04, 0x00, 0xe0, 0x26, 0x04,
-    0x01, 0x80, 0x19, 0x00, 0x9f, 0x19, 0x99, 0x46,
-    0x85, 0x19, 0x99, 0x46, 0x8a, 0x19, 0x89, 0x3e,
+    0x01, 0x80, 0x19, 0x00, 0x9f, 0x19, 0x99, 0x47,
+    0x85, 0x19, 0x99, 0x47, 0x8a, 0x19, 0x89, 0x3e,
     0x80, 0x19, 0xac, 0x3e, 0x81, 0x19, 0x9e, 0x31,
     0x02, 0x85, 0x31, 0x01, 0x85, 0x31, 0x01, 0x85,
     0x31, 0x01, 0x82, 0x31, 0x02, 0x86, 0x19, 0x00,
-    0x86, 0x19, 0x09, 0x84, 0x19, 0x01, 0x8b, 0x4a,
-    0x00, 0x99, 0x4a, 0x00, 0x92, 0x4a, 0x00, 0x81,
-    0x4a, 0x00, 0x8e, 0x4a, 0x01, 0x8d, 0x4a, 0x21,
-    0xe0, 0x1a, 0x4a, 0x04, 0x82, 0x19, 0x03, 0xac,
+    0x86, 0x19, 0x09, 0x84, 0x19, 0x01, 0x8b, 0x4b,
+    0x00, 0x99, 0x4b, 0x00, 0x92, 0x4b, 0x00, 0x81,
+    0x4b, 0x00, 0x8e, 0x4b, 0x01, 0x8d, 0x4b, 0x21,
+    0xe0, 0x1a, 0x4b, 0x04, 0x82, 0x19, 0x03, 0xac,
     0x19, 0x02, 0x88, 0x19, 0xce, 0x2c, 0x00, 0x8c,
     0x19, 0x02, 0x80, 0x2c, 0x2e, 0xac, 0x19, 0x80,
-    0x38, 0x60, 0x21, 0x9c, 0x4c, 0x02, 0xb0, 0x13,
-    0x0e, 0x80, 0x38, 0x9a, 0x19, 0x03, 0xa3, 0x6a,
-    0x08, 0x82, 0x6a, 0x9a, 0x2a, 0x04, 0xaa, 0x6c,
-    0x04, 0x9d, 0x9a, 0x00, 0x80, 0x9a, 0xa3, 0x6d,
-    0x03, 0x8d, 0x6d, 0x29, 0xcf, 0x1f, 0xaf, 0x80,
-    0x9d, 0x74, 0x01, 0x89, 0x74, 0x05, 0xa3, 0x73,
-    0x03, 0xa3, 0x73, 0x03, 0xa7, 0x25, 0x07, 0xb3,
-    0x14, 0x0a, 0x80, 0x14, 0x8a, 0x9c, 0x00, 0x8e,
-    0x9c, 0x00, 0x86, 0x9c, 0x00, 0x81, 0x9c, 0x00,
-    0x8a, 0x9c, 0x00, 0x8e, 0x9c, 0x00, 0x86, 0x9c,
-    0x00, 0x81, 0x9c, 0x42, 0xe0, 0xd6, 0x49, 0x08,
-    0x95, 0x49, 0x09, 0x87, 0x49, 0x17, 0x85, 0x46,
-    0x00, 0xa9, 0x46, 0x00, 0x88, 0x46, 0x44, 0x85,
+    0x38, 0x60, 0x21, 0x9c, 0x4d, 0x02, 0xb0, 0x13,
+    0x0e, 0x80, 0x38, 0x9a, 0x19, 0x03, 0xa3, 0x6c,
+    0x08, 0x82, 0x6c, 0x9a, 0x2a, 0x04, 0xaa, 0x6e,
+    0x04, 0x9d, 0x9c, 0x00, 0x80, 0x9c, 0xa3, 0x6f,
+    0x03, 0x8d, 0x6f, 0x29, 0xcf, 0x1f, 0xaf, 0x82,
+    0x9d, 0x76, 0x01, 0x89, 0x76, 0x05, 0xa3, 0x75,
+    0x03, 0xa3, 0x75, 0x03, 0xa7, 0x25, 0x07, 0xb3,
+    0x14, 0x0a, 0x80, 0x14, 0x8a, 0x9e, 0x00, 0x8e,
+    0x9e, 0x00, 0x86, 0x9e, 0x00, 0x81, 0x9e, 0x00,
+    0x8a, 0x9e, 0x00, 0x8e, 0x9e, 0x00, 0x86, 0x9e,
+    0x00, 0x81, 0x9e, 0x42, 0xe0, 0xd6, 0x4a, 0x08,
+    0x95, 0x4a, 0x09, 0x87, 0x4a, 0x17, 0x85, 0x47,
+    0x00, 0xa9, 0x47, 0x00, 0x88, 0x47, 0x44, 0x85,
     0x1c, 0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c, 0x00,
     0x81, 0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80, 0x1c,
-    0x95, 0x37, 0x00, 0x88, 0x37, 0x9f, 0x76, 0x9e,
-    0x60, 0x07, 0x88, 0x60, 0x2f, 0x92, 0x34, 0x00,
-    0x81, 0x34, 0x04, 0x84, 0x34, 0x9b, 0x79, 0x02,
-    0x80, 0x79, 0x99, 0x4d, 0x04, 0x80, 0x4d, 0x3f,
-    0x9f, 0x59, 0x97, 0x58, 0x03, 0x93, 0x58, 0x01,
-    0xad, 0x58, 0x83, 0x40, 0x00, 0x81, 0x40, 0x04,
-    0x87, 0x40, 0x00, 0x82, 0x40, 0x00, 0x9c, 0x40,
-    0x01, 0x82, 0x40, 0x03, 0x89, 0x40, 0x06, 0x88,
-    0x40, 0x06, 0x9f, 0x6f, 0x9f, 0x6b, 0x1f, 0xa6,
-    0x52, 0x03, 0x8b, 0x52, 0x08, 0xb5, 0x06, 0x02,
+    0x95, 0x37, 0x00, 0x88, 0x37, 0x9f, 0x78, 0x9e,
+    0x61, 0x07, 0x88, 0x61, 0x2f, 0x92, 0x34, 0x00,
+    0x81, 0x34, 0x04, 0x84, 0x34, 0x9b, 0x7b, 0x02,
+    0x80, 0x7b, 0x99, 0x4e, 0x04, 0x80, 0x4e, 0x3f,
+    0x9f, 0x5a, 0x97, 0x59, 0x03, 0x93, 0x59, 0x01,
+    0xad, 0x59, 0x83, 0x41, 0x00, 0x81, 0x41, 0x04,
+    0x87, 0x41, 0x00, 0x82, 0x41, 0x00, 0x9c, 0x41,
+    0x01, 0x82, 0x41, 0x03, 0x89, 0x41, 0x06, 0x88,
+    0x41, 0x06, 0x9f, 0x71, 0x9f, 0x6d, 0x1f, 0xa6,
+    0x53, 0x03, 0x8b, 0x53, 0x08, 0xb5, 0x06, 0x02,
     0x86, 0x06, 0x95, 0x3a, 0x01, 0x87, 0x3a, 0x92,
-    0x39, 0x04, 0x87, 0x39, 0x91, 0x7a, 0x06, 0x83,
-    0x7a, 0x0b, 0x86, 0x7a, 0x4f, 0xc8, 0x70, 0x36,
-    0xb2, 0x69, 0x0c, 0xb2, 0x69, 0x06, 0x85, 0x69,
+    0x39, 0x04, 0x87, 0x39, 0x91, 0x7c, 0x06, 0x83,
+    0x7c, 0x0b, 0x86, 0x7c, 0x4f, 0xc8, 0x72, 0x36,
+    0xb2, 0x6b, 0x0c, 0xb2, 0x6b, 0x06, 0x85, 0x6b,
     0xa7, 0x32, 0x07, 0x89, 0x32, 0x60, 0xc5, 0x9e,
-    0x04, 0x00, 0xa9, 0x9f, 0x00, 0x82, 0x9f, 0x01,
-    0x81, 0x9f, 0x4d, 0xa7, 0x6e, 0x07, 0xa9, 0x84,
-    0x15, 0x99, 0x71, 0x25, 0x9b, 0x18, 0x13, 0x96,
-    0x26, 0x08, 0xcd, 0x0e, 0x03, 0xa3, 0x0e, 0x08,
-    0x80, 0x0e, 0xc2, 0x3c, 0x09, 0x80, 0x3c, 0x01,
-    0x98, 0x85, 0x06, 0x89, 0x85, 0x05, 0xb4, 0x15,
-    0x00, 0x91, 0x15, 0x07, 0xa6, 0x4f, 0x08, 0xdf,
-    0x7f, 0x00, 0x93, 0x83, 0x0a, 0x91, 0x42, 0x00,
-    0xab, 0x42, 0x40, 0x86, 0x5e, 0x00, 0x80, 0x5e,
-    0x00, 0x83, 0x5e, 0x00, 0x8e, 0x5e, 0x00, 0x8a,
-    0x5e, 0x05, 0xba, 0x44, 0x04, 0x89, 0x44, 0x05,
-    0x83, 0x2b, 0x00, 0x87, 0x2b, 0x01, 0x81, 0x2b,
-    0x01, 0x95, 0x2b, 0x00, 0x86, 0x2b, 0x00, 0x81,
-    0x2b, 0x00, 0x84, 0x2b, 0x00, 0x80, 0x38, 0x88,
-    0x2b, 0x01, 0x81, 0x2b, 0x01, 0x82, 0x2b, 0x01,
-    0x80, 0x2b, 0x05, 0x80, 0x2b, 0x04, 0x86, 0x2b,
-    0x01, 0x86, 0x2b, 0x02, 0x84, 0x2b, 0x60, 0x2a,
-    0xdb, 0x63, 0x00, 0x84, 0x63, 0x1d, 0xc7, 0x97,
-    0x07, 0x89, 0x97, 0x60, 0x45, 0xb5, 0x81, 0x01,
-    0xa5, 0x81, 0x21, 0xc4, 0x5b, 0x0a, 0x89, 0x5b,
-    0x05, 0x8c, 0x5c, 0x12, 0xb9, 0x8f, 0x05, 0x89,
-    0x8f, 0x35, 0x9a, 0x02, 0x01, 0x8e, 0x02, 0x03,
-    0x96, 0x02, 0x60, 0x58, 0xbb, 0x22, 0x60, 0x03,
-    0xd2, 0x9e, 0x0b, 0x80, 0x9e, 0x86, 0x21, 0x01,
-    0x80, 0x21, 0x01, 0x87, 0x21, 0x00, 0x81, 0x21,
-    0x00, 0x9d, 0x21, 0x00, 0x81, 0x21, 0x01, 0x8b,
-    0x21, 0x08, 0x89, 0x21, 0x45, 0x87, 0x61, 0x01,
-    0xad, 0x61, 0x01, 0x8a, 0x61, 0x1a, 0xc7, 0xa1,
-    0x07, 0xd2, 0x86, 0x0c, 0x8f, 0x12, 0xb8, 0x77,
-    0x60, 0xa6, 0x88, 0x0c, 0x00, 0xac, 0x0c, 0x00,
-    0x8d, 0x0c, 0x09, 0x9c, 0x0c, 0x02, 0x9f, 0x53,
-    0x01, 0x95, 0x53, 0x00, 0x8d, 0x53, 0x48, 0x86,
-    0x54, 0x00, 0x81, 0x54, 0x00, 0xab, 0x54, 0x02,
-    0x80, 0x54, 0x00, 0x81, 0x54, 0x00, 0x88, 0x54,
-    0x07, 0x89, 0x54, 0x05, 0x85, 0x2e, 0x00, 0x81,
-    0x2e, 0x00, 0xa4, 0x2e, 0x00, 0x81, 0x2e, 0x00,
-    0x85, 0x2e, 0x06, 0x89, 0x2e, 0x60, 0xd5, 0x98,
-    0x4e, 0x60, 0x56, 0x80, 0x4b, 0x0e, 0xb1, 0x90,
-    0x0c, 0x80, 0x90, 0xe3, 0x39, 0x1b, 0x60, 0x05,
-    0xe0, 0x0e, 0x1b, 0x00, 0x84, 0x1b, 0x0a, 0xe0,
-    0x63, 0x1b, 0x69, 0xeb, 0xe0, 0x02, 0x1e, 0x0c,
-    0xe3, 0xce, 0x24, 0x00, 0x88, 0x24, 0x6f, 0x66,
-    0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58, 0xe1, 0xd8,
-    0x08, 0x06, 0x9e, 0x5d, 0x00, 0x89, 0x5d, 0x03,
-    0x81, 0x5d, 0xce, 0x98, 0x00, 0x89, 0x98, 0x05,
-    0x9d, 0x09, 0x01, 0x85, 0x09, 0x09, 0xc5, 0x75,
-    0x09, 0x89, 0x75, 0x00, 0x86, 0x75, 0x00, 0x94,
-    0x75, 0x04, 0x92, 0x75, 0x62, 0x4f, 0xda, 0x55,
-    0x60, 0x04, 0xca, 0x5a, 0x03, 0xb8, 0x5a, 0x06,
-    0x90, 0x5a, 0x3f, 0x80, 0x91, 0x80, 0x65, 0x81,
-    0x30, 0x80, 0x43, 0x0a, 0x81, 0x30, 0x0d, 0xf0,
-    0x07, 0x97, 0x91, 0x07, 0xe2, 0x9f, 0x91, 0xe1,
-    0x75, 0x43, 0x29, 0x88, 0x91, 0x70, 0x12, 0x86,
-    0x83, 0x3e, 0x00, 0x86, 0x3e, 0x00, 0x81, 0x3e,
-    0x00, 0x80, 0x3e, 0xe0, 0xbe, 0x36, 0x82, 0x3e,
-    0x2c, 0x82, 0x36, 0x10, 0x83, 0x3e, 0x07, 0xe1,
-    0x2b, 0x65, 0x68, 0xa3, 0xe0, 0x0a, 0x23, 0x04,
+    0x04, 0x00, 0xa9, 0xa1, 0x00, 0x82, 0xa1, 0x01,
+    0x81, 0xa1, 0x4a, 0x82, 0x04, 0xa7, 0x70, 0x07,
+    0xa9, 0x86, 0x15, 0x99, 0x73, 0x25, 0x9b, 0x18,
+    0x13, 0x96, 0x26, 0x08, 0xcd, 0x0e, 0x03, 0xa3,
+    0x0e, 0x08, 0x80, 0x0e, 0xc2, 0x3c, 0x09, 0x80,
+    0x3c, 0x01, 0x98, 0x87, 0x06, 0x89, 0x87, 0x05,
+    0xb4, 0x15, 0x00, 0x91, 0x15, 0x07, 0xa6, 0x50,
+    0x08, 0xdf, 0x81, 0x00, 0x93, 0x85, 0x0a, 0x91,
+    0x43, 0x00, 0xae, 0x43, 0x3d, 0x86, 0x5f, 0x00,
+    0x80, 0x5f, 0x00, 0x83, 0x5f, 0x00, 0x8e, 0x5f,
+    0x00, 0x8a, 0x5f, 0x05, 0xba, 0x45, 0x04, 0x89,
+    0x45, 0x05, 0x83, 0x2b, 0x00, 0x87, 0x2b, 0x01,
+    0x81, 0x2b, 0x01, 0x95, 0x2b, 0x00, 0x86, 0x2b,
+    0x00, 0x81, 0x2b, 0x00, 0x84, 0x2b, 0x00, 0x80,
+    0x38, 0x88, 0x2b, 0x01, 0x81, 0x2b, 0x01, 0x82,
+    0x2b, 0x01, 0x80, 0x2b, 0x05, 0x80, 0x2b, 0x04,
+    0x86, 0x2b, 0x01, 0x86, 0x2b, 0x02, 0x84, 0x2b,
+    0x60, 0x2a, 0xdb, 0x65, 0x00, 0x84, 0x65, 0x1d,
+    0xc7, 0x99, 0x07, 0x89, 0x99, 0x60, 0x45, 0xb5,
+    0x83, 0x01, 0xa5, 0x83, 0x21, 0xc4, 0x5c, 0x0a,
+    0x89, 0x5c, 0x05, 0x8c, 0x5d, 0x12, 0xb9, 0x91,
+    0x05, 0x89, 0x91, 0x35, 0x9a, 0x02, 0x01, 0x8e,
+    0x02, 0x03, 0x96, 0x02, 0x60, 0x58, 0xbb, 0x22,
+    0x60, 0x03, 0xd2, 0xa0, 0x0b, 0x80, 0xa0, 0x86,
+    0x21, 0x01, 0x80, 0x21, 0x01, 0x87, 0x21, 0x00,
+    0x81, 0x21, 0x00, 0x9d, 0x21, 0x00, 0x81, 0x21,
+    0x01, 0x8b, 0x21, 0x08, 0x89, 0x21, 0x45, 0x87,
+    0x63, 0x01, 0xad, 0x63, 0x01, 0x8a, 0x63, 0x1a,
+    0xc7, 0xa3, 0x07, 0xd2, 0x88, 0x0c, 0x8f, 0x12,
+    0xb8, 0x79, 0x06, 0x89, 0x20, 0x60, 0x95, 0x88,
+    0x0c, 0x00, 0xac, 0x0c, 0x00, 0x8d, 0x0c, 0x09,
+    0x9c, 0x0c, 0x02, 0x9f, 0x54, 0x01, 0x95, 0x54,
+    0x00, 0x8d, 0x54, 0x48, 0x86, 0x55, 0x00, 0x81,
+    0x55, 0x00, 0xab, 0x55, 0x02, 0x80, 0x55, 0x00,
+    0x81, 0x55, 0x00, 0x88, 0x55, 0x07, 0x89, 0x55,
+    0x05, 0x85, 0x2e, 0x00, 0x81, 0x2e, 0x00, 0xa4,
+    0x2e, 0x00, 0x81, 0x2e, 0x00, 0x85, 0x2e, 0x06,
+    0x89, 0x2e, 0x60, 0xd5, 0x98, 0x4f, 0x06, 0x90,
+    0x3f, 0x00, 0xa8, 0x3f, 0x02, 0x9b, 0x3f, 0x55,
+    0x80, 0x4c, 0x0e, 0xb1, 0x92, 0x0c, 0x80, 0x92,
+    0xe3, 0x39, 0x1b, 0x60, 0x05, 0xe0, 0x0e, 0x1b,
+    0x00, 0x84, 0x1b, 0x0a, 0xe0, 0x63, 0x1b, 0x69,
+    0xeb, 0xe0, 0x02, 0x1e, 0x0c, 0xe3, 0xf5, 0x24,
+    0x6f, 0x49, 0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58,
+    0xe1, 0xd8, 0x08, 0x06, 0x9e, 0x5e, 0x00, 0x89,
+    0x5e, 0x03, 0x81, 0x5e, 0xce, 0x9a, 0x00, 0x89,
+    0x9a, 0x05, 0x9d, 0x09, 0x01, 0x85, 0x09, 0x09,
+    0xc5, 0x77, 0x09, 0x89, 0x77, 0x00, 0x86, 0x77,
+    0x00, 0x94, 0x77, 0x04, 0x92, 0x77, 0x62, 0x4f,
+    0xda, 0x56, 0x60, 0x04, 0xca, 0x5b, 0x03, 0xb8,
+    0x5b, 0x06, 0x90, 0x5b, 0x3f, 0x80, 0x93, 0x80,
+    0x67, 0x81, 0x30, 0x80, 0x44, 0x0a, 0x81, 0x30,
+    0x0d, 0xf0, 0x07, 0x97, 0x93, 0x07, 0xe2, 0x9f,
+    0x93, 0xe1, 0x75, 0x44, 0x29, 0x88, 0x93, 0x70,
+    0x12, 0x86, 0x83, 0x3e, 0x00, 0x86, 0x3e, 0x00,
+    0x81, 0x3e, 0x00, 0x80, 0x3e, 0xe0, 0xbe, 0x36,
+    0x82, 0x3e, 0x0e, 0x80, 0x36, 0x1c, 0x82, 0x36,
+    0x01, 0x80, 0x3e, 0x0d, 0x83, 0x3e, 0x07, 0xe1,
+    0x2b, 0x67, 0x68, 0xa3, 0xe0, 0x0a, 0x23, 0x04,
     0x8c, 0x23, 0x02, 0x88, 0x23, 0x06, 0x89, 0x23,
     0x01, 0x83, 0x23, 0x83, 0x19, 0x70, 0x01, 0xfb,
     0xad, 0x38, 0x01, 0x96, 0x38, 0x08, 0xe0, 0x13,
     0x19, 0x3b, 0xe0, 0x95, 0x19, 0x09, 0xa6, 0x19,
     0x01, 0xbd, 0x19, 0x82, 0x38, 0x90, 0x19, 0x87,
     0x38, 0x81, 0x19, 0x86, 0x38, 0x9d, 0x19, 0x83,
-    0x38, 0xbc, 0x19, 0x14, 0xc5, 0x2c, 0x60, 0x39,
-    0x93, 0x19, 0x0b, 0xd6, 0x19, 0x08, 0x98, 0x19,
-    0x60, 0x26, 0xd4, 0x19, 0x00, 0xc6, 0x19, 0x00,
-    0x81, 0x19, 0x01, 0x80, 0x19, 0x01, 0x81, 0x19,
-    0x01, 0x83, 0x19, 0x00, 0x8b, 0x19, 0x00, 0x80,
-    0x19, 0x00, 0x86, 0x19, 0x00, 0xc0, 0x19, 0x00,
-    0x83, 0x19, 0x01, 0x87, 0x19, 0x00, 0x86, 0x19,
-    0x00, 0x9b, 0x19, 0x00, 0x83, 0x19, 0x00, 0x84,
-    0x19, 0x00, 0x80, 0x19, 0x02, 0x86, 0x19, 0x00,
-    0xe0, 0xf3, 0x19, 0x01, 0xe0, 0xc3, 0x19, 0x01,
-    0xb1, 0x19, 0xe2, 0x2b, 0x82, 0x0e, 0x84, 0x82,
-    0x00, 0x8e, 0x82, 0x63, 0xef, 0x9e, 0x46, 0x60,
-    0x80, 0x86, 0x29, 0x00, 0x90, 0x29, 0x01, 0x86,
-    0x29, 0x00, 0x81, 0x29, 0x00, 0x84, 0x29, 0x60,
-    0x74, 0xac, 0x66, 0x02, 0x8d, 0x66, 0x01, 0x89,
-    0x66, 0x03, 0x81, 0x66, 0x60, 0xdf, 0x9e, 0x99,
-    0x10, 0xb9, 0x9d, 0x04, 0x80, 0x9d, 0x64, 0x7f,
+    0x38, 0xbc, 0x19, 0x14, 0xc5, 0x2c, 0x60, 0x19,
+    0x93, 0x19, 0x0b, 0x93, 0x19, 0x0b, 0xd6, 0x19,
+    0x08, 0x98, 0x19, 0x60, 0x26, 0xd4, 0x19, 0x00,
+    0xc6, 0x19, 0x00, 0x81, 0x19, 0x01, 0x80, 0x19,
+    0x01, 0x81, 0x19, 0x01, 0x83, 0x19, 0x00, 0x8b,
+    0x19, 0x00, 0x80, 0x19, 0x00, 0x86, 0x19, 0x00,
+    0xc0, 0x19, 0x00, 0x83, 0x19, 0x01, 0x87, 0x19,
+    0x00, 0x86, 0x19, 0x00, 0x9b, 0x19, 0x00, 0x83,
+    0x19, 0x00, 0x84, 0x19, 0x00, 0x80, 0x19, 0x02,
+    0x86, 0x19, 0x00, 0xe0, 0xf3, 0x19, 0x01, 0xe0,
+    0xc3, 0x19, 0x01, 0xb1, 0x19, 0xe2, 0x2b, 0x84,
+    0x0e, 0x84, 0x84, 0x00, 0x8e, 0x84, 0x63, 0xef,
+    0x9e, 0x47, 0x05, 0x85, 0x47, 0x60, 0x74, 0x86,
+    0x29, 0x00, 0x90, 0x29, 0x01, 0x86, 0x29, 0x00,
+    0x81, 0x29, 0x00, 0x84, 0x29, 0x04, 0xbd, 0x1d,
+    0x20, 0x80, 0x1d, 0x60, 0x0f, 0xac, 0x68, 0x02,
+    0x8d, 0x68, 0x01, 0x89, 0x68, 0x03, 0x81, 0x68,
+    0x60, 0xdf, 0x9e, 0x9b, 0x10, 0xb9, 0x9f, 0x04,
+    0x80, 0x9f, 0x61, 0x6f, 0xa9, 0x62, 0x62, 0x85,
     0x86, 0x27, 0x00, 0x83, 0x27, 0x00, 0x81, 0x27,
-    0x00, 0x8e, 0x27, 0x00, 0xe0, 0x64, 0x57, 0x01,
-    0x8f, 0x57, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
+    0x00, 0x8e, 0x27, 0x00, 0xe0, 0x64, 0x58, 0x01,
+    0x8f, 0x58, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
     0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19, 0x4b,
     0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a,
     0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
@@ -3455,86 +3491,85 @@ static const uint8_t unicode_script_table[2690] = {
     0x19, 0x37, 0x99, 0x19, 0x80, 0x36, 0x81, 0x19,
     0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06, 0x81,
     0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3, 0x77,
-    0x19, 0x04, 0x8f, 0x19, 0x02, 0x8c, 0x19, 0x02,
-    0xe0, 0x13, 0x19, 0x0b, 0xd8, 0x19, 0x06, 0x8b,
+    0x19, 0x03, 0x90, 0x19, 0x02, 0x8c, 0x19, 0x02,
+    0xe0, 0x16, 0x19, 0x03, 0xde, 0x19, 0x05, 0x8b,
     0x19, 0x03, 0x80, 0x19, 0x0e, 0x8b, 0x19, 0x03,
     0xb7, 0x19, 0x07, 0x89, 0x19, 0x05, 0xa7, 0x19,
     0x07, 0x9d, 0x19, 0x01, 0x81, 0x19, 0x4d, 0xe0,
-    0xf3, 0x19, 0x0b, 0x8d, 0x19, 0x01, 0x84, 0x19,
-    0x02, 0x84, 0x19, 0x02, 0x86, 0x19, 0x08, 0x9c,
-    0x19, 0x02, 0x8a, 0x19, 0x04, 0x85, 0x19, 0x09,
-    0x89, 0x19, 0x05, 0x87, 0x19, 0x07, 0x86, 0x19,
-    0x08, 0xe0, 0x32, 0x19, 0x00, 0xb6, 0x19, 0x24,
-    0x89, 0x19, 0x63, 0xa5, 0xf0, 0x96, 0x7f, 0x30,
-    0x1f, 0xef, 0xd8, 0x30, 0x06, 0xe0, 0x7d, 0x30,
-    0x01, 0xf0, 0x06, 0x21, 0x30, 0x0d, 0xf0, 0x0c,
-    0xd0, 0x30, 0x6b, 0xbe, 0xe1, 0xbd, 0x30, 0x65,
-    0x81, 0xf0, 0x02, 0xea, 0x30, 0x7a, 0xdc, 0x55,
-    0x80, 0x19, 0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0,
-    0x8f, 0x38,
+    0xf3, 0x19, 0x0b, 0x8d, 0x19, 0x01, 0x8c, 0x19,
+    0x02, 0x88, 0x19, 0x06, 0xad, 0x19, 0x00, 0x86,
+    0x19, 0x07, 0x8d, 0x19, 0x03, 0x88, 0x19, 0x06,
+    0x88, 0x19, 0x06, 0xe0, 0x32, 0x19, 0x00, 0xb6,
+    0x19, 0x24, 0x89, 0x19, 0x63, 0xa5, 0xf0, 0x96,
+    0x7f, 0x30, 0x1f, 0xef, 0xd9, 0x30, 0x05, 0xe0,
+    0x7d, 0x30, 0x01, 0xf0, 0x06, 0x21, 0x30, 0x0d,
+    0xf0, 0x0c, 0xd0, 0x30, 0x6b, 0xbe, 0xe1, 0xbd,
+    0x30, 0x65, 0x81, 0xf0, 0x02, 0xea, 0x30, 0x04,
+    0xef, 0xff, 0x30, 0x7a, 0xcb, 0xf0, 0x80, 0x19,
+    0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0, 0x8f, 0x38,
 };
 
 static const uint8_t unicode_script_ext_table[828] = {
     0x82, 0xc1, 0x00, 0x00, 0x01, 0x2c, 0x01, 0x00,
-    0x00, 0x01, 0x2c, 0x1c, 0x00, 0x0c, 0x01, 0x46,
-    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6c, 0x00,
-    0x02, 0x1d, 0x29, 0x01, 0x02, 0x1d, 0x46, 0x00,
+    0x00, 0x01, 0x2c, 0x1c, 0x00, 0x0c, 0x01, 0x47,
+    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6e, 0x00,
+    0x02, 0x1d, 0x29, 0x01, 0x02, 0x1d, 0x47, 0x00,
     0x02, 0x1d, 0x29, 0x81, 0x03, 0x00, 0x00, 0x06,
-    0x04, 0x64, 0x32, 0x89, 0x93, 0x9f, 0x0d, 0x00,
-    0x00, 0x06, 0x04, 0x64, 0x32, 0x89, 0x93, 0x9f,
-    0x00, 0x03, 0x04, 0x89, 0x93, 0x01, 0x00, 0x00,
-    0x07, 0x01, 0x04, 0x64, 0x32, 0x89, 0x93, 0x9f,
-    0x1f, 0x00, 0x00, 0x09, 0x01, 0x04, 0x51, 0x52,
-    0x71, 0x7a, 0x32, 0x84, 0x89, 0x09, 0x00, 0x0a,
-    0x02, 0x04, 0x89, 0x09, 0x00, 0x09, 0x03, 0x04,
-    0x93, 0x9f, 0x05, 0x00, 0x00, 0x02, 0x04, 0x89,
+    0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1, 0x0d, 0x00,
+    0x00, 0x06, 0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1,
+    0x00, 0x03, 0x04, 0x8b, 0x95, 0x01, 0x00, 0x00,
+    0x07, 0x01, 0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1,
+    0x1f, 0x00, 0x00, 0x09, 0x01, 0x04, 0x52, 0x53,
+    0x73, 0x7c, 0x32, 0x86, 0x8b, 0x09, 0x00, 0x0a,
+    0x02, 0x04, 0x8b, 0x09, 0x00, 0x09, 0x03, 0x04,
+    0x95, 0xa1, 0x05, 0x00, 0x00, 0x02, 0x04, 0x8b,
     0x62, 0x00, 0x00, 0x02, 0x04, 0x32, 0x81, 0xfb,
     0x00, 0x00, 0x0d, 0x0b, 0x20, 0x2b, 0x2d, 0x2f,
-    0x3d, 0x46, 0x50, 0x72, 0x7f, 0x90, 0x92, 0x97,
+    0x3d, 0x47, 0x51, 0x74, 0x81, 0x92, 0x94, 0x99,
     0x00, 0x0c, 0x0b, 0x20, 0x2b, 0x2d, 0x2f, 0x3d,
-    0x46, 0x50, 0x72, 0x90, 0x92, 0x97, 0x10, 0x00,
-    0x00, 0x14, 0x0b, 0x20, 0x22, 0x2e, 0x54, 0x2b,
-    0x2d, 0x2f, 0x3d, 0x4f, 0x50, 0x61, 0x72, 0x44,
-    0x83, 0x88, 0x8f, 0x90, 0x92, 0x97, 0x00, 0x15,
-    0x0b, 0x20, 0x22, 0x2e, 0x54, 0x2b, 0x2d, 0x2f,
-    0x3d, 0x48, 0x4f, 0x50, 0x61, 0x72, 0x44, 0x83,
-    0x88, 0x8f, 0x90, 0x92, 0x97, 0x09, 0x04, 0x20,
-    0x22, 0x3c, 0x4f, 0x75, 0x00, 0x09, 0x03, 0x0b,
-    0x15, 0x88, 0x75, 0x00, 0x09, 0x02, 0x2f, 0x5e,
-    0x75, 0x00, 0x09, 0x02, 0x2d, 0x42, 0x80, 0x75,
-    0x00, 0x0d, 0x02, 0x2b, 0x90, 0x80, 0x71, 0x00,
-    0x09, 0x02, 0x3d, 0x61, 0x82, 0xcf, 0x00, 0x09,
-    0x03, 0x15, 0x5f, 0x8c, 0x80, 0x30, 0x00, 0x00,
-    0x02, 0x28, 0x46, 0x85, 0xb8, 0x00, 0x01, 0x04,
-    0x11, 0x33, 0x8b, 0x8a, 0x80, 0x4a, 0x00, 0x01,
-    0x02, 0x5c, 0x78, 0x00, 0x00, 0x00, 0x02, 0x5c,
-    0x78, 0x84, 0x49, 0x00, 0x00, 0x04, 0x0b, 0x20,
+    0x47, 0x51, 0x74, 0x92, 0x94, 0x99, 0x10, 0x00,
+    0x00, 0x14, 0x0b, 0x20, 0x22, 0x2e, 0x55, 0x2b,
+    0x2d, 0x2f, 0x3d, 0x50, 0x51, 0x63, 0x74, 0x45,
+    0x85, 0x8a, 0x91, 0x92, 0x94, 0x99, 0x00, 0x15,
+    0x0b, 0x20, 0x22, 0x2e, 0x55, 0x2b, 0x2d, 0x2f,
+    0x3d, 0x49, 0x50, 0x51, 0x63, 0x74, 0x45, 0x85,
+    0x8a, 0x91, 0x92, 0x94, 0x99, 0x09, 0x04, 0x20,
+    0x22, 0x3c, 0x50, 0x75, 0x00, 0x09, 0x03, 0x0b,
+    0x15, 0x8a, 0x75, 0x00, 0x09, 0x02, 0x2f, 0x5f,
+    0x75, 0x00, 0x09, 0x02, 0x2d, 0x43, 0x80, 0x75,
+    0x00, 0x0d, 0x02, 0x2b, 0x92, 0x80, 0x71, 0x00,
+    0x09, 0x02, 0x3d, 0x63, 0x82, 0xcf, 0x00, 0x09,
+    0x03, 0x15, 0x60, 0x8e, 0x80, 0x30, 0x00, 0x00,
+    0x02, 0x28, 0x47, 0x85, 0xb8, 0x00, 0x01, 0x04,
+    0x11, 0x33, 0x8d, 0x8c, 0x80, 0x4a, 0x00, 0x01,
+    0x02, 0x5d, 0x7a, 0x00, 0x00, 0x00, 0x02, 0x5d,
+    0x7a, 0x84, 0x49, 0x00, 0x00, 0x04, 0x0b, 0x20,
     0x2b, 0x3d, 0x00, 0x01, 0x20, 0x00, 0x04, 0x0b,
     0x20, 0x2b, 0x3d, 0x00, 0x02, 0x20, 0x2b, 0x00,
     0x01, 0x20, 0x01, 0x02, 0x0b, 0x20, 0x00, 0x02,
-    0x20, 0x7f, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x02,
-    0x20, 0x7f, 0x00, 0x06, 0x20, 0x3d, 0x50, 0x72,
-    0x90, 0x92, 0x00, 0x01, 0x20, 0x01, 0x02, 0x20,
-    0x7f, 0x01, 0x01, 0x20, 0x00, 0x02, 0x20, 0x7f,
+    0x20, 0x81, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x02,
+    0x20, 0x81, 0x00, 0x06, 0x20, 0x3d, 0x51, 0x74,
+    0x92, 0x94, 0x00, 0x01, 0x20, 0x01, 0x02, 0x20,
+    0x81, 0x01, 0x01, 0x20, 0x00, 0x02, 0x20, 0x81,
     0x00, 0x02, 0x0b, 0x20, 0x06, 0x01, 0x20, 0x00,
-    0x02, 0x20, 0x61, 0x00, 0x02, 0x0b, 0x20, 0x01,
+    0x02, 0x20, 0x63, 0x00, 0x02, 0x0b, 0x20, 0x01,
     0x01, 0x20, 0x00, 0x02, 0x0b, 0x20, 0x03, 0x01,
-    0x20, 0x00, 0x08, 0x0b, 0x20, 0x2b, 0x3d, 0x61,
-    0x72, 0x92, 0x97, 0x00, 0x02, 0x20, 0x2b, 0x00,
+    0x20, 0x00, 0x08, 0x0b, 0x20, 0x2b, 0x3d, 0x63,
+    0x74, 0x94, 0x99, 0x00, 0x02, 0x20, 0x2b, 0x00,
     0x03, 0x20, 0x2b, 0x3d, 0x01, 0x02, 0x0b, 0x20,
     0x00, 0x01, 0x0b, 0x01, 0x02, 0x20, 0x2b, 0x00,
-    0x01, 0x61, 0x80, 0x44, 0x00, 0x01, 0x01, 0x2c,
-    0x35, 0x00, 0x00, 0x02, 0x1d, 0x89, 0x00, 0x00,
-    0x00, 0x01, 0x89, 0x81, 0xb3, 0x00, 0x00, 0x02,
-    0x46, 0x5c, 0x80, 0x3f, 0x00, 0x00, 0x03, 0x20,
-    0x2b, 0x46, 0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d,
+    0x01, 0x63, 0x80, 0x44, 0x00, 0x01, 0x01, 0x2c,
+    0x35, 0x00, 0x00, 0x02, 0x1d, 0x8b, 0x00, 0x00,
+    0x00, 0x01, 0x8b, 0x81, 0xb3, 0x00, 0x00, 0x02,
+    0x47, 0x5d, 0x80, 0x3f, 0x00, 0x00, 0x03, 0x20,
+    0x2b, 0x47, 0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d,
     0x29, 0x81, 0x3c, 0x00, 0x01, 0x06, 0x0d, 0x31,
-    0x30, 0x36, 0x3e, 0xa0, 0x00, 0x05, 0x0d, 0x31,
+    0x30, 0x36, 0x3e, 0xa2, 0x00, 0x05, 0x0d, 0x31,
     0x30, 0x36, 0x3e, 0x01, 0x00, 0x00, 0x01, 0x30,
     0x00, 0x00, 0x09, 0x06, 0x0d, 0x31, 0x30, 0x36,
-    0x3e, 0xa0, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x31,
+    0x3e, 0xa2, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x31,
     0x30, 0x36, 0x3e, 0x07, 0x06, 0x0d, 0x31, 0x30,
-    0x36, 0x3e, 0xa0, 0x03, 0x05, 0x0d, 0x31, 0x30,
+    0x36, 0x3e, 0xa2, 0x03, 0x05, 0x0d, 0x31, 0x30,
     0x36, 0x3e, 0x09, 0x00, 0x03, 0x02, 0x0d, 0x30,
     0x01, 0x00, 0x00, 0x05, 0x0d, 0x31, 0x30, 0x36,
     0x3e, 0x04, 0x02, 0x36, 0x3e, 0x00, 0x00, 0x00,
@@ -3542,7 +3577,7 @@ static const uint8_t unicode_script_ext_table[828] = {
     0x01, 0x03, 0x30, 0x36, 0x3e, 0x01, 0x01, 0x30,
     0x58, 0x00, 0x03, 0x02, 0x36, 0x3e, 0x02, 0x00,
     0x00, 0x02, 0x36, 0x3e, 0x59, 0x00, 0x00, 0x06,
-    0x0d, 0x31, 0x30, 0x36, 0x3e, 0xa0, 0x00, 0x02,
+    0x0d, 0x31, 0x30, 0x36, 0x3e, 0xa2, 0x00, 0x02,
     0x36, 0x3e, 0x80, 0x12, 0x00, 0x0f, 0x01, 0x30,
     0x1f, 0x00, 0x23, 0x01, 0x30, 0x3b, 0x00, 0x27,
     0x01, 0x30, 0x37, 0x00, 0x30, 0x01, 0x30, 0x0e,
@@ -3550,32 +3585,32 @@ static const uint8_t unicode_script_ext_table[828] = {
     0x30, 0x57, 0x00, 0x18, 0x01, 0x30, 0x09, 0x00,
     0x04, 0x01, 0x30, 0x5f, 0x00, 0x1e, 0x01, 0x30,
     0xc0, 0x31, 0xef, 0x00, 0x00, 0x02, 0x1d, 0x29,
-    0x80, 0x0f, 0x00, 0x07, 0x02, 0x30, 0x46, 0x80,
+    0x80, 0x0f, 0x00, 0x07, 0x02, 0x30, 0x47, 0x80,
     0xa7, 0x00, 0x02, 0x0e, 0x20, 0x22, 0x2d, 0x2f,
-    0x42, 0x3d, 0x3c, 0x4f, 0x50, 0x5b, 0x61, 0x44,
-    0x8f, 0x97, 0x02, 0x0d, 0x20, 0x22, 0x2d, 0x2f,
-    0x42, 0x3d, 0x3c, 0x4f, 0x5b, 0x61, 0x44, 0x8f,
-    0x97, 0x03, 0x0b, 0x20, 0x22, 0x2d, 0x2f, 0x42,
-    0x3c, 0x4f, 0x5b, 0x44, 0x8f, 0x97, 0x80, 0x36,
+    0x43, 0x3d, 0x3c, 0x50, 0x51, 0x5c, 0x63, 0x45,
+    0x91, 0x99, 0x02, 0x0d, 0x20, 0x22, 0x2d, 0x2f,
+    0x43, 0x3d, 0x3c, 0x50, 0x5c, 0x63, 0x45, 0x91,
+    0x99, 0x03, 0x0b, 0x20, 0x22, 0x2d, 0x2f, 0x43,
+    0x3c, 0x50, 0x5c, 0x45, 0x91, 0x99, 0x80, 0x36,
     0x00, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x00, 0x00,
-    0x02, 0x20, 0x90, 0x39, 0x00, 0x00, 0x03, 0x3f,
-    0x46, 0x5f, 0x80, 0x1f, 0x00, 0x00, 0x02, 0x10,
+    0x02, 0x20, 0x92, 0x39, 0x00, 0x00, 0x03, 0x40,
+    0x47, 0x60, 0x80, 0x1f, 0x00, 0x00, 0x02, 0x10,
     0x3b, 0xc0, 0x12, 0xed, 0x00, 0x01, 0x02, 0x04,
-    0x64, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04, 0x93,
-    0x09, 0x00, 0x00, 0x02, 0x04, 0x93, 0x46, 0x00,
+    0x66, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04, 0x95,
+    0x09, 0x00, 0x00, 0x02, 0x04, 0x95, 0x46, 0x00,
     0x01, 0x05, 0x0d, 0x31, 0x30, 0x36, 0x3e, 0x80,
     0x99, 0x00, 0x04, 0x06, 0x0d, 0x31, 0x30, 0x36,
-    0x3e, 0xa0, 0x09, 0x00, 0x00, 0x02, 0x36, 0x3e,
+    0x3e, 0xa2, 0x09, 0x00, 0x00, 0x02, 0x36, 0x3e,
     0x2c, 0x00, 0x01, 0x02, 0x36, 0x3e, 0x80, 0xdf,
-    0x00, 0x01, 0x03, 0x1e, 0x1c, 0x4a, 0x00, 0x02,
-    0x1c, 0x4a, 0x03, 0x00, 0x2c, 0x03, 0x1c, 0x49,
-    0x4a, 0x02, 0x00, 0x08, 0x02, 0x1c, 0x4a, 0x81,
+    0x00, 0x01, 0x03, 0x1e, 0x1c, 0x4b, 0x00, 0x02,
+    0x1c, 0x4b, 0x03, 0x00, 0x2c, 0x03, 0x1c, 0x4a,
+    0x4b, 0x02, 0x00, 0x08, 0x02, 0x1c, 0x4b, 0x81,
     0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a, 0x87, 0x75,
-    0x00, 0x00, 0x02, 0x52, 0x71, 0x87, 0x8d, 0x00,
-    0x00, 0x02, 0x2b, 0x90, 0x00, 0x00, 0x00, 0x02,
-    0x2b, 0x90, 0x36, 0x00, 0x01, 0x02, 0x2b, 0x90,
-    0x8c, 0x12, 0x00, 0x01, 0x02, 0x2b, 0x90, 0x00,
-    0x00, 0x00, 0x02, 0x2b, 0x90, 0xc0, 0x5c, 0x4b,
+    0x00, 0x00, 0x02, 0x53, 0x73, 0x87, 0x8d, 0x00,
+    0x00, 0x02, 0x2b, 0x92, 0x00, 0x00, 0x00, 0x02,
+    0x2b, 0x92, 0x36, 0x00, 0x01, 0x02, 0x2b, 0x92,
+    0x8c, 0x12, 0x00, 0x01, 0x02, 0x2b, 0x92, 0x00,
+    0x00, 0x00, 0x02, 0x2b, 0x92, 0xc0, 0x5c, 0x4b,
     0x00, 0x03, 0x01, 0x23, 0x96, 0x3b, 0x00, 0x11,
     0x01, 0x30, 0x9e, 0x5d, 0x00, 0x01, 0x01, 0x30,
     0xce, 0xcd, 0x2d, 0x00,
@@ -3616,7 +3651,7 @@ static const uint8_t unicode_prop_Other_Math_table[200] = {
     0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
 };
 
-static const uint8_t unicode_prop_Other_Alphabetic_table[417] = {
+static const uint8_t unicode_prop_Other_Alphabetic_table[428] = {
     0x43, 0x44, 0x80, 0x42, 0x69, 0x8d, 0x00, 0x01,
     0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c, 0x06, 0x8f,
     0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80,
@@ -3628,59 +3663,61 @@ static const uint8_t unicode_prop_Other_Alphabetic_table[417] = {
     0x0a, 0x80, 0x8a, 0x82, 0xb9, 0x38, 0x10, 0x81,
     0x94, 0x81, 0x95, 0x13, 0x82, 0xb9, 0x31, 0x09,
     0x81, 0x88, 0x81, 0x89, 0x81, 0x9d, 0x80, 0xba,
-    0x22, 0x10, 0x82, 0x89, 0x80, 0xa7, 0x83, 0xb9,
+    0x22, 0x10, 0x82, 0x89, 0x80, 0xa7, 0x84, 0xb8,
     0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9c, 0x82,
-    0xb9, 0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9b,
-    0x83, 0xb9, 0x30, 0x10, 0x82, 0x89, 0x80, 0x89,
-    0x81, 0x9c, 0x82, 0xca, 0x28, 0x00, 0x87, 0x91,
-    0x81, 0xbc, 0x01, 0x86, 0x91, 0x80, 0xe2, 0x01,
-    0x28, 0x81, 0x8f, 0x80, 0x40, 0xa2, 0x90, 0x8a,
-    0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00, 0x0b, 0x96,
-    0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c, 0x8b, 0x00,
-    0x89, 0x83, 0x46, 0x73, 0x81, 0x9d, 0x81, 0x9d,
-    0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40, 0xbb, 0x81,
-    0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88, 0x40, 0xdd,
-    0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9, 0x81, 0x8a,
-    0x82, 0xb0, 0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d,
-    0x88, 0x09, 0xb8, 0x8a, 0xb1, 0x92, 0x41, 0xaf,
-    0x8d, 0x46, 0xc0, 0xb3, 0x48, 0xf5, 0x9f, 0x60,
-    0x78, 0x73, 0x87, 0xa1, 0x81, 0x41, 0x61, 0x07,
-    0x80, 0x96, 0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00,
-    0xb8, 0x80, 0xa5, 0x84, 0x9b, 0x8b, 0xac, 0x83,
-    0xaf, 0x8b, 0xa4, 0x80, 0xc2, 0x8d, 0x8b, 0x07,
-    0x81, 0xac, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x80,
-    0xab, 0x24, 0x80, 0x40, 0xec, 0x87, 0x60, 0x4f,
-    0x32, 0x80, 0x48, 0x56, 0x84, 0x46, 0x85, 0x10,
-    0x0c, 0x83, 0x43, 0x13, 0x83, 0x41, 0x82, 0x81,
-    0x41, 0x52, 0x82, 0xb4, 0x8d, 0xac, 0x81, 0x8c,
-    0x80, 0xac, 0x88, 0x88, 0x80, 0xbc, 0x82, 0xa3,
-    0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf, 0x8c, 0x8d,
-    0x81, 0xdb, 0x88, 0x08, 0x28, 0x40, 0x9f, 0x89,
-    0x96, 0x83, 0xb9, 0x31, 0x09, 0x81, 0x89, 0x80,
-    0x89, 0x81, 0x40, 0xd0, 0x8c, 0x02, 0xe9, 0x91,
-    0x40, 0xec, 0x31, 0x86, 0x9c, 0x81, 0xd1, 0x8e,
-    0x00, 0xe9, 0x8a, 0xe6, 0x8d, 0x41, 0x00, 0x8c,
-    0x40, 0xf6, 0x28, 0x09, 0x0a, 0x00, 0x80, 0x40,
-    0x8d, 0x31, 0x2b, 0x80, 0x9b, 0x89, 0xa9, 0x20,
-    0x83, 0x91, 0x8a, 0xad, 0x8d, 0x41, 0x96, 0x38,
-    0x86, 0xd2, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00,
-    0x08, 0x10, 0x02, 0x80, 0xc1, 0x20, 0x08, 0x83,
-    0x41, 0x5b, 0x83, 0x60, 0x50, 0x57, 0x00, 0xb6,
-    0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80, 0x60,
-    0x23, 0x60, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x49,
-    0x1b, 0x80, 0x47, 0xe7, 0x99, 0x85, 0x99, 0x85,
-    0x99,
+    0xb9, 0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x8e,
+    0x80, 0x8b, 0x83, 0xb9, 0x30, 0x10, 0x82, 0x89,
+    0x80, 0x89, 0x81, 0x9c, 0x82, 0xca, 0x28, 0x00,
+    0x87, 0x91, 0x81, 0xbc, 0x01, 0x86, 0x91, 0x80,
+    0xe2, 0x01, 0x28, 0x81, 0x8f, 0x80, 0x40, 0xa2,
+    0x92, 0x88, 0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00,
+    0x0b, 0x96, 0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c,
+    0x8b, 0x00, 0x89, 0x83, 0x46, 0x73, 0x81, 0x9d,
+    0x81, 0x9d, 0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40,
+    0xbb, 0x81, 0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88,
+    0x40, 0xdd, 0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9,
+    0x81, 0x8a, 0x82, 0xb0, 0x84, 0xaf, 0x8e, 0xbb,
+    0x82, 0x9d, 0x88, 0x09, 0xb8, 0x8a, 0xb1, 0x92,
+    0x41, 0xaf, 0x8d, 0x46, 0xc0, 0xb3, 0x48, 0xf5,
+    0x9f, 0x60, 0x78, 0x73, 0x87, 0xa1, 0x81, 0x41,
+    0x61, 0x07, 0x80, 0x96, 0x84, 0xd7, 0x81, 0xb1,
+    0x8f, 0x00, 0xb8, 0x80, 0xa5, 0x84, 0x9b, 0x8b,
+    0xac, 0x83, 0xaf, 0x8b, 0xa4, 0x80, 0xc2, 0x8d,
+    0x8b, 0x07, 0x81, 0xac, 0x82, 0xb1, 0x00, 0x11,
+    0x0c, 0x80, 0xab, 0x24, 0x80, 0x40, 0xec, 0x87,
+    0x60, 0x4f, 0x32, 0x80, 0x48, 0x56, 0x84, 0x46,
+    0x85, 0x10, 0x0c, 0x83, 0x43, 0x13, 0x83, 0x41,
+    0x82, 0x81, 0x41, 0x52, 0x82, 0xb4, 0x8d, 0xac,
+    0x81, 0x8a, 0x82, 0xac, 0x88, 0x88, 0x80, 0xbc,
+    0x82, 0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf,
+    0x8c, 0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x08,
+    0x40, 0x9c, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09,
+    0x81, 0x89, 0x80, 0x89, 0x81, 0x40, 0xd0, 0x8c,
+    0x02, 0xe9, 0x91, 0x40, 0xec, 0x31, 0x86, 0x9c,
+    0x81, 0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6, 0x8d,
+    0x41, 0x00, 0x8c, 0x40, 0xf6, 0x28, 0x09, 0x0a,
+    0x00, 0x80, 0x40, 0x8d, 0x31, 0x2b, 0x80, 0x9b,
+    0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a, 0xad, 0x8d,
+    0x41, 0x96, 0x38, 0x86, 0xd2, 0x95, 0x80, 0x8d,
+    0xf9, 0x2a, 0x00, 0x08, 0x10, 0x02, 0x80, 0xc1,
+    0x20, 0x08, 0x83, 0x41, 0x5b, 0x83, 0x88, 0x08,
+    0x80, 0xaf, 0x32, 0x82, 0x60, 0x50, 0x0d, 0x00,
+    0xb6, 0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80,
+    0x60, 0x23, 0x60, 0x30, 0x90, 0x0e, 0x01, 0x04,
+    0xe3, 0x80, 0x48, 0xb6, 0x80, 0x47, 0xe7, 0x99,
+    0x85, 0x99, 0x85, 0x99,
 };
 
-static const uint8_t unicode_prop_Other_Lowercase_table[59] = {
+static const uint8_t unicode_prop_Other_Lowercase_table[69] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0x41, 0xf4, 0x88,
-    0x31, 0x9d, 0x84, 0xdf, 0x80, 0xb3, 0x80, 0x59,
-    0xb0, 0xbe, 0x8c, 0x80, 0xa1, 0xa4, 0x42, 0xb0,
-    0x80, 0x8c, 0x80, 0x8f, 0x8c, 0x40, 0xd2, 0x8f,
-    0x43, 0x4f, 0x99, 0x47, 0x91, 0x81, 0x60, 0x7a,
-    0x1d, 0x81, 0x40, 0xd1, 0x80, 0x40, 0x86, 0x81,
-    0x43, 0x61, 0x83, 0x60, 0x5c, 0x1f, 0x01, 0x10,
-    0xa9, 0x80, 0x88,
+    0x31, 0x9d, 0x84, 0xdf, 0x80, 0xb3, 0x80, 0x4d,
+    0x80, 0x80, 0x4c, 0x2e, 0xbe, 0x8c, 0x80, 0xa1,
+    0xa4, 0x42, 0xb0, 0x80, 0x8c, 0x80, 0x8f, 0x8c,
+    0x40, 0xd2, 0x8f, 0x43, 0x4f, 0x99, 0x47, 0x91,
+    0x81, 0x60, 0x7a, 0x1d, 0x81, 0x40, 0xd1, 0x80,
+    0x40, 0x80, 0x12, 0x81, 0x43, 0x61, 0x83, 0x88,
+    0x80, 0x60, 0x5c, 0x15, 0x01, 0x10, 0xa9, 0x80,
+    0x88, 0x60, 0xd8, 0x74, 0xbd,
 };
 
 static const uint8_t unicode_prop_Other_Uppercase_table[15] = {
@@ -3750,7 +3787,7 @@ static const uint8_t unicode_prop_Changes_When_Casefolded1_table[33] = {
     0x84,
 };
 
-static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[448] = {
+static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[451] = {
     0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12,
     0x10, 0x82, 0x9f, 0x80, 0xcf, 0x01, 0x80, 0x8b,
     0x07, 0x80, 0xfb, 0x01, 0x01, 0x80, 0xa5, 0x80,
@@ -3798,15 +3835,16 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[448] = {
     0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80,
     0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04,
     0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23,
-    0x81, 0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01, 0x00,
-    0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18,
-    0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03,
-    0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80,
-    0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80, 0x9f,
-    0x99, 0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c, 0xab,
-    0x83, 0x88, 0x31, 0x49, 0x9d, 0x89, 0x60, 0xfc,
-    0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1, 0x4f, 0xff,
+    0x81, 0xb1, 0x48, 0x2f, 0xbd, 0x4d, 0x91, 0x18,
+    0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00,
+    0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b,
+    0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90,
+    0x22, 0x04, 0x80, 0x90, 0x42, 0x43, 0x8a, 0x84,
+    0x9e, 0x80, 0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee,
+    0x82, 0x8c, 0xab, 0x83, 0x88, 0x31, 0x49, 0x9d,
+    0x89, 0x60, 0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05,
+    0xe1, 0x4f, 0xff,
 };
 
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
@@ -3834,7 +3872,7 @@ static const uint8_t unicode_prop_Deprecated_table[23] = {
     0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
 };
 
-static const uint8_t unicode_prop_Diacritic_table[391] = {
+static const uint8_t unicode_prop_Diacritic_table[399] = {
     0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81,
     0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
     0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0,
@@ -3869,20 +3907,21 @@ static const uint8_t unicode_prop_Diacritic_table[391] = {
     0x00, 0x8f, 0x41, 0x0d, 0x00, 0x80, 0xae, 0x80,
     0xac, 0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x44,
     0x9e, 0x28, 0xa9, 0x80, 0x88, 0x43, 0x29, 0x81,
-    0x42, 0x3a, 0x85, 0x42, 0x1d, 0x8a, 0xb0, 0x83,
-    0x40, 0xbf, 0x80, 0xa8, 0x80, 0xc7, 0x81, 0xf7,
-    0x81, 0xbd, 0x80, 0xcb, 0x80, 0x88, 0x82, 0xe7,
-    0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80, 0x8f, 0x80,
-    0x97, 0x32, 0x84, 0x40, 0xcc, 0x02, 0x80, 0xfa,
-    0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80, 0xf5, 0x81,
-    0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0x01, 0x0b,
-    0x80, 0x40, 0x9b, 0x80, 0xd2, 0x80, 0x91, 0x80,
-    0xd0, 0x80, 0x41, 0xa4, 0x80, 0x41, 0x01, 0x00,
-    0x81, 0xd0, 0x80, 0x60, 0x4d, 0x57, 0x84, 0xba,
-    0x86, 0x44, 0x57, 0x90, 0xcf, 0x81, 0x60, 0x3f,
-    0xfd, 0x18, 0x30, 0x81, 0x5f, 0x00, 0xad, 0x81,
-    0x96, 0x42, 0x1f, 0x12, 0x2f, 0x39, 0x86, 0x9d,
-    0x83, 0x4f, 0x81, 0x86, 0x41, 0x76, 0x80, 0xbc,
+    0x42, 0x3a, 0x85, 0x41, 0xd4, 0x82, 0xc5, 0x8a,
+    0xb0, 0x83, 0x40, 0xbf, 0x80, 0xa8, 0x80, 0xc7,
+    0x81, 0xf7, 0x81, 0xbd, 0x80, 0xcb, 0x80, 0x88,
+    0x82, 0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80,
+    0x8f, 0x80, 0x97, 0x32, 0x84, 0x40, 0xcc, 0x02,
+    0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80,
+    0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41,
+    0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2, 0x80,
+    0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80, 0x41,
+    0x01, 0x00, 0x81, 0xd0, 0x80, 0x56, 0xae, 0x8e,
+    0x60, 0x36, 0x99, 0x84, 0xba, 0x86, 0x44, 0x57,
+    0x90, 0xcf, 0x81, 0x60, 0x3f, 0xfd, 0x18, 0x30,
+    0x81, 0x5f, 0x00, 0xad, 0x81, 0x96, 0x42, 0x1f,
+    0x12, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x4e, 0x81,
+    0xbd, 0x40, 0xc1, 0x86, 0x41, 0x76, 0x80, 0xbc,
     0x83, 0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
 };
 
@@ -3914,16 +3953,16 @@ static const uint8_t unicode_prop_IDS_Trinary_Operator_table[4] = {
     0x60, 0x2f, 0xf1, 0x81,
 };
 
-static const uint8_t unicode_prop_Ideographic_table[66] = {
+static const uint8_t unicode_prop_Ideographic_table[69] = {
     0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82,
     0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xff,
     0x60, 0x58, 0xff, 0x41, 0x6d, 0x81, 0xe9, 0x60,
     0x75, 0x09, 0x80, 0x9a, 0x57, 0xf7, 0x87, 0x44,
     0xd5, 0xa9, 0x88, 0x60, 0x24, 0x66, 0x41, 0x8b,
     0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdf, 0x9f, 0x50,
-    0x38, 0x86, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
+    0x39, 0x85, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
     0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1,
-    0x53, 0x4a,
+    0x53, 0x4a, 0x84, 0x50, 0x5f,
 };
 
 static const uint8_t unicode_prop_Join_Control_table[4] = {
@@ -3979,7 +4018,7 @@ static const uint8_t unicode_prop_Regional_Indicator_table[4] = {
     0x61, 0xf1, 0xe5, 0x99,
 };
 
-static const uint8_t unicode_prop_Sentence_Terminal_table[194] = {
+static const uint8_t unicode_prop_Sentence_Terminal_table[196] = {
     0xa0, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0x45, 0x48,
     0x80, 0x40, 0x92, 0x82, 0x40, 0xb3, 0x80, 0xaa,
     0x82, 0x40, 0xf5, 0x80, 0xbc, 0x00, 0x02, 0x81,
@@ -4001,13 +4040,13 @@ static const uint8_t unicode_prop_Sentence_Terminal_table[194] = {
     0xeb, 0x80, 0x41, 0xa0, 0x81, 0x41, 0x74, 0x0c,
     0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42, 0x04,
     0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6, 0x81, 0x41,
-    0xa3, 0x81, 0x42, 0xb3, 0x81, 0x60, 0x4b, 0x74,
-    0x81, 0x40, 0x84, 0x80, 0xc0, 0x81, 0x8a, 0x80,
-    0x43, 0x52, 0x80, 0x60, 0x4e, 0x05, 0x80, 0x5d,
-    0xe7, 0x80,
+    0xa3, 0x81, 0x42, 0xb3, 0x81, 0xc9, 0x81, 0x60,
+    0x4b, 0x28, 0x81, 0x40, 0x84, 0x80, 0xc0, 0x81,
+    0x8a, 0x80, 0x43, 0x52, 0x80, 0x60, 0x4e, 0x05,
+    0x80, 0x5d, 0xe7, 0x80,
 };
 
-static const uint8_t unicode_prop_Soft_Dotted_table[74] = {
+static const uint8_t unicode_prop_Soft_Dotted_table[79] = {
     0xe8, 0x81, 0x40, 0xc3, 0x80, 0x41, 0x18, 0x80,
     0x9d, 0x80, 0xb3, 0x80, 0x93, 0x80, 0x41, 0x3f,
     0x80, 0xe1, 0x00, 0x80, 0x59, 0x08, 0x80, 0xb2,
@@ -4017,10 +4056,10 @@ static const uint8_t unicode_prop_Soft_Dotted_table[74] = {
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1,
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1,
     0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0x48,
-    0x85, 0x80,
+    0x85, 0x80, 0x41, 0x30, 0x81, 0x99, 0x80,
 };
 
-static const uint8_t unicode_prop_Terminal_Punctuation_table[246] = {
+static const uint8_t unicode_prop_Terminal_Punctuation_table[248] = {
     0xa0, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
     0x43, 0x3d, 0x07, 0x80, 0x42, 0x00, 0x80, 0xb8,
     0x80, 0xc7, 0x80, 0x8d, 0x00, 0x82, 0x40, 0xb3,
@@ -4048,19 +4087,19 @@ static const uint8_t unicode_prop_Terminal_Punctuation_table[246] = {
     0x82, 0x8b, 0x81, 0x41, 0x65, 0x1a, 0x8e, 0xe8,
     0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80,
     0x40, 0xfa, 0x81, 0xd6, 0x0b, 0x81, 0x41, 0x9d,
-    0x82, 0xac, 0x80, 0x42, 0x84, 0x81, 0x45, 0x76,
-    0x84, 0x60, 0x45, 0xf8, 0x81, 0x40, 0x84, 0x80,
-    0xc0, 0x82, 0x89, 0x80, 0x43, 0x51, 0x81, 0x60,
-    0x4e, 0x05, 0x80, 0x5d, 0xe6, 0x83,
+    0x82, 0xac, 0x80, 0x42, 0x84, 0x81, 0xc9, 0x81,
+    0x45, 0x2a, 0x84, 0x60, 0x45, 0xf8, 0x81, 0x40,
+    0x84, 0x80, 0xc0, 0x82, 0x89, 0x80, 0x43, 0x51,
+    0x81, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe6, 0x83,
 };
 
-static const uint8_t unicode_prop_Unified_Ideograph_table[42] = {
+static const uint8_t unicode_prop_Unified_Ideograph_table[45] = {
     0x60, 0x33, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x51,
     0xff, 0x60, 0x5a, 0x0d, 0x08, 0x00, 0x81, 0x89,
     0x00, 0x00, 0x09, 0x82, 0x61, 0x05, 0xd5, 0x60,
-    0xa6, 0xdf, 0x9f, 0x50, 0x38, 0x86, 0x40, 0xdd,
+    0xa6, 0xdf, 0x9f, 0x50, 0x39, 0x85, 0x40, 0xdd,
     0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x54, 0x1e,
-    0x53, 0x4a,
+    0x53, 0x4a, 0x84, 0x50, 0x5f,
 };
 
 static const uint8_t unicode_prop_Variation_Selector_table[13] = {
@@ -4125,11 +4164,11 @@ static const uint8_t unicode_prop_Emoji_table[239] = {
     0xbe, 0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01,
     0x19, 0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88,
     0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05,
-    0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x84,
-    0x88, 0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2,
+    0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x83,
+    0x89, 0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2,
     0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89, 0x80,
-    0x40, 0xb8, 0xef, 0x22, 0x22, 0x86, 0x88, 0x9c,
-    0x82, 0x8a, 0x25, 0x89, 0x89, 0x2f, 0x3e,
+    0x40, 0xb8, 0xef, 0x8c, 0x82, 0x88, 0x86, 0xad,
+    0x06, 0x87, 0x8d, 0x83, 0x88, 0x86, 0x88,
 };
 
 static const uint8_t unicode_prop_Emoji_Component_table[28] = {
@@ -4152,7 +4191,7 @@ static const uint8_t unicode_prop_Emoji_Modifier_Base_table[71] = {
     0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a, 0x80,
     0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88, 0x89,
     0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80, 0x90,
-    0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x86,
+    0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x88,
 };
 
 static const uint8_t unicode_prop_Emoji_Presentation_table[145] = {
@@ -4170,11 +4209,11 @@ static const uint8_t unicode_prop_Emoji_Presentation_table[145] = {
     0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80,
     0x40, 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91,
     0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
-    0xc5, 0x28, 0x12, 0x0a, 0x22, 0x8a, 0x0e, 0x88,
+    0xc5, 0x28, 0x12, 0x0a, 0x1b, 0x8a, 0x0e, 0x88,
     0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80,
-    0x89, 0x80, 0x40, 0xb8, 0xef, 0x22, 0x22, 0x86,
-    0x88, 0x9c, 0x82, 0x8a, 0x25, 0x89, 0x89, 0x2f,
-    0x3e,
+    0x89, 0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x88,
+    0x86, 0xad, 0x06, 0x87, 0x8d, 0x83, 0x88, 0x86,
+    0x88,
 };
 
 static const uint8_t unicode_prop_Extended_Pictographic_table[156] = {
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 4c2279452a..81c65b99d8 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -169,8 +169,8 @@ DEF(groups, "groups")
 DEF(status, "status")
 DEF(reason, "reason")
 DEF(globalThis, "globalThis")
-#ifdef CONFIG_BIGNUM
 DEF(bigint, "bigint")
+#ifdef CONFIG_BIGNUM
 DEF(bigfloat, "bigfloat")
 DEF(bigdecimal, "bigdecimal")
 DEF(roundingMode, "roundingMode")
@@ -209,15 +209,13 @@ DEF(Int16Array, "Int16Array")
 DEF(Uint16Array, "Uint16Array")
 DEF(Int32Array, "Int32Array")
 DEF(Uint32Array, "Uint32Array")
-#ifdef CONFIG_BIGNUM
 DEF(BigInt64Array, "BigInt64Array")
 DEF(BigUint64Array, "BigUint64Array")
-#endif
 DEF(Float32Array, "Float32Array")
 DEF(Float64Array, "Float64Array")
 DEF(DataView, "DataView")
-#ifdef CONFIG_BIGNUM
 DEF(BigInt, "BigInt")
+#ifdef CONFIG_BIGNUM
 DEF(BigFloat, "BigFloat")
 DEF(BigFloatEnv, "BigFloatEnv")
 DEF(BigDecimal, "BigDecimal")
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index c731a14a9c..15a9fce6a3 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -279,7 +279,7 @@ def(  scope_get_ref, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase
 def(scope_put_var_init, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
 def(scope_get_private_field, 7, 1, 1, atom_u16) /* obj -> value, emitted in phase 1, removed in phase 2 */
 def(scope_get_private_field2, 7, 1, 2, atom_u16) /* obj -> obj value, emitted in phase 1, removed in phase 2 */
-def(scope_put_private_field, 7, 1, 1, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
+def(scope_put_private_field, 7, 2, 0, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
 
 def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
     
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index 1984561a0e..f9fd091ac0 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -44,9 +44,7 @@
 #include "list.h"
 #include "quickjs.h"
 #include "libregexp.h"
-#ifdef CONFIG_BIGNUM
 #include "libbf.h"
-#endif
 
 #define OPTIMIZE         1
 #define SHORT_OPCODES    1
@@ -144,15 +142,13 @@ enum {
     JS_CLASS_UINT16_ARRAY,      /* u.array (typed_array) */
     JS_CLASS_INT32_ARRAY,       /* u.array (typed_array) */
     JS_CLASS_UINT32_ARRAY,      /* u.array (typed_array) */
-#ifdef CONFIG_BIGNUM
     JS_CLASS_BIG_INT64_ARRAY,   /* u.array (typed_array) */
     JS_CLASS_BIG_UINT64_ARRAY,  /* u.array (typed_array) */
-#endif
     JS_CLASS_FLOAT32_ARRAY,     /* u.array (typed_array) */
     JS_CLASS_FLOAT64_ARRAY,     /* u.array (typed_array) */
     JS_CLASS_DATAVIEW,          /* u.typed_array */
-#ifdef CONFIG_BIGNUM
     JS_CLASS_BIG_INT,           /* u.object_data */
+#ifdef CONFIG_BIGNUM
     JS_CLASS_BIG_FLOAT,         /* u.object_data */
     JS_CLASS_FLOAT_ENV,         /* u.float_env */
     JS_CLASS_BIG_DECIMAL,       /* u.object_data */
@@ -218,7 +214,6 @@ typedef enum {
 
 typedef enum OPCodeEnum OPCodeEnum;
 
-#ifdef CONFIG_BIGNUM
 /* function pointers are used for numeric operations so that it is
    possible to remove some numeric types */
 typedef struct {
@@ -236,7 +231,6 @@ typedef struct {
                                     int64_t exponent);
     int (*mul_pow10)(JSContext *ctx, JSValue *sp);
 } JSNumericOperations;
-#endif
 
 struct JSRuntime {
     JSMallocFunctions mf;
@@ -301,9 +295,9 @@ struct JSRuntime {
     int shape_hash_size;
     int shape_hash_count; /* number of hashed shapes */
     JSShape **shape_hash;
-#ifdef CONFIG_BIGNUM
     bf_context_t bf_ctx;
     JSNumericOperations bigint_ops;
+#ifdef CONFIG_BIGNUM
     JSNumericOperations bigfloat_ops;
     JSNumericOperations bigdecimal_ops;
     uint32_t operator_count;
@@ -383,13 +377,6 @@ typedef struct JSVarRef {
     JSValue value; /* used when the variable is no longer on the stack */
 } JSVarRef;
 
-#ifdef CONFIG_BIGNUM
-typedef struct JSFloatEnv {
-    limb_t prec;
-    bf_flags_t flags;
-    unsigned int status;
-} JSFloatEnv;
-
 /* the same structure is used for big integers and big floats. Big
    integers are never infinite or NaNs */
 typedef struct JSBigFloat {
@@ -397,6 +384,13 @@ typedef struct JSBigFloat {
     bf_t num;
 } JSBigFloat;
 
+#ifdef CONFIG_BIGNUM
+typedef struct JSFloatEnv {
+    limb_t prec;
+    bf_flags_t flags;
+    unsigned int status;
+} JSFloatEnv;
+
 typedef struct JSBigDecimal {
     JSRefCountHeader header; /* must come first, 32-bit */
     bfdec_t num;
@@ -440,8 +434,8 @@ struct JSContext {
     JSValue global_var_obj; /* contains the global let/const definitions */
 
     uint64_t random_state;
-#ifdef CONFIG_BIGNUM
     bf_context_t *bf_ctx;   /* points to rt->bf_ctx, shared by all contexts */
+#ifdef CONFIG_BIGNUM
     JSFloatEnv fp_env; /* global FP environment */
     BOOL bignum_ext : 8; /* enable math mode */
     BOOL allow_operator_overloading : 8;
@@ -561,6 +555,7 @@ typedef struct JSVarDef {
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
     uint8_t is_captured : 1;
+    uint8_t is_static_private : 1; /* only used during private class field parsing */
     uint8_t var_kind : 4; /* see JSVarKindEnum */
     /* only used during compilation: function pool index for lexical
        variables with var_kind =
@@ -1120,6 +1115,18 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val);
 static JSValue JS_ToObjectFree(JSContext *ctx, JSValue val);
 static JSProperty *add_property(JSContext *ctx,
                                 JSObject *p, JSAtom prop, int prop_flags);
+static JSValue JS_NewBigInt(JSContext *ctx);
+static inline bf_t *JS_GetBigInt(JSValueConst val)
+{
+    JSBigFloat *p = JS_VALUE_GET_PTR(val);
+    return &p->num;
+}
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+                                 BOOL convert_to_safe_integer);
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val);
+static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
+static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
+static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
 #ifdef CONFIG_BIGNUM
 static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
 static JSValue JS_NewBigFloat(JSContext *ctx);
@@ -1134,18 +1141,6 @@ static inline bfdec_t *JS_GetBigDecimal(JSValueConst val)
     JSBigDecimal *p = JS_VALUE_GET_PTR(val);
     return &p->num;
 }
-static JSValue JS_NewBigInt(JSContext *ctx);
-static inline bf_t *JS_GetBigInt(JSValueConst val)
-{
-    JSBigFloat *p = JS_VALUE_GET_PTR(val);
-    return &p->num;
-}
-static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
-                                 BOOL convert_to_safe_integer);
-static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val);
-static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
-static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
-static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
 static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val);
 static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
                                    BOOL allow_null_or_undefined);
@@ -1314,14 +1309,12 @@ void *js_mallocz_rt(JSRuntime *rt, size_t size)
     return memset(ptr, 0, size);
 }
 
-#ifdef CONFIG_BIGNUM
 /* called by libbf */
 static void *js_bf_realloc(void *opaque, void *ptr, size_t size)
 {
     JSRuntime *rt = opaque;
     return js_realloc_rt(rt, ptr, size);
 }
-#endif /* CONFIG_BIGNUM */
 
 /* Throw out of memory in case of error */
 void *js_malloc(JSContext *ctx, size_t size)
@@ -1472,15 +1465,13 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Uint16Array, js_typed_array_finalizer, js_typed_array_mark },     /* JS_CLASS_UINT16_ARRAY */
     { JS_ATOM_Int32Array, js_typed_array_finalizer, js_typed_array_mark },      /* JS_CLASS_INT32_ARRAY */
     { JS_ATOM_Uint32Array, js_typed_array_finalizer, js_typed_array_mark },     /* JS_CLASS_UINT32_ARRAY */
-#ifdef CONFIG_BIGNUM
     { JS_ATOM_BigInt64Array, js_typed_array_finalizer, js_typed_array_mark },   /* JS_CLASS_BIG_INT64_ARRAY */
     { JS_ATOM_BigUint64Array, js_typed_array_finalizer, js_typed_array_mark },  /* JS_CLASS_BIG_UINT64_ARRAY */
-#endif
     { JS_ATOM_Float32Array, js_typed_array_finalizer, js_typed_array_mark },    /* JS_CLASS_FLOAT32_ARRAY */
     { JS_ATOM_Float64Array, js_typed_array_finalizer, js_typed_array_mark },    /* JS_CLASS_FLOAT64_ARRAY */
     { JS_ATOM_DataView, js_typed_array_finalizer, js_typed_array_mark },        /* JS_CLASS_DATAVIEW */
-#ifdef CONFIG_BIGNUM
     { JS_ATOM_BigInt, js_object_data_finalizer, js_object_data_mark },      /* JS_CLASS_BIG_INT */
+#ifdef CONFIG_BIGNUM
     { JS_ATOM_BigFloat, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_FLOAT */
     { JS_ATOM_BigFloatEnv, js_float_env_finalizer, NULL },      /* JS_CLASS_FLOAT_ENV */
     { JS_ATOM_BigDecimal, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_DECIMAL */
@@ -1515,7 +1506,6 @@ static int init_class_range(JSRuntime *rt, JSClassShortDef const *tab,
     return 0;
 }
 
-#ifdef CONFIG_BIGNUM
 static JSValue JS_ThrowUnsupportedOperation(JSContext *ctx)
 {
     return JS_ThrowTypeError(ctx, "unsupported operation");
@@ -1571,8 +1561,6 @@ static void set_dummy_numeric_ops(JSNumericOperations *ops)
     ops->mul_pow10 = invalid_mul_pow10;
 }
 
-#endif /* CONFIG_BIGNUM */
-
 #if !defined(CONFIG_STACK_CHECK)
 /* no stack limitation */
 static inline uintptr_t js_get_stack_pointer(void)
@@ -1620,9 +1608,9 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->malloc_state = ms;
     rt->malloc_gc_threshold = 256 * 1024;
 
-#ifdef CONFIG_BIGNUM
     bf_context_init(&rt->bf_ctx, js_bf_realloc, rt);
     set_dummy_numeric_ops(&rt->bigint_ops);
+#ifdef CONFIG_BIGNUM
     set_dummy_numeric_ops(&rt->bigfloat_ops);
     set_dummy_numeric_ops(&rt->bigdecimal_ops);
 #endif
@@ -1994,9 +1982,7 @@ void JS_FreeRuntime(JSRuntime *rt)
     }
     js_free_rt(rt, rt->class_array);
 
-#ifdef CONFIG_BIGNUM
     bf_context_end(&rt->bf_ctx);
-#endif
 
 #ifdef DUMP_LEAKS
     /* only the atoms defined in JS_InitAtoms() should be left */
@@ -2134,8 +2120,8 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
     }
     ctx->rt = rt;
     list_add_tail(&ctx->link, &rt->context_list);
-#ifdef CONFIG_BIGNUM
     ctx->bf_ctx = &rt->bf_ctx;
+#ifdef CONFIG_BIGNUM
     ctx->fp_env.prec = 113;
     ctx->fp_env.flags = bf_set_exp_bits(15) | BF_RNDN | BF_FLAG_SUBNORMAL;
 #endif
@@ -2168,9 +2154,7 @@ JSContext *JS_NewContext(JSRuntime *rt)
     JS_AddIntrinsicMapSet(ctx);
     JS_AddIntrinsicTypedArrays(ctx);
     JS_AddIntrinsicPromise(ctx);
-#ifdef CONFIG_BIGNUM
     JS_AddIntrinsicBigInt(ctx);
-#endif
     return ctx;
 }
 
@@ -2378,6 +2362,11 @@ static inline BOOL is_math_mode(JSContext *ctx)
     JSStackFrame *sf = ctx->rt->current_stack_frame;
     return (sf && (sf->js_mode & JS_MODE_MATH));
 }
+#else
+static inline BOOL is_math_mode(JSContext *ctx)
+{
+    return FALSE;
+}
 #endif
 
 /* JSAtom support */
@@ -4785,10 +4774,8 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     case JS_CLASS_UINT16_ARRAY:
     case JS_CLASS_INT32_ARRAY:
     case JS_CLASS_UINT32_ARRAY:
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
     case JS_CLASS_BIG_UINT64_ARRAY:
-#endif
     case JS_CLASS_FLOAT32_ARRAY:
     case JS_CLASS_FLOAT64_ARRAY:
         p->is_exotic = 1;
@@ -4805,8 +4792,8 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     case JS_CLASS_BOOLEAN:
     case JS_CLASS_SYMBOL:
     case JS_CLASS_DATE:
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_FLOAT:
     case JS_CLASS_BIG_DECIMAL:
 #endif
@@ -4868,8 +4855,8 @@ static JSValue JS_GetObjectData(JSContext *ctx, JSValueConst obj)
         case JS_CLASS_BOOLEAN:
         case JS_CLASS_SYMBOL:
         case JS_CLASS_DATE:
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:
+#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_FLOAT:
         case JS_CLASS_BIG_DECIMAL:
 #endif
@@ -4892,8 +4879,8 @@ static int JS_SetObjectData(JSContext *ctx, JSValueConst obj, JSValue val)
         case JS_CLASS_BOOLEAN:
         case JS_CLASS_SYMBOL:
         case JS_CLASS_DATE:
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:
+#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_FLOAT:
         case JS_CLASS_BIG_DECIMAL:
 #endif
@@ -5520,15 +5507,17 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v)
     case JS_TAG_MODULE:
         abort(); /* never freed here */
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif        
         {
             JSBigFloat *bf = JS_VALUE_GET_PTR(v);
             bf_delete(&bf->num);
             js_free_rt(rt, bf);
         }
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_DECIMAL:
         {
             JSBigDecimal *bf = JS_VALUE_GET_PTR(v);
@@ -5891,13 +5880,13 @@ static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp)
     case JS_TAG_STRING:
         compute_jsstring_size(JS_VALUE_GET_STRING(val), hp);
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
     case JS_TAG_BIG_DECIMAL:
+#endif
         /* should track JSBigFloat usage */
         break;
-#endif
     }
 }
 
@@ -6021,8 +6010,8 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         case JS_CLASS_BOOLEAN:           /* u.object_data */
         case JS_CLASS_SYMBOL:            /* u.object_data */
         case JS_CLASS_DATE:              /* u.object_data */
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT:           /* u.object_data */
+#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_FLOAT:         /* u.object_data */
         case JS_CLASS_BIG_DECIMAL:         /* u.object_data */
 #endif
@@ -6114,10 +6103,8 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         case JS_CLASS_UINT16_ARRAY:      /* u.typed_array / u.array */
         case JS_CLASS_INT32_ARRAY:       /* u.typed_array / u.array */
         case JS_CLASS_UINT32_ARRAY:      /* u.typed_array / u.array */
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT64_ARRAY:   /* u.typed_array / u.array */
         case JS_CLASS_BIG_UINT64_ARRAY:  /* u.typed_array / u.array */
-#endif
         case JS_CLASS_FLOAT32_ARRAY:     /* u.typed_array / u.array */
         case JS_CLASS_FLOAT64_ARRAY:     /* u.typed_array / u.array */
         case JS_CLASS_DATAVIEW:          /* u.typed_array */
@@ -6878,10 +6865,10 @@ int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val)
 static JSValueConst JS_GetPrototypePrimitive(JSContext *ctx, JSValueConst val)
 {
     switch(JS_VALUE_GET_NORM_TAG(val)) {
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         val = ctx->class_proto[JS_CLASS_BIG_INT];
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         val = ctx->class_proto[JS_CLASS_BIG_FLOAT];
         break;
@@ -7881,12 +7868,10 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
             return JS_NewInt32(ctx, p->u.array.u.int32_ptr[idx]);
         case JS_CLASS_UINT32_ARRAY:
             return JS_NewUint32(ctx, p->u.array.u.uint32_ptr[idx]);
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT64_ARRAY:
             return JS_NewBigInt64(ctx, p->u.array.u.int64_ptr[idx]);
         case JS_CLASS_BIG_UINT64_ARRAY:
             return JS_NewBigUint64(ctx, p->u.array.u.uint64_ptr[idx]);
-#endif
         case JS_CLASS_FLOAT32_ARRAY:
             return __JS_NewFloat64(ctx, p->u.array.u.float_ptr[idx]);
         case JS_CLASS_FLOAT64_ARRAY:
@@ -8314,119 +8299,14 @@ static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc)
     JS_FreeValue(ctx, desc->value);
 }
 
-/* generic (and slower) version of JS_SetProperty() for
- * Reflect.set(). 'obj' must be an object.  */
-static int JS_SetPropertyGeneric(JSContext *ctx,
-                                 JSValueConst obj, JSAtom prop,
-                                 JSValue val, JSValueConst this_obj,
-                                 int flags)
-{
-    int ret;
-    JSPropertyDescriptor desc;
-    JSValue obj1;
-    JSObject *p;
-    
-    obj1 = JS_DupValue(ctx, obj);
-    for(;;) {
-        p = JS_VALUE_GET_OBJ(obj1);
-        if (p->is_exotic) {
-            const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
-            if (em && em->set_property) {
-                ret = em->set_property(ctx, obj1, prop,
-                                       val, this_obj, flags);
-                JS_FreeValue(ctx, obj1);
-                JS_FreeValue(ctx, val);
-                return ret;
-            }
-        }
-
-        ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
-        if (ret < 0) {
-            JS_FreeValue(ctx, obj1);
-            JS_FreeValue(ctx, val);
-            return ret;
-        }
-        if (ret) {
-            if (desc.flags & JS_PROP_GETSET) {
-                JSObject *setter;
-                if (JS_IsUndefined(desc.setter))
-                    setter = NULL;
-                else
-                    setter = JS_VALUE_GET_OBJ(desc.setter);
-                ret = call_setter(ctx, setter, this_obj, val, flags);
-                JS_FreeValue(ctx, desc.getter);
-                JS_FreeValue(ctx, desc.setter);
-                JS_FreeValue(ctx, obj1);
-                return ret;
-            } else {
-                JS_FreeValue(ctx, desc.value);
-                if (!(desc.flags & JS_PROP_WRITABLE)) {
-                    JS_FreeValue(ctx, obj1);
-                    goto read_only_error;
-                }
-            }
-            break;
-        }
-        /* Note: at this point 'obj1' cannot be a proxy. XXX: may have
-           to check recursion */
-        obj1 = JS_GetPrototypeFree(ctx, obj1);
-        if (JS_IsNull(obj1))
-            break;
-    }
-    JS_FreeValue(ctx, obj1);
-
-    if (!JS_IsObject(this_obj)) {
-        JS_FreeValue(ctx, val);
-        return JS_ThrowTypeErrorOrFalse(ctx, flags, "receiver is not an object");
-    }
-    
-    p = JS_VALUE_GET_OBJ(this_obj);
-
-    /* modify the property in this_obj if it already exists */
-    ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
-    if (ret < 0) {
-        JS_FreeValue(ctx, val);
-        return ret;
-    }
-    if (ret) {
-        if (desc.flags & JS_PROP_GETSET) {
-            JS_FreeValue(ctx, desc.getter);
-            JS_FreeValue(ctx, desc.setter);
-            JS_FreeValue(ctx, val);
-            return JS_ThrowTypeErrorOrFalse(ctx, flags, "setter is forbidden");
-        } else {
-            JS_FreeValue(ctx, desc.value);
-            if (!(desc.flags & JS_PROP_WRITABLE) ||
-                p->class_id == JS_CLASS_MODULE_NS) {
-            read_only_error:
-                JS_FreeValue(ctx, val);
-                return JS_ThrowTypeErrorReadOnly(ctx, flags, prop);
-            }
-        }
-        ret = JS_DefineProperty(ctx, this_obj, prop, val,
-                                JS_UNDEFINED, JS_UNDEFINED,
-                                JS_PROP_HAS_VALUE);
-        JS_FreeValue(ctx, val);
-        return ret;
-    }
-
-    ret = JS_CreateProperty(ctx, p, prop, val, JS_UNDEFINED, JS_UNDEFINED,
-                            flags |
-                            JS_PROP_HAS_VALUE |
-                            JS_PROP_HAS_ENUMERABLE |
-                            JS_PROP_HAS_WRITABLE |
-                            JS_PROP_HAS_CONFIGURABLE |
-                            JS_PROP_C_W_E);
-    JS_FreeValue(ctx, val);
-    return ret;
-}
-
 /* return -1 in case of exception or TRUE or FALSE. Warning: 'val' is
    freed by the function. 'flags' is a bitmask of JS_PROP_NO_ADD,
    JS_PROP_THROW or JS_PROP_THROW_STRICT. If JS_PROP_NO_ADD is set,
-   the new property is not added and an error is raised. */
-int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
-                           JSAtom prop, JSValue val, int flags)
+   the new property is not added and an error is raised. 'this_obj' is
+   the receiver. If obj != this_obj, then obj must be an object
+   (Reflect.set case). */
+int JS_SetPropertyInternal(JSContext *ctx, JSValueConst obj,
+                           JSAtom prop, JSValue val, JSValueConst this_obj, int flags)
 {
     JSObject *p, *p1;
     JSShapeProperty *prs;
@@ -8439,25 +8319,37 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
 #endif
     tag = JS_VALUE_GET_TAG(this_obj);
     if (unlikely(tag != JS_TAG_OBJECT)) {
-        switch(tag) {
-        case JS_TAG_NULL:
-            JS_FreeValue(ctx, val);
-            JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of null", prop);
-            return -1;
-        case JS_TAG_UNDEFINED:
-            JS_FreeValue(ctx, val);
-            JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of undefined", prop);
-            return -1;
-        default:
-            /* even on a primitive type we can have setters on the prototype */
+        if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
             p = NULL;
-            p1 = JS_VALUE_GET_OBJ(JS_GetPrototypePrimitive(ctx, this_obj));
+            p1 = JS_VALUE_GET_OBJ(obj);
             goto prototype_lookup;
+        } else {
+            switch(tag) {
+            case JS_TAG_NULL:
+                JS_FreeValue(ctx, val);
+                JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of null", prop);
+                return -1;
+            case JS_TAG_UNDEFINED:
+                JS_FreeValue(ctx, val);
+                JS_ThrowTypeErrorAtom(ctx, "cannot set property '%s' of undefined", prop);
+                return -1;
+            default:
+                /* even on a primitive type we can have setters on the prototype */
+                p = NULL;
+                p1 = JS_VALUE_GET_OBJ(JS_GetPrototypePrimitive(ctx, obj));
+                goto prototype_lookup;
+            }
         }
+    } else {
+        p = JS_VALUE_GET_OBJ(this_obj);
+        p1 = JS_VALUE_GET_OBJ(obj);
+        if (unlikely(p != p1))
+            goto retry2;
     }
-    p = JS_VALUE_GET_OBJ(this_obj);
-retry:
-    prs = find_own_property(&pr, p, prop);
+
+    /* fast path if obj == this_obj */
+ retry:
+    prs = find_own_property(&pr, p1, prop);
     if (prs) {
         if (likely((prs->flags & (JS_PROP_TMASK | JS_PROP_WRITABLE |
                                   JS_PROP_LENGTH)) == JS_PROP_WRITABLE)) {
@@ -8489,8 +8381,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
             goto read_only_prop;
         }
     }
-
-    p1 = p;
+    
     for(;;) {
         if (p1->is_exotic) {
             if (p1->fast_array) {
@@ -8514,11 +8405,19 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                             return -1;
                         }
                     typed_array_oob:
-                        val = JS_ToNumberFree(ctx, val);
-                        JS_FreeValue(ctx, val);
-                        if (JS_IsException(val))
-                            return -1;
-                        return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound numeric index");
+                        /* must convert the argument even if out of bound access */
+                        if (p1->class_id == JS_CLASS_BIG_INT64_ARRAY ||
+                            p1->class_id == JS_CLASS_BIG_UINT64_ARRAY) {
+                            int64_t v;
+                            if (JS_ToBigInt64Free(ctx, &v, val))
+                                return -1;
+                        } else {
+                            val = JS_ToNumberFree(ctx, val);
+                            JS_FreeValue(ctx, val);
+                            if (JS_IsException(val))
+                                return -1;
+                        }
+                        return TRUE;
                     }
                 }
             } else {
@@ -8590,9 +8489,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
                     return -1;
                 goto retry2;
             } else if (!(prs->flags & JS_PROP_WRITABLE)) {
-            read_only_prop:
-                JS_FreeValue(ctx, val);
-                return JS_ThrowTypeErrorReadOnly(ctx, flags, prop);
+                goto read_only_prop;
             }
         }
     }
@@ -8613,16 +8510,56 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
         return JS_ThrowTypeErrorOrFalse(ctx, flags, "object is not extensible");
     }
 
-    if (p->is_exotic) {
-        if (p->class_id == JS_CLASS_ARRAY && p->fast_array &&
-            __JS_AtomIsTaggedInt(prop)) {
-            uint32_t idx = __JS_AtomToUInt32(prop);
-            if (idx == p->u.array.count) {
-                /* fast case */
-                return add_fast_array_element(ctx, p, val, flags);
+    if (likely(p == JS_VALUE_GET_OBJ(obj))) {
+        if (p->is_exotic) {
+            if (p->class_id == JS_CLASS_ARRAY && p->fast_array &&
+                __JS_AtomIsTaggedInt(prop)) {
+                uint32_t idx = __JS_AtomToUInt32(prop);
+                if (idx == p->u.array.count) {
+                    /* fast case */
+                    return add_fast_array_element(ctx, p, val, flags);
+                } else {
+                    goto generic_create_prop;
+                }
             } else {
                 goto generic_create_prop;
             }
+        } else {
+            pr = add_property(ctx, p, prop, JS_PROP_C_W_E);
+            if (unlikely(!pr)) {
+                JS_FreeValue(ctx, val);
+                return -1;
+            }
+            pr->u.value = val;
+            return TRUE;
+        }
+    } else {
+        /* generic case: modify the property in this_obj if it already exists */
+        ret = JS_GetOwnPropertyInternal(ctx, &desc, p, prop);
+        if (ret < 0) {
+            JS_FreeValue(ctx, val);
+            return ret;
+        }
+        if (ret) {
+            if (desc.flags & JS_PROP_GETSET) {
+                JS_FreeValue(ctx, desc.getter);
+                JS_FreeValue(ctx, desc.setter);
+                JS_FreeValue(ctx, val);
+                return JS_ThrowTypeErrorOrFalse(ctx, flags, "setter is forbidden");
+            } else {
+                JS_FreeValue(ctx, desc.value);
+                if (!(desc.flags & JS_PROP_WRITABLE) ||
+                    p->class_id == JS_CLASS_MODULE_NS) {
+                read_only_prop:
+                    JS_FreeValue(ctx, val);
+                    return JS_ThrowTypeErrorReadOnly(ctx, flags, prop);
+                }
+            }
+            ret = JS_DefineProperty(ctx, this_obj, prop, val,
+                                    JS_UNDEFINED, JS_UNDEFINED,
+                                    JS_PROP_HAS_VALUE);
+            JS_FreeValue(ctx, val);
+            return ret;
         } else {
         generic_create_prop:
             ret = JS_CreateProperty(ctx, p, prop, val, JS_UNDEFINED, JS_UNDEFINED,
@@ -8636,14 +8573,6 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
             return ret;
         }
     }
-
-    pr = add_property(ctx, p, prop, JS_PROP_C_W_E);
-    if (unlikely(!pr)) {
-        JS_FreeValue(ctx, val);
-        return -1;
-    }
-    pr->u.value = val;
-    return TRUE;
 }
 
 /* flags can be JS_PROP_THROW or JS_PROP_THROW_STRICT */
@@ -8728,7 +8657,6 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
                 goto ta_out_of_bound;
             p->u.array.u.uint32_ptr[idx] = v;
             break;
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT64_ARRAY:
         case JS_CLASS_BIG_UINT64_ARRAY:
             /* XXX: need specific conversion function */
@@ -8741,7 +8669,6 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
                 p->u.array.u.uint64_ptr[idx] = v;
             }
             break;
-#endif
         case JS_CLASS_FLOAT32_ARRAY:
             if (JS_ToFloat64Free(ctx, &d, val))
                 return -1;
@@ -8754,7 +8681,7 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
                 return -1;
             if (unlikely(idx >= (uint32_t)p->u.array.count)) {
             ta_out_of_bound:
-                return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound numeric index");
+                return TRUE;
             }
             p->u.array.u.double_ptr[idx] = d;
             break;
@@ -8772,7 +8699,7 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
             JS_FreeValue(ctx, val);
             return -1;
         }
-        ret = JS_SetPropertyInternal(ctx, this_obj, atom, val, flags);
+        ret = JS_SetPropertyInternal(ctx, this_obj, atom, val, this_obj, flags);
         JS_FreeAtom(ctx, atom);
         return ret;
     }
@@ -8812,7 +8739,7 @@ int JS_SetPropertyStr(JSContext *ctx, JSValueConst this_obj,
     JSAtom atom;
     int ret;
     atom = JS_NewAtom(ctx, prop);
-    ret = JS_SetPropertyInternal(ctx, this_obj, atom, val, JS_PROP_THROW);
+    ret = JS_SetPropertyInternal(ctx, this_obj, atom, val, this_obj, JS_PROP_THROW);
     JS_FreeAtom(ctx, atom);
     return ret;
 }
@@ -9269,7 +9196,7 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
             }
             idx = __JS_AtomToUInt32(prop);
             /* if the typed array is detached, p->u.array.count = 0 */
-            if (idx >= typed_array_get_length(ctx, p)) {
+            if (idx >= p->u.array.count) {
             typed_array_oob:
                 return JS_ThrowTypeErrorOrFalse(ctx, flags, "out-of-bound index in typed array");
             }
@@ -9663,7 +9590,7 @@ static int JS_SetGlobalVar(JSContext *ctx, JSAtom prop, JSValue val,
     flags = JS_PROP_THROW_STRICT;
     if (is_strict_mode(ctx)) 
         flags |= JS_PROP_NO_ADD;
-    return JS_SetPropertyInternal(ctx, ctx->global_obj, prop, val, flags);
+    return JS_SetPropertyInternal(ctx, ctx->global_obj, prop, val, ctx->global_obj, flags);
 }
 
 /* return -1, FALSE or TRUE. return FALSE if not configurable or
@@ -9940,9 +9867,10 @@ static int JS_ToBoolFree(JSContext *ctx, JSValue val)
             JS_FreeValue(ctx, val);
             return ret;
         }
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif        
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             BOOL ret;
@@ -9950,6 +9878,7 @@ static int JS_ToBoolFree(JSContext *ctx, JSValue val)
             JS_FreeValue(ctx, val);
             return ret;
         }
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_DECIMAL:
         {
             JSBigDecimal *p = JS_VALUE_GET_PTR(val);
@@ -10080,15 +10009,16 @@ static double js_strtod(const char *p, int radix, BOOL is_float)
 #define ATOD_TYPE_MASK        (3 << 7)
 #define ATOD_TYPE_FLOAT64     (0 << 7)
 #define ATOD_TYPE_BIG_INT     (1 << 7)
+#ifdef CONFIG_BIGNUM
 #define ATOD_TYPE_BIG_FLOAT   (2 << 7)
 #define ATOD_TYPE_BIG_DECIMAL (3 << 7)
 /* assume bigint mode: floats are parsed as integers if no decimal
    point nor exponent */
 #define ATOD_MODE_BIGINT      (1 << 9) 
+#endif
 /* accept -0x1 */
 #define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
-#ifdef CONFIG_BIGNUM
 static JSValue js_string_to_bigint(JSContext *ctx, const char *buf,
                                    int radix, int flags, slimb_t *pexponent)
 {
@@ -10104,10 +10034,15 @@ static JSValue js_string_to_bigint(JSContext *ctx, const char *buf,
         JS_FreeValue(ctx, val);
         return JS_ThrowOutOfMemory(ctx);
     }
+#ifdef CONFIG_BIGNUM
     val = JS_CompactBigInt1(ctx, val, (flags & ATOD_MODE_BIGINT) != 0);
+#else
+    val = JS_CompactBigInt1(ctx, val, FALSE);
+#endif
     return val;
 }
 
+#ifdef CONFIG_BIGNUM
 static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
                                      int radix, int flags, slimb_t *pexponent)
 {
@@ -10153,7 +10088,6 @@ static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
     }
     return val;
 }
-
 #endif
 
 /* return an exception in case of memory error. Return JS_NAN if
@@ -10228,8 +10162,11 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
     } else {
  no_radix_prefix:
         if (!(flags & ATOD_INT_ONLY) &&
-            (atod_type == ATOD_TYPE_FLOAT64 ||
-             atod_type == ATOD_TYPE_BIG_FLOAT) &&
+            (atod_type == ATOD_TYPE_FLOAT64
+#ifdef CONFIG_BIGNUM
+             || atod_type == ATOD_TYPE_BIG_FLOAT
+#endif             
+             ) &&
             strstart(p, "Infinity", &p)) {
 #ifdef CONFIG_BIGNUM
             if (atod_type == ATOD_TYPE_BIG_FLOAT) {
@@ -10309,36 +10246,40 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
     }
     buf[j] = '\0';
 
-#ifdef CONFIG_BIGNUM
     if (flags & ATOD_ACCEPT_SUFFIX) {
         if (*p == 'n') {
             p++;
             atod_type = ATOD_TYPE_BIG_INT;
-        } else if (*p == 'l') {
+        } else
+#ifdef CONFIG_BIGNUM
+        if (*p == 'l') {
             p++;
             atod_type = ATOD_TYPE_BIG_FLOAT;
         } else if (*p == 'm') {
             p++;
             atod_type = ATOD_TYPE_BIG_DECIMAL;
-        } else {
-            if (flags & ATOD_MODE_BIGINT) {
-                if (!is_float)
-                    atod_type = ATOD_TYPE_BIG_INT;
-                if (has_legacy_octal)
-                    goto fail;
-            } else {
-                if (is_float && radix != 10)
-                    goto fail;
-            }
+        } else if (flags & ATOD_MODE_BIGINT) {
+            if (!is_float)
+                atod_type = ATOD_TYPE_BIG_INT;
+            if (has_legacy_octal)
+                goto fail;
+        } else
+#endif
+        {
+            if (is_float && radix != 10)
+                goto fail;
         }
     } else {
         if (atod_type == ATOD_TYPE_FLOAT64) {
+#ifdef CONFIG_BIGNUM
             if (flags & ATOD_MODE_BIGINT) {
                 if (!is_float)
                     atod_type = ATOD_TYPE_BIG_INT;
                 if (has_legacy_octal)
                     goto fail;
-            } else {
+            } else
+#endif                
+            {
                 if (is_float && radix != 10)
                     goto fail;
             }
@@ -10359,6 +10300,7 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
             goto fail;
         val = ctx->rt->bigint_ops.from_string(ctx, buf, radix, flags, NULL);
         break;
+#ifdef CONFIG_BIGNUM
     case ATOD_TYPE_BIG_FLOAT:
         if (has_legacy_octal)
             goto fail;
@@ -10370,19 +10312,10 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
             goto fail;
         val = ctx->rt->bigdecimal_ops.from_string(ctx, buf, radix, flags, NULL);
         break;
+#endif        
     default:
         abort();
     }
-#else
-    {
-        double d;
-        (void)has_legacy_octal;
-        if (is_float && radix != 10)
-            goto fail;
-        d = js_strtod(buf, radix, is_float);
-        val = JS_NewFloat64(ctx, d);
-    }
-#endif
     
 done:
     if (buf_allocated)
@@ -10420,18 +10353,18 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
  redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_DECIMAL:
+    case JS_TAG_BIG_INT:
         if (flag != TON_FLAG_NUMERIC) {
             JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert bigdecimal to number");
+            return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
         }
         ret = val;
         break;
-    case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
+    case JS_TAG_BIG_DECIMAL:
         if (flag != TON_FLAG_NUMERIC) {
             JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
+            return JS_ThrowTypeError(ctx, "cannot convert bigdecimal to number");
         }
         ret = val;
         break;
@@ -10533,9 +10466,10 @@ static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
     case JS_TAG_FLOAT64:
         d = JS_VALUE_GET_FLOAT64(val);
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             /* XXX: there can be a double rounding issue with some
@@ -10545,7 +10479,6 @@ static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
             JS_FreeValue(ctx, val);
         }
         break;
-#endif
     default:
         abort();
     }
@@ -10613,6 +10546,10 @@ static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
             BOOL is_nan;
 
             a = JS_ToBigFloat(ctx, &a_s, val);
+            if (!a) {
+                JS_FreeValue(ctx, val);
+                return JS_EXCEPTION;
+            }
             if (!bf_is_finite(a)) {
                 is_nan = bf_is_nan(a);
                 if (is_nan)
@@ -11013,9 +10950,10 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
             len = v;
         }
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif        
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             bf_t a;
@@ -11030,7 +10968,6 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
                 goto fail;
         }
         break;
-#endif
     default:
         if (JS_TAG_IS_FLOAT64(tag)) {
             double d;
@@ -11134,13 +11071,13 @@ static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
             u.d = JS_VALUE_GET_FLOAT64(val);
             return (u.u64 >> 63);
         }
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
             /* Note: integer zeros are not necessarily positive */
             return p->num.sign && !bf_is_zero(&p->num);
         }
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
@@ -11159,8 +11096,6 @@ static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
     }
 }
 
-#ifdef CONFIG_BIGNUM
-
 static JSValue js_bigint_to_string1(JSContext *ctx, JSValueConst val, int radix)
 {
     JSValue ret;
@@ -11190,6 +11125,8 @@ static JSValue js_bigint_to_string(JSContext *ctx, JSValueConst val)
     return js_bigint_to_string1(ctx, val, 10);
 }
 
+#ifdef CONFIG_BIGNUM
+
 static JSValue js_ftoa(JSContext *ctx, JSValueConst val1, int radix,
                        limb_t prec, bf_flags_t flags)
 {
@@ -11202,6 +11139,10 @@ static JSValue js_ftoa(JSContext *ctx, JSValueConst val1, int radix,
     if (JS_IsException(val))
         return val;
     a = JS_ToBigFloat(ctx, &a_s, val);
+    if (!a) {
+        JS_FreeValue(ctx, val);
+        return JS_EXCEPTION;
+    }
     saved_sign = a->sign;
     if (a->expn == BF_EXP_ZERO)
         a->sign = 0;
@@ -11258,6 +11199,8 @@ static JSValue js_bigdecimal_to_string1(JSContext *ctx, JSValueConst val,
     int saved_sign;
 
     a = JS_ToBigDecimal(ctx, val);
+    if (!a)
+        return JS_EXCEPTION;
     saved_sign = a->sign;
     if (a->expn == BF_EXP_ZERO)
         a->sign = 0;
@@ -11590,9 +11533,9 @@ JSValue JS_ToStringInternal(JSContext *ctx, JSValueConst val, BOOL is_ToProperty
     case JS_TAG_FLOAT64:
         return js_dtoa(ctx, JS_VALUE_GET_FLOAT64(val), 10, 0,
                        JS_DTOA_VAR_FORMAT);
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         return ctx->rt->bigint_ops.to_string(ctx, val);
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         return ctx->rt->bigfloat_ops.to_string(ctx, val);
     case JS_TAG_BIG_DECIMAL:
@@ -11753,10 +11696,8 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
             case JS_CLASS_UINT16_ARRAY:
             case JS_CLASS_INT32_ARRAY:
             case JS_CLASS_UINT32_ARRAY:
-#ifdef CONFIG_BIGNUM
             case JS_CLASS_BIG_INT64_ARRAY:
             case JS_CLASS_BIG_UINT64_ARRAY:
-#endif
             case JS_CLASS_FLOAT32_ARRAY:
             case JS_CLASS_FLOAT64_ARRAY:
                 {
@@ -11883,7 +11824,6 @@ static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
     case JS_TAG_FLOAT64:
         printf("%.14g", JS_VALUE_GET_FLOAT64(val));
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
@@ -11894,6 +11834,7 @@ static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
             bf_realloc(&rt->bf_ctx, str, 0);
         }
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         {
             JSBigFloat *p = JS_VALUE_GET_PTR(val);
@@ -11995,8 +11936,6 @@ static double js_pow(double a, double b)
     }
 }
 
-#ifdef CONFIG_BIGNUM
-
 JSValue JS_NewBigInt64_1(JSContext *ctx, int64_t v)
 {
     JSValue val;
@@ -12041,6 +11980,252 @@ JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
     return val;
 }
 
+/* return NaN if bad bigint literal */
+static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
+{
+    const char *str, *p;
+    size_t len;
+    int flags;
+    
+    str = JS_ToCStringLen(ctx, &len, val);
+    JS_FreeValue(ctx, val);
+    if (!str)
+        return JS_EXCEPTION;
+    p = str;
+    p += skip_spaces(p);
+    if ((p - str) == len) {
+        val = JS_NewBigInt64(ctx, 0);
+    } else {
+        flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
+#ifdef CONFIG_BIGNUM
+        if (is_math_mode(ctx))
+            flags |= ATOD_MODE_BIGINT;
+#endif        
+        val = js_atof(ctx, p, &p, 0, flags);
+        p += skip_spaces(p);
+        if (!JS_IsException(val)) {
+            if ((p - str) != len) {
+                JS_FreeValue(ctx, val);
+                val = JS_NAN;
+            }
+        }
+    }
+    JS_FreeCString(ctx, str);
+    return val;
+}
+
+static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
+{
+    val = JS_StringToBigInt(ctx, val);
+    if (JS_VALUE_IS_NAN(val))
+        return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
+    return val;
+}
+
+/* if the returned bigfloat is allocated it is equal to
+   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. */
+static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
+{
+    uint32_t tag;
+    bf_t *r;
+    JSBigFloat *p;
+
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+        if (!is_math_mode(ctx))
+            goto fail;
+        /* fall tru */
+    case JS_TAG_BOOL:
+        r = buf;
+        bf_init(ctx->bf_ctx, r);
+        bf_set_si(r, JS_VALUE_GET_INT(val));
+        break;
+    case JS_TAG_FLOAT64:
+        {
+            double d = JS_VALUE_GET_FLOAT64(val);
+            if (!is_math_mode(ctx))
+                goto fail;
+            if (!isfinite(d))
+                goto fail;
+            r = buf;
+            bf_init(ctx->bf_ctx, r);
+            d = trunc(d);
+            bf_set_float64(r, d);
+        }
+        break;
+    case JS_TAG_BIG_INT:
+        p = JS_VALUE_GET_PTR(val);
+        r = &p->num;
+        break;
+#ifdef CONFIG_BIGNUM
+    case JS_TAG_BIG_FLOAT:
+        if (!is_math_mode(ctx))
+            goto fail;
+        p = JS_VALUE_GET_PTR(val);
+        if (!bf_is_finite(&p->num))
+            goto fail;
+        r = buf;
+        bf_init(ctx->bf_ctx, r);
+        bf_set(r, &p->num);
+        bf_rint(r, BF_RNDZ);
+        JS_FreeValue(ctx, val);
+        break;
+#endif        
+    case JS_TAG_STRING:
+        val = JS_StringToBigIntErr(ctx, val);
+        if (JS_IsException(val))
+            return NULL;
+        goto redo;
+    case JS_TAG_OBJECT:
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+        if (JS_IsException(val))
+            return NULL;
+        goto redo;
+    default:
+    fail:
+        JS_FreeValue(ctx, val);
+        JS_ThrowTypeError(ctx, "cannot convert to bigint");
+        return NULL;
+    }
+    return r;
+}
+
+static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
+{
+    return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
+}
+
+static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
+        return val;
+    } else {
+        bf_t a_s, *a, *r;
+        int ret;
+        JSValue res; 
+
+        res = JS_NewBigInt(ctx);
+        if (JS_IsException(res))
+            return JS_EXCEPTION;
+        a = JS_ToBigIntFree(ctx, &a_s, val);
+        if (!a) {
+            JS_FreeValue(ctx, res);
+            return JS_EXCEPTION;
+        }
+        r = JS_GetBigInt(res);
+        ret = bf_set(r, a);
+        JS_FreeBigInt(ctx, a, &a_s);
+        if (ret) {
+            JS_FreeValue(ctx, res);
+            return JS_ThrowOutOfMemory(ctx);
+        }
+        return JS_CompactBigInt(ctx, res);
+    }
+}
+
+/* free the bf_t allocated by JS_ToBigInt */
+static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf)
+{
+    if (a == buf) {
+        bf_delete(a);
+    } else {
+        JSBigFloat *p = (JSBigFloat *)((uint8_t *)a -
+                                       offsetof(JSBigFloat, num));
+        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_BIG_INT, p));
+    }
+}
+
+/* XXX: merge with JS_ToInt64Free with a specific flag */
+static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
+{
+    bf_t a_s, *a;
+
+    a = JS_ToBigIntFree(ctx, &a_s, val);
+    if (!a) {
+        *pres = 0;
+        return -1;
+    }
+    bf_get_int64(pres, a, BF_GET_INT_MOD);
+    JS_FreeBigInt(ctx, a, &a_s);
+    return 0;
+}
+
+int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
+{
+    return JS_ToBigInt64Free(ctx, pres, JS_DupValue(ctx, val));
+}
+
+static JSBigFloat *js_new_bf(JSContext *ctx)
+{
+    JSBigFloat *p;
+    p = js_malloc(ctx, sizeof(*p));
+    if (!p)
+        return NULL;
+    p->header.ref_count = 1;
+    bf_init(ctx->bf_ctx, &p->num);
+    return p;
+}
+
+static JSValue JS_NewBigInt(JSContext *ctx)
+{
+    JSBigFloat *p;
+    p = js_malloc(ctx, sizeof(*p));
+    if (!p)
+        return JS_EXCEPTION;
+    p->header.ref_count = 1;
+    bf_init(ctx->bf_ctx, &p->num);
+    return JS_MKPTR(JS_TAG_BIG_INT, p);
+}
+
+static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
+                                 BOOL convert_to_safe_integer)
+{
+    int64_t v;
+    bf_t *a;
+    
+    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
+        return val; /* fail safe */
+    a = JS_GetBigInt(val);
+    if (convert_to_safe_integer && bf_get_int64(&v, a, 0) == 0 &&
+        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
+        JS_FreeValue(ctx, val);
+        return JS_NewInt64(ctx, v);
+    } else if (a->expn == BF_EXP_ZERO && a->sign) {
+        JSBigFloat *p = JS_VALUE_GET_PTR(val);
+        assert(p->header.ref_count == 1);
+        a->sign = 0;
+    }
+    return val;
+}
+
+/* Convert the big int to a safe integer if in math mode. normalize
+   the zero representation. Could also be used to convert the bigint
+   to a short bigint value. The reference count of the value must be
+   1. Cannot fail */
+static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
+{
+    return JS_CompactBigInt1(ctx, val, is_math_mode(ctx));
+}
+
+static JSValue throw_bf_exception(JSContext *ctx, int status)
+{
+    const char *str;
+    if (status & BF_ST_MEM_ERROR)
+        return JS_ThrowOutOfMemory(ctx);
+    if (status & BF_ST_DIVIDE_ZERO) {
+        str = "division by zero";
+    } else if (status & BF_ST_INVALID_OP) {
+        str = "invalid operation";
+    } else {
+        str = "integer overflow";
+    }
+    return JS_ThrowRangeError(ctx, "%s", str);
+}
+
 /* if the returned bigfloat is allocated it is equal to
    'buf'. Otherwise it is a pointer to the bigfloat in 'val'. Return
    NULL in case of error. */
@@ -12070,7 +12255,9 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val)
         }
         break;
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif
         p = JS_VALUE_GET_PTR(val);
         r = &p->num;
         break;
@@ -12084,6 +12271,7 @@ static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val)
     return r;
 }
 
+#ifdef CONFIG_BIGNUM
 /* return NULL if invalid type */
 static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val)
 {
@@ -12105,192 +12293,6 @@ static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val)
     return r;
 }
 
-/* return NaN if bad bigint literal */
-static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
-{
-    const char *str, *p;
-    size_t len;
-    int flags;
-    
-    str = JS_ToCStringLen(ctx, &len, val);
-    JS_FreeValue(ctx, val);
-    if (!str)
-        return JS_EXCEPTION;
-    p = str;
-    p += skip_spaces(p);
-    if ((p - str) == len) {
-        val = JS_NewBigInt64(ctx, 0);
-    } else {
-        flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
-        if (is_math_mode(ctx))
-            flags |= ATOD_MODE_BIGINT;
-        val = js_atof(ctx, p, &p, 0, flags);
-        p += skip_spaces(p);
-        if (!JS_IsException(val)) {
-            if ((p - str) != len) {
-                JS_FreeValue(ctx, val);
-                val = JS_NAN;
-            }
-        }
-    }
-    JS_FreeCString(ctx, str);
-    return val;
-}
-
-static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
-{
-    val = JS_StringToBigInt(ctx, val);
-    if (JS_VALUE_IS_NAN(val))
-        return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
-    return val;
-}
-
-/* if the returned bigfloat is allocated it is equal to
-   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. */
-static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
-{
-    uint32_t tag;
-    bf_t *r;
-    JSBigFloat *p;
-
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        if (!is_math_mode(ctx))
-            goto fail;
-        /* fall tru */
-    case JS_TAG_BOOL:
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        bf_set_si(r, JS_VALUE_GET_INT(val));
-        break;
-    case JS_TAG_FLOAT64:
-        {
-            double d = JS_VALUE_GET_FLOAT64(val);
-            if (!is_math_mode(ctx))
-                goto fail;
-            if (!isfinite(d))
-                goto fail;
-            r = buf;
-            bf_init(ctx->bf_ctx, r);
-            d = trunc(d);
-            bf_set_float64(r, d);
-        }
-        break;
-    case JS_TAG_BIG_INT:
-        p = JS_VALUE_GET_PTR(val);
-        r = &p->num;
-        break;
-    case JS_TAG_BIG_FLOAT:
-        if (!is_math_mode(ctx))
-            goto fail;
-        p = JS_VALUE_GET_PTR(val);
-        if (!bf_is_finite(&p->num))
-            goto fail;
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        bf_set(r, &p->num);
-        bf_rint(r, BF_RNDZ);
-        JS_FreeValue(ctx, val);
-        break;
-    case JS_TAG_STRING:
-        val = JS_StringToBigIntErr(ctx, val);
-        if (JS_IsException(val))
-            return NULL;
-        goto redo;
-    case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
-        if (JS_IsException(val))
-            return NULL;
-        goto redo;
-    default:
-    fail:
-        JS_FreeValue(ctx, val);
-        JS_ThrowTypeError(ctx, "cannot convert to bigint");
-        return NULL;
-    }
-    return r;
-}
-
-static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
-{
-    return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
-}
-
-static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
-{
-    if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
-        return val;
-    } else {
-        bf_t a_s, *a, *r;
-        int ret;
-        JSValue res; 
-
-        res = JS_NewBigInt(ctx);
-        if (JS_IsException(res))
-            return JS_EXCEPTION;
-        a = JS_ToBigIntFree(ctx, &a_s, val);
-        if (!a) {
-            JS_FreeValue(ctx, res);
-            return JS_EXCEPTION;
-        }
-        r = JS_GetBigInt(res);
-        ret = bf_set(r, a);
-        JS_FreeBigInt(ctx, a, &a_s);
-        if (ret) {
-            JS_FreeValue(ctx, res);
-            return JS_ThrowOutOfMemory(ctx);
-        }
-        return JS_CompactBigInt(ctx, res);
-    }
-}
-
-/* free the bf_t allocated by JS_ToBigInt */
-static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf)
-{
-    if (a == buf) {
-        bf_delete(a);
-    } else {
-        JSBigFloat *p = (JSBigFloat *)((uint8_t *)a -
-                                       offsetof(JSBigFloat, num));
-        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_BIG_FLOAT, p));
-    }
-}
-
-/* XXX: merge with JS_ToInt64Free with a specific flag */
-static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
-{
-    bf_t a_s, *a;
-
-    a = JS_ToBigIntFree(ctx, &a_s, val);
-    if (!a) {
-        *pres = 0;
-        return -1;
-    }
-    bf_get_int64(pres, a, BF_GET_INT_MOD);
-    JS_FreeBigInt(ctx, a, &a_s);
-    return 0;
-}
-
-int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
-{
-    return JS_ToBigInt64Free(ctx, pres, JS_DupValue(ctx, val));
-}
-
-static JSBigFloat *js_new_bf(JSContext *ctx)
-{
-    JSBigFloat *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return NULL;
-    p->header.ref_count = 1;
-    bf_init(ctx->bf_ctx, &p->num);
-    return p;
-}
-
 static JSValue JS_NewBigFloat(JSContext *ctx)
 {
     JSBigFloat *p;
@@ -12313,47 +12315,6 @@ static JSValue JS_NewBigDecimal(JSContext *ctx)
     return JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
 }
 
-static JSValue JS_NewBigInt(JSContext *ctx)
-{
-    JSBigFloat *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return JS_EXCEPTION;
-    p->header.ref_count = 1;
-    bf_init(ctx->bf_ctx, &p->num);
-    return JS_MKPTR(JS_TAG_BIG_INT, p);
-}
-
-static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
-                                 BOOL convert_to_safe_integer)
-{
-    int64_t v;
-    bf_t *a;
-    
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
-        return val; /* fail safe */
-    a = JS_GetBigInt(val);
-    if (convert_to_safe_integer && bf_get_int64(&v, a, 0) == 0 &&
-        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
-        JS_FreeValue(ctx, val);
-        return JS_NewInt64(ctx, v);
-    } else if (a->expn == BF_EXP_ZERO && a->sign) {
-        JSBigFloat *p = JS_VALUE_GET_PTR(val);
-        assert(p->header.ref_count == 1);
-        a->sign = 0;
-    }
-    return val;
-}
-
-/* Convert the big int to a safe integer if in math mode. normalize
-   the zero representation. Could also be used to convert the bigint
-   to a short bigint value. The reference count of the value must be
-   1. Cannot fail */
-static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
-{
-    return JS_CompactBigInt1(ctx, val, is_math_mode(ctx));
-}
-
 /* must be kept in sync with JSOverloadableOperatorEnum */
 /* XXX: use atoms ? */
 static const char js_overloadable_operator_names[JS_OVOP_COUNT][4] = {
@@ -12677,46 +12638,37 @@ static __exception int js_call_unary_op_fallback(JSContext *ctx,
     return -1;
 }
 
-static JSValue throw_bf_exception(JSContext *ctx, int status)
-{
-    const char *str;
-    if (status & BF_ST_MEM_ERROR)
-        return JS_ThrowOutOfMemory(ctx);
-    if (status & BF_ST_DIVIDE_ZERO) {
-        str = "division by zero";
-    } else if (status & BF_ST_INVALID_OP) {
-        str = "invalid operation";
-    } else {
-        str = "integer overflow";
-    }
-    return JS_ThrowRangeError(ctx, "%s", str);
-}
-
-static int js_unary_arith_bigint(JSContext *ctx,
-                                 JSValue *pres, OPCodeEnum op, JSValue op1)
+static int js_unary_arith_bigfloat(JSContext *ctx,
+                                   JSValue *pres, OPCodeEnum op, JSValue op1)
 {
     bf_t a_s, *r, *a;
     int ret, v;
     JSValue res;
     
     if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigint argument with unary +");
+        JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
-    res = JS_NewBigInt(ctx);
+
+    res = JS_NewBigFloat(ctx);
     if (JS_IsException(res)) {
         JS_FreeValue(ctx, op1);
         return -1;
     }
-    r = JS_GetBigInt(res);
-    a = JS_ToBigInt(ctx, &a_s, op1);
+    r = JS_GetBigFloat(res);
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    if (!a) {
+        JS_FreeValue(ctx, res);
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
     ret = 0;
     switch(op) {
     case OP_inc:
     case OP_dec:
         v = 2 * (op - OP_dec) - 1;
-        ret = bf_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+        ret = bf_add_si(r, a, v, ctx->fp_env.prec, ctx->fp_env.flags);
         break;
     case OP_plus:
         ret = bf_set(r, a);
@@ -12725,66 +12677,65 @@ static int js_unary_arith_bigint(JSContext *ctx,
         ret = bf_set(r, a);
         bf_neg(r);
         break;
-    case OP_not:
-        ret = bf_add_si(r, a, 1, BF_PREC_INF, BF_RNDZ);
-        bf_neg(r);
-        break;
     default:
         abort();
     }
-    JS_FreeBigInt(ctx, a, &a_s);
+    if (a == &a_s)
+        bf_delete(a);
     JS_FreeValue(ctx, op1);
-    if (unlikely(ret)) {
+    if (unlikely(ret & BF_ST_MEM_ERROR)) {
         JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
-    res = JS_CompactBigInt(ctx, res);
     *pres = res;
     return 0;
 }
 
-static int js_unary_arith_bigfloat(JSContext *ctx,
-                                   JSValue *pres, OPCodeEnum op, JSValue op1)
+static int js_unary_arith_bigdecimal(JSContext *ctx,
+                                     JSValue *pres, OPCodeEnum op, JSValue op1)
 {
-    bf_t a_s, *r, *a;
+    bfdec_t *r, *a;
     int ret, v;
     JSValue res;
     
     if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
+        JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
 
-    res = JS_NewBigFloat(ctx);
+    res = JS_NewBigDecimal(ctx);
     if (JS_IsException(res)) {
         JS_FreeValue(ctx, op1);
         return -1;
     }
-    r = JS_GetBigFloat(res);
-    a = JS_ToBigFloat(ctx, &a_s, op1);
+    r = JS_GetBigDecimal(res);
+    a = JS_ToBigDecimal(ctx, op1);
+    if (!a) {
+        JS_FreeValue(ctx, res);
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
     ret = 0;
     switch(op) {
     case OP_inc:
     case OP_dec:
         v = 2 * (op - OP_dec) - 1;
-        ret = bf_add_si(r, a, v, ctx->fp_env.prec, ctx->fp_env.flags);
+        ret = bfdec_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
         break;
     case OP_plus:
-        ret = bf_set(r, a);
+        ret = bfdec_set(r, a);
         break;
     case OP_neg:
-        ret = bf_set(r, a);
-        bf_neg(r);
+        ret = bfdec_set(r, a);
+        bfdec_neg(r);
         break;
     default:
         abort();
     }
-    if (a == &a_s)
-        bf_delete(a);
     JS_FreeValue(ctx, op1);
-    if (unlikely(ret & BF_ST_MEM_ERROR)) {
+    if (unlikely(ret)) {
         JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
@@ -12793,49 +12744,61 @@ static int js_unary_arith_bigfloat(JSContext *ctx,
     return 0;
 }
 
-static int js_unary_arith_bigdecimal(JSContext *ctx,
-                                     JSValue *pres, OPCodeEnum op, JSValue op1)
+#endif /* CONFIG_BIGNUM */
+
+static int js_unary_arith_bigint(JSContext *ctx,
+                                 JSValue *pres, OPCodeEnum op, JSValue op1)
 {
-    bfdec_t *r, *a;
+    bf_t a_s, *r, *a;
     int ret, v;
     JSValue res;
     
     if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
+        JS_ThrowTypeError(ctx, "bigint argument with unary +");
         JS_FreeValue(ctx, op1);
         return -1;
     }
-
-    res = JS_NewBigDecimal(ctx);
+    res = JS_NewBigInt(ctx);
     if (JS_IsException(res)) {
         JS_FreeValue(ctx, op1);
         return -1;
     }
-    r = JS_GetBigDecimal(res);
-    a = JS_ToBigDecimal(ctx, op1);
+    r = JS_GetBigInt(res);
+    a = JS_ToBigInt(ctx, &a_s, op1);
+    if (!a) {
+        JS_FreeValue(ctx, res);
+        JS_FreeValue(ctx, op1);
+        return -1;
+    }
     ret = 0;
     switch(op) {
     case OP_inc:
     case OP_dec:
         v = 2 * (op - OP_dec) - 1;
-        ret = bfdec_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+        ret = bf_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
         break;
     case OP_plus:
-        ret = bfdec_set(r, a);
+        ret = bf_set(r, a);
         break;
     case OP_neg:
-        ret = bfdec_set(r, a);
-        bfdec_neg(r);
+        ret = bf_set(r, a);
+        bf_neg(r);
+        break;
+    case OP_not:
+        ret = bf_add_si(r, a, 1, BF_PREC_INF, BF_RNDZ);
+        bf_neg(r);
         break;
     default:
         abort();
     }
+    JS_FreeBigInt(ctx, a, &a_s);
     JS_FreeValue(ctx, op1);
     if (unlikely(ret)) {
         JS_FreeValue(ctx, res);
         throw_bf_exception(ctx, ret);
         return -1;
     }
+    res = JS_CompactBigInt(ctx, res);
     *pres = res;
     return 0;
 }
@@ -12844,16 +12807,18 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
                                                      JSValue *sp,
                                                      OPCodeEnum op)
 {
-    JSValue op1, val;
-    int v, ret;
+    JSValue op1;
+    int v;
     uint32_t tag;
 
     op1 = sp[-1];
     /* fast path for float64 */
     if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(op1)))
         goto handle_float64;
+#ifdef CONFIG_BIGNUM
     if (JS_IsObject(op1)) {
-        ret = js_call_unary_op_fallback(ctx, &val, op1, op);
+        JSValue val;
+        int ret = js_call_unary_op_fallback(ctx, &val, op1, op);
         if (ret < 0)
             return -1;
         if (ret) {
@@ -12862,7 +12827,7 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
             return 0;
         }
     }
-
+#endif
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1))
         goto exception;
@@ -12899,6 +12864,7 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
         if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
             goto exception;
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
             goto exception;
@@ -12907,6 +12873,7 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
         if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
             goto exception;
         break;
+#endif        
     default:
     handle_float64:
         {
@@ -12957,12 +12924,13 @@ static __exception int js_post_inc_slow(JSContext *ctx,
 
 static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 {
-    JSValue op1, val;
-    int ret;
+    JSValue op1;
     
     op1 = sp[-1];
+#ifdef CONFIG_BIGNUM
     if (JS_IsObject(op1)) {
-        ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
+        JSValue val;
+        int ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
         if (ret < 0)
             return -1;
         if (ret) {
@@ -12971,7 +12939,7 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
             return 0;
         }
     }
-
+#endif
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1))
         goto exception;
@@ -12990,67 +12958,6 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
-static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
-                                    JSValue *pres, JSValue op1, JSValue op2)
-{
-    bf_t a_s, b_s, *r, *a, *b;
-    int ret;
-    JSValue res;
-    
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res)) {
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        return -1;
-    }
-    r = JS_GetBigFloat(res);
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    b = JS_ToBigFloat(ctx, &b_s, op2);
-    bf_init(ctx->bf_ctx, r);
-    switch(op) {
-    case OP_add:
-        ret = bf_add(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_sub:
-        ret = bf_sub(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_mul:
-        ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_div:
-        ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_math_mod:
-        /* Euclidian remainder */
-        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                     BF_DIVREM_EUCLIDIAN);
-        break;
-    case OP_mod:
-        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                     BF_RNDZ);
-        break;
-    case OP_pow:
-        ret = bf_pow(r, a, b, ctx->fp_env.prec,
-                     ctx->fp_env.flags | BF_POW_JS_QUIRKS);
-        break;
-    default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    if (b == &b_s)
-        bf_delete(b);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    if (unlikely(ret & BF_ST_MEM_ERROR)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
-    }
-    *pres = res;
-    return 0;
-}
-
 static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
                                   JSValue *pres, JSValue op1, JSValue op2)
 {
@@ -13092,11 +12999,13 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
             goto math_mode_div_pow;
         }
         break;
+#ifdef CONFIG_BIGNUM
     case OP_math_mod:
         /* Euclidian remainder */
         ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
                      BF_DIVREM_EUCLIDIAN) & BF_ST_INVALID_OP;
         break;
+#endif        
     case OP_mod:
         ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
                      BF_RNDZ) & BF_ST_INVALID_OP;
@@ -13107,6 +13016,7 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
                 ret = BF_ST_INVALID_OP;
             } else {
             math_mode_div_pow:
+#ifdef CONFIG_BIGNUM
                 JS_FreeValue(ctx, res);
                 ret = js_call_binary_op_simple(ctx, &res, ctx->class_proto[JS_CLASS_BIG_INT], op1, op2, op);
                 if (ret != 0) {
@@ -13147,6 +13057,9 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
                 }
                 *pres = res;
                 return 0;
+#else
+                abort();
+#endif
             }
         } else {
             ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUIRKS);
@@ -13206,6 +13119,79 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
     return -1;
 }
 
+#ifdef CONFIG_BIGNUM
+static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
+                                    JSValue *pres, JSValue op1, JSValue op2)
+{
+    bf_t a_s, b_s, *r, *a, *b;
+    int ret;
+    JSValue res;
+    
+    res = JS_NewBigFloat(ctx);
+    if (JS_IsException(res))
+        goto fail;
+    r = JS_GetBigFloat(res);
+    a = JS_ToBigFloat(ctx, &a_s, op1);
+    if (!a) {
+        JS_FreeValue(ctx, res);
+        goto fail;
+    }
+    b = JS_ToBigFloat(ctx, &b_s, op2);
+    if (!b) {
+        if (a == &a_s)
+            bf_delete(a);
+        JS_FreeValue(ctx, res);
+        goto fail;
+    }
+    bf_init(ctx->bf_ctx, r);
+    switch(op) {
+    case OP_add:
+        ret = bf_add(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_sub:
+        ret = bf_sub(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_mul:
+        ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_div:
+        ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
+        break;
+    case OP_math_mod:
+        /* Euclidian remainder */
+        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+                     BF_DIVREM_EUCLIDIAN);
+        break;
+    case OP_mod:
+        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
+                     BF_RNDZ);
+        break;
+    case OP_pow:
+        ret = bf_pow(r, a, b, ctx->fp_env.prec,
+                     ctx->fp_env.flags | BF_POW_JS_QUIRKS);
+        break;
+    default:
+        abort();
+    }
+    if (a == &a_s)
+        bf_delete(a);
+    if (b == &b_s)
+        bf_delete(b);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    if (unlikely(ret & BF_ST_MEM_ERROR)) {
+        JS_FreeValue(ctx, res);
+        throw_bf_exception(ctx, ret);
+        return -1;
+    }
+    *pres = res;
+    return 0;
+ fail:
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return -1;
+}
+
 /* b must be a positive integer */
 static int js_bfdec_pow(bfdec_t *r, const bfdec_t *a, const bfdec_t *b)
 {
@@ -13292,13 +13278,13 @@ static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
     JS_FreeValue(ctx, op2);
     return -1;
 }
+#endif /* CONFIG_BIGNUM */
 
 static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *sp,
                                                       OPCodeEnum op)
 {
-    JSValue op1, op2, res;
+    JSValue op1, op2;
     uint32_t tag1, tag2;
-    int ret;
     double d1, d2;
 
     op1 = sp[-2];
@@ -13312,12 +13298,14 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         goto handle_float64;
     }
 
+#ifdef CONFIG_BIGNUM
     /* try to call an overloaded operator */
     if ((tag1 == JS_TAG_OBJECT &&
          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
         (tag2 == JS_TAG_OBJECT &&
          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
-        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
+        JSValue res;
+        int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -13329,6 +13317,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             }
         }
     }
+#endif
 
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1)) {
@@ -13367,6 +13356,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                 goto handle_bigint;
             sp[-2] = __JS_NewFloat64(ctx, (double)v1 / (double)v2);
             return 0;
+#ifdef CONFIG_BIGNUM
         case OP_math_mod:
             if (unlikely(v2 == 0)) {
                 throw_bf_exception(ctx, BF_ST_DIVIDE_ZERO);
@@ -13380,6 +13370,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
                     v += v2;
             }
             break;
+#endif            
         case OP_mod:
             if (v1 < 0 || v2 <= 0) {
                 sp[-2] = JS_NewFloat64(ctx, fmod(v1, v2));
@@ -13400,13 +13391,17 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             abort();
         }
         sp[-2] = JS_NewInt64(ctx, v);
-    } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+    } else
+#ifdef CONFIG_BIGNUM
+    if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
         if (ctx->rt->bigdecimal_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
     } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
         if (ctx->rt->bigfloat_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
-    } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+    } else
+#endif        
+    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
     handle_bigint:
         if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
             goto exception;
@@ -13435,6 +13430,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         case OP_mod:
             dr = fmod(d1, d2);
             break;
+#ifdef CONFIG_BIGNUM
         case OP_math_mod:
             d2 = fabs(d2);
             dr = fmod(d1, d2);
@@ -13442,6 +13438,7 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             if (dr < 0)
                 dr += d2;
             break;
+#endif            
         case OP_pow:
             dr = js_pow(d1, d2);
             break;
@@ -13459,9 +13456,8 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
 
 static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
 {
-    JSValue op1, op2, res;
+    JSValue op1, op2;
     uint32_t tag1, tag2;
-    int ret;
 
     op1 = sp[-2];
     op2 = sp[-1];
@@ -13478,6 +13474,7 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
     }
 
     if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
+#ifdef CONFIG_BIGNUM
         /* try to call an overloaded operator */
         if ((tag1 == JS_TAG_OBJECT &&
              (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED &&
@@ -13485,8 +13482,9 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
             (tag2 == JS_TAG_OBJECT &&
              (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED &&
               tag1 != JS_TAG_STRING))) {
-            ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add,
-                                             FALSE, HINT_NONE);
+            JSValue res;
+            int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add,
+                                                 FALSE, HINT_NONE);
             if (ret != 0) {
                 JS_FreeValue(ctx, op1);
                 JS_FreeValue(ctx, op2);
@@ -13498,7 +13496,7 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
                 }
             }
         }
-
+#endif
         op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
         if (JS_IsException(op1)) {
             JS_FreeValue(ctx, op2);
@@ -13541,13 +13539,17 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         v2 = JS_VALUE_GET_INT(op2);
         v = (int64_t)v1 + (int64_t)v2;
         sp[-2] = JS_NewInt64(ctx, v);
-    } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+    } else
+#ifdef CONFIG_BIGNUM
+    if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
         if (ctx->rt->bigdecimal_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
             goto exception;
     } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
         if (ctx->rt->bigfloat_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
             goto exception;
-    } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+    } else
+#endif        
+    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
     handle_bigint:
         if (ctx->rt->bigint_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
             goto exception;
@@ -13575,8 +13577,7 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
                                                       JSValue *sp,
                                                       OPCodeEnum op)
 {
-    JSValue op1, op2, res;
-    int ret;
+    JSValue op1, op2;
     uint32_t tag1, tag2;
     uint32_t v1, v2, r;
 
@@ -13585,12 +13586,14 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
+#ifdef CONFIG_BIGNUM
     /* try to call an overloaded operator */
     if ((tag1 == JS_TAG_OBJECT &&
          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
         (tag2 == JS_TAG_OBJECT &&
          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
-        ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
+        JSValue res;
+        int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
         if (ret != 0) {
             JS_FreeValue(ctx, op1);
             JS_FreeValue(ctx, op2);
@@ -13602,6 +13605,7 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
             }
         }
     }
+#endif
 
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1)) {
@@ -13712,6 +13716,7 @@ static int js_compare_bigfloat(JSContext *ctx, OPCodeEnum op,
     return res;
 }
 
+#ifdef CONFIG_BIGNUM
 static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
                                  JSValue op1, JSValue op2)
 {
@@ -13731,8 +13736,8 @@ static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
         JS_FreeValue(ctx, op1);
         return -1;
     }
-    a = JS_ToBigDecimal(ctx, op1);
-    b = JS_ToBigDecimal(ctx, op2);
+    a = JS_ToBigDecimal(ctx, op1); /* cannot fail */
+    b = JS_ToBigDecimal(ctx, op2); /* cannot fail */
     
     switch(op) {
     case OP_lt:
@@ -13757,11 +13762,12 @@ static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
     JS_FreeValue(ctx, op2);
     return res;
 }
+#endif /* !CONFIG_BIGNUM */
 
 static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
                                         OPCodeEnum op)
 {
-    JSValue op1, op2, ret;
+    JSValue op1, op2;
     int res;
     uint32_t tag1, tag2;
 
@@ -13769,11 +13775,13 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     op2 = sp[-1];
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
+#ifdef CONFIG_BIGNUM
     /* try to call an overloaded operator */
     if ((tag1 == JS_TAG_OBJECT &&
          (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
         (tag2 == JS_TAG_OBJECT &&
          (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
+        JSValue ret;
         res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op,
                                          FALSE, HINT_NUMBER);
         if (res != 0) {
@@ -13787,6 +13795,7 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
             }
         }
     }
+#endif    
     op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NUMBER);
     if (JS_IsException(op1)) {
         JS_FreeValue(ctx, op2);
@@ -13861,6 +13870,7 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
         tag1 = JS_VALUE_GET_NORM_TAG(op1);
         tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
+#ifdef CONFIG_BIGNUM
         if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
             res = ctx->rt->bigdecimal_ops.compare(ctx, op, op1, op2);
             if (res < 0)
@@ -13869,7 +13879,9 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
             res = ctx->rt->bigfloat_ops.compare(ctx, op, op1, op2);
             if (res < 0)
                 goto exception;
-        } else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
+        } else
+#endif            
+        if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
             res = ctx->rt->bigint_ops.compare(ctx, op, op1, op2);
             if (res < 0)
                 goto exception;
@@ -13917,14 +13929,20 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
 static BOOL tag_is_number(uint32_t tag)
 {
     return (tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
-            tag == JS_TAG_FLOAT64 || tag == JS_TAG_BIG_FLOAT ||
-            tag == JS_TAG_BIG_DECIMAL);
+            tag == JS_TAG_FLOAT64
+#ifdef CONFIG_BIGNUM
+            || tag == JS_TAG_BIG_FLOAT || tag == JS_TAG_BIG_DECIMAL
+#endif
+            );
 }
 
 static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                                             BOOL is_neq)
 {
-    JSValue op1, op2, ret;
+    JSValue op1, op2;
+#ifdef CONFIG_BIGNUM
+    JSValue ret;
+#endif
     int res;
     uint32_t tag1, tag2;
 
@@ -13952,7 +13970,9 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 d2 = JS_VALUE_GET_INT(op2);
             }
             res = (d1 == d2);
-        } else if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
+        } else
+#ifdef CONFIG_BIGNUM
+        if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
             res = ctx->rt->bigdecimal_ops.compare(ctx, OP_eq, op1, op2);
             if (res < 0)
                 goto exception;
@@ -13960,12 +13980,15 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
             res = ctx->rt->bigfloat_ops.compare(ctx, OP_eq, op1, op2);
             if (res < 0)
                 goto exception;
-        } else {
+        } else
+#endif            
+        {
             res = ctx->rt->bigint_ops.compare(ctx, OP_eq, op1, op2);
             if (res < 0)
                 goto exception;
         }
     } else if (tag1 == tag2) {
+#ifdef CONFIG_BIGNUM
         if (tag1 == JS_TAG_OBJECT) {
             /* try the fallback operator */
             res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
@@ -13982,6 +14005,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 }
             }
         }
+#endif        
         res = js_strict_eq2(ctx, op1, op2, JS_EQ_STRICT);
     } else if ((tag1 == JS_TAG_NULL && tag2 == JS_TAG_UNDEFINED) ||
                (tag2 == JS_TAG_NULL && tag1 == JS_TAG_UNDEFINED)) {
@@ -14029,7 +14053,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 (tag_is_number(tag2) || tag2 == JS_TAG_STRING || tag2 == JS_TAG_SYMBOL)) ||
                (tag2 == JS_TAG_OBJECT &&
                 (tag_is_number(tag1) || tag1 == JS_TAG_STRING || tag1 == JS_TAG_SYMBOL))) {
-
+#ifdef CONFIG_BIGNUM
         /* try the fallback operator */
         res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
                                          is_neq ? OP_neq : OP_eq,
@@ -14044,7 +14068,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 return 0;
             }
         }
-
+#endif
         op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
         if (JS_IsException(op1)) {
             JS_FreeValue(ctx, op2);
@@ -14116,6 +14140,7 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
+#ifdef CONFIG_BIGNUM
 static JSValue js_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
                                        int64_t exponent)
 {
@@ -14150,8 +14175,10 @@ static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
     op1 = sp[-2];
     op2 = sp[-1];
     a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a)
+    if (!a) {
+        JS_FreeValue(ctx, res);
         return -1;
+    }
     if (JS_IsBigInt(ctx, op2)) {
         ret = JS_ToBigInt64(ctx, &e, op2);
     } else {
@@ -14172,395 +14199,7 @@ static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
     sp[-2] = res;
     return 0;
 }
-
-#else /* !CONFIG_BIGNUM */
-
-static JSValue JS_ThrowUnsupportedBigint(JSContext *ctx)
-{
-    return JS_ThrowTypeError(ctx, "bigint is not supported");
-}
-
-JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
-{
-    return JS_ThrowUnsupportedBigint(ctx);
-}
-
-JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
-{
-    return JS_ThrowUnsupportedBigint(ctx);
-}
-
-int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
-{
-    JS_ThrowUnsupportedBigint(ctx);
-    *pres = 0;
-    return -1;
-}
-
-static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
-                                                     JSValue *sp,
-                                                     OPCodeEnum op)
-{
-    JSValue op1;
-    double d;
-
-    op1 = sp[-1];
-    if (unlikely(JS_ToFloat64Free(ctx, &d, op1))) {
-        sp[-1] = JS_UNDEFINED;
-        return -1;
-    }
-    switch(op) {
-    case OP_inc:
-        d++;
-        break;
-    case OP_dec:
-        d--;
-        break;
-    case OP_plus:
-        break;
-    case OP_neg:
-        d = -d;
-        break;
-    default:
-        abort();
-    }
-    sp[-1] = JS_NewFloat64(ctx, d);
-    return 0;
-}
-
-/* specific case necessary for correct return value semantics */
-static __exception int js_post_inc_slow(JSContext *ctx,
-                                        JSValue *sp, OPCodeEnum op)
-{
-    JSValue op1;
-    double d, r;
-
-    op1 = sp[-1];
-    if (unlikely(JS_ToFloat64Free(ctx, &d, op1))) {
-        sp[-1] = JS_UNDEFINED;
-        return -1;
-    }
-    r = d + 2 * (op - OP_post_dec) - 1;
-    sp[0] = JS_NewFloat64(ctx, r);
-    sp[-1] = JS_NewFloat64(ctx, d);
-    return 0;
-}
-
-static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *sp,
-                                                      OPCodeEnum op)
-{
-    JSValue op1, op2;
-    double d1, d2, r;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    if (unlikely(JS_ToFloat64Free(ctx, &d1, op1))) {
-        JS_FreeValue(ctx, op2);
-        goto exception;
-    }
-    if (unlikely(JS_ToFloat64Free(ctx, &d2, op2))) {
-        goto exception;
-    }
-    switch(op) {
-    case OP_sub:
-        r = d1 - d2;
-        break;
-    case OP_mul:
-        r = d1 * d2;
-        break;
-    case OP_div:
-        r = d1 / d2;
-        break;
-    case OP_mod:
-        r = fmod(d1, d2);
-        break;
-    case OP_pow:
-        r = js_pow(d1, d2);
-        break;
-    default:
-        abort();
-    }
-    sp[-2] = JS_NewFloat64(ctx, r);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
-{
-    JSValue op1, op2;
-    uint32_t tag1, tag2;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    tag1 = JS_VALUE_GET_TAG(op1);
-    tag2 = JS_VALUE_GET_TAG(op2);
-    if ((tag1 == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag1)) &&
-        (tag2 == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag2))) {
-        goto add_numbers;
-    } else {
-        op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
-        if (JS_IsException(op1)) {
-            JS_FreeValue(ctx, op2);
-            goto exception;
-        }
-        op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
-        if (JS_IsException(op2)) {
-            JS_FreeValue(ctx, op1);
-            goto exception;
-        }
-        tag1 = JS_VALUE_GET_TAG(op1);
-        tag2 = JS_VALUE_GET_TAG(op2);
-        if (tag1 == JS_TAG_STRING || tag2 == JS_TAG_STRING) {
-            sp[-2] = JS_ConcatString(ctx, op1, op2);
-            if (JS_IsException(sp[-2]))
-                goto exception;
-        } else {
-            double d1, d2;
-        add_numbers:
-            if (JS_ToFloat64Free(ctx, &d1, op1)) {
-                JS_FreeValue(ctx, op2);
-                goto exception;
-            }
-            if (JS_ToFloat64Free(ctx, &d2, op2))
-                goto exception;
-            sp[-2] = JS_NewFloat64(ctx, d1 + d2);
-        }
-    }
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
-                                                      JSValue *sp,
-                                                      OPCodeEnum op)
-{
-    JSValue op1, op2;
-    uint32_t v1, v2, r;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
-        JS_FreeValue(ctx, op2);
-        goto exception;
-    }
-    if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v2, op2)))
-        goto exception;
-    switch(op) {
-    case OP_shl:
-        r = v1 << (v2 & 0x1f);
-        break;
-    case OP_sar:
-        r = (int)v1 >> (v2 & 0x1f);
-        break;
-    case OP_and:
-        r = v1 & v2;
-        break;
-    case OP_or:
-        r = v1 | v2;
-        break;
-    case OP_xor:
-        r = v1 ^ v2;
-        break;
-    default:
-        abort();
-    }
-    sp[-2] = JS_NewInt32(ctx, r);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
-{
-    int32_t v1;
-
-    if (unlikely(JS_ToInt32Free(ctx, &v1, sp[-1]))) {
-        sp[-1] = JS_UNDEFINED;
-        return -1;
-    }
-    sp[-1] = JS_NewInt32(ctx, ~v1);
-    return 0;
-}
-
-static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
-                                        OPCodeEnum op)
-{
-    JSValue op1, op2;
-    int res;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NUMBER);
-    if (JS_IsException(op1)) {
-        JS_FreeValue(ctx, op2);
-        goto exception;
-    }
-    op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NUMBER);
-    if (JS_IsException(op2)) {
-        JS_FreeValue(ctx, op1);
-        goto exception;
-    }
-    if (JS_VALUE_GET_TAG(op1) == JS_TAG_STRING &&
-        JS_VALUE_GET_TAG(op2) == JS_TAG_STRING) {
-        JSString *p1, *p2;
-        p1 = JS_VALUE_GET_STRING(op1);
-        p2 = JS_VALUE_GET_STRING(op2);
-        res = js_string_compare(ctx, p1, p2);
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        switch(op) {
-        case OP_lt:
-            res = (res < 0);
-            break;
-        case OP_lte:
-            res = (res <= 0);
-            break;
-        case OP_gt:
-            res = (res > 0);
-            break;
-        default:
-        case OP_gte:
-            res = (res >= 0);
-            break;
-        }
-    } else {
-        double d1, d2;
-        if (JS_ToFloat64Free(ctx, &d1, op1)) {
-            JS_FreeValue(ctx, op2);
-            goto exception;
-        }
-        if (JS_ToFloat64Free(ctx, &d2, op2))
-            goto exception;
-        switch(op) {
-        case OP_lt:
-            res = (d1 < d2); /* if NaN return false */
-            break;
-        case OP_lte:
-            res = (d1 <= d2); /* if NaN return false */
-            break;
-        case OP_gt:
-            res = (d1 > d2); /* if NaN return false */
-            break;
-        default:
-        case OP_gte:
-            res = (d1 >= d2); /* if NaN return false */
-            break;
-        }
-    }
-    sp[-2] = JS_NewBool(ctx, res);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
-                                            BOOL is_neq)
-{
-    JSValue op1, op2;
-    int tag1, tag2;
-    BOOL res;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
- redo:
-    tag1 = JS_VALUE_GET_NORM_TAG(op1);
-    tag2 = JS_VALUE_GET_NORM_TAG(op2);
-    if (tag1 == tag2 ||
-        (tag1 == JS_TAG_INT && tag2 == JS_TAG_FLOAT64) ||
-        (tag2 == JS_TAG_INT && tag1 == JS_TAG_FLOAT64)) {
-        res = js_strict_eq(ctx, op1, op2);
-    } else if ((tag1 == JS_TAG_NULL && tag2 == JS_TAG_UNDEFINED) ||
-               (tag2 == JS_TAG_NULL && tag1 == JS_TAG_UNDEFINED)) {
-        res = TRUE;
-    } else if ((tag1 == JS_TAG_STRING && (tag2 == JS_TAG_INT ||
-                                   tag2 == JS_TAG_FLOAT64)) ||
-        (tag2 == JS_TAG_STRING && (tag1 == JS_TAG_INT ||
-                                   tag1 == JS_TAG_FLOAT64))) {
-        double d1;
-        double d2;
-        if (JS_ToFloat64Free(ctx, &d1, op1)) {
-            JS_FreeValue(ctx, op2);
-            goto exception;
-        }
-        if (JS_ToFloat64Free(ctx, &d2, op2))
-            goto exception;
-        res = (d1 == d2);
-    } else if (tag1 == JS_TAG_BOOL) {
-        op1 = JS_NewInt32(ctx, JS_VALUE_GET_INT(op1));
-        goto redo;
-    } else if (tag2 == JS_TAG_BOOL) {
-        op2 = JS_NewInt32(ctx, JS_VALUE_GET_INT(op2));
-        goto redo;
-    } else if (tag1 == JS_TAG_OBJECT &&
-               (tag2 == JS_TAG_INT || tag2 == JS_TAG_FLOAT64 || tag2 == JS_TAG_STRING || tag2 == JS_TAG_SYMBOL)) {
-        op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
-        if (JS_IsException(op1)) {
-            JS_FreeValue(ctx, op2);
-            goto exception;
-        }
-        goto redo;
-    } else if (tag2 == JS_TAG_OBJECT &&
-               (tag1 == JS_TAG_INT || tag1 == JS_TAG_FLOAT64 || tag1 == JS_TAG_STRING || tag1 == JS_TAG_SYMBOL)) {
-        op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
-        if (JS_IsException(op2)) {
-            JS_FreeValue(ctx, op1);
-            goto exception;
-        }
-        goto redo;
-    } else {
-        /* IsHTMLDDA object is equivalent to undefined for '==' and '!=' */
-        if ((JS_IsHTMLDDA(ctx, op1) &&
-             (tag2 == JS_TAG_NULL || tag2 == JS_TAG_UNDEFINED)) ||
-            (JS_IsHTMLDDA(ctx, op2) &&
-             (tag1 == JS_TAG_NULL || tag1 == JS_TAG_UNDEFINED))) {
-            res = TRUE;
-        } else {
-            res = FALSE;
-        }
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-    }
-    sp[-2] = JS_NewBool(ctx, res ^ is_neq);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
-{
-    JSValue op1, op2;
-    uint32_t v1, v2, r;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    if (unlikely(JS_ToUint32Free(ctx, &v1, op1))) {
-        JS_FreeValue(ctx, op2);
-        goto exception;
-    }
-    if (unlikely(JS_ToUint32Free(ctx, &v2, op2)))
-        goto exception;
-    r = v1 >> (v2 & 0x1f);
-    sp[-2] = JS_NewUint32(ctx, r);
-    return 0;
- exception:
-    sp[-2] = JS_UNDEFINED;
-    sp[-1] = JS_UNDEFINED;
-    return -1;
-}
-
-#endif /* !CONFIG_BIGNUM */
+#endif
 
 /* XXX: Should take JSValueConst arguments */
 static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
@@ -14654,7 +14293,6 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             res = (d1 == d2); /* if NaN return false and +0 == -0 */
         }
         goto done_no_free;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         {
             bf_t a_s, *a, b_s, *b;
@@ -14662,8 +14300,8 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
                 res = FALSE;
                 break;
             }
-            a = JS_ToBigFloat(ctx, &a_s, op1);
-            b = JS_ToBigFloat(ctx, &b_s, op2);
+            a = JS_ToBigFloat(ctx, &a_s, op1); /* cannot fail */
+            b = JS_ToBigFloat(ctx, &b_s, op2); /* cannot fail */
             res = bf_cmp_eq(a, b);
             if (a == &a_s)
                 bf_delete(a);
@@ -14671,6 +14309,7 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
                 bf_delete(b);
         }
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         {
             JSBigFloat *p1, *p2;
@@ -14816,10 +14455,10 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValueConst op1)
 
     tag = JS_VALUE_GET_NORM_TAG(op1);
     switch(tag) {
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         atom = JS_ATOM_bigint;
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         atom = JS_ATOM_bigfloat;
         break;
@@ -15151,7 +14790,7 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
                                    JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY))
             goto fail;
         for(i = 0; i < tab_atom_count; i++) {
-            JS_SetPropertyInternal(ctx, enum_obj, tab_atom[i].atom, JS_NULL, 0);
+            JS_SetPropertyInternal(ctx, enum_obj, tab_atom[i].atom, JS_NULL, enum_obj, 0);
         }
         js_free_prop_enum(ctx, tab_atom, tab_atom_count);
     }
@@ -17571,7 +17210,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 pc += 4;
 
-                ret = JS_SetPropertyInternal(ctx, sp[-2], atom, sp[-1],
+                ret = JS_SetPropertyInternal(ctx, sp[-2], atom, sp[-1], sp[-2],
                                              JS_PROP_THROW_STRICT);
                 JS_FreeValue(ctx, sp[-2]);
                 sp -= 2;
@@ -17870,8 +17509,8 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = JS_ValueToAtom(ctx, sp[-2]);
                 if (unlikely(atom == JS_ATOM_NULL))
                     goto exception;
-                ret = JS_SetPropertyGeneric(ctx, sp[-3], atom, sp[-1], sp[-4],
-                                            JS_PROP_THROW_STRICT);
+                ret = JS_SetPropertyInternal(ctx, sp[-3], atom, sp[-1], sp[-4],
+                                             JS_PROP_THROW_STRICT);
                 JS_FreeAtom(ctx, atom);
                 JS_FreeValue(ctx, sp[-4]);
                 JS_FreeValue(ctx, sp[-3]);
@@ -18550,7 +18189,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                         break;
                     case OP_with_put_var:
                         /* XXX: check if strict mode */
-                        ret = JS_SetPropertyInternal(ctx, obj, atom, sp[-2],
+                        ret = JS_SetPropertyInternal(ctx, obj, atom, sp[-2], obj,
                                                      JS_PROP_THROW_STRICT);
                         JS_FreeValue(ctx, sp[-1]);
                         sp -= 2;
@@ -20148,11 +19787,9 @@ static __exception int next_token(JSParseState *s);
 static void free_token(JSParseState *s, JSToken *token)
 {
     switch(token->val) {
-#ifdef CONFIG_BIGNUM
     case TOK_NUMBER:
         JS_FreeValue(s->ctx, token->u.num.val);
         break;
-#endif
     case TOK_STRING:
     case TOK_TEMPLATE:
         JS_FreeValue(s->ctx, token->u.str.str);
@@ -20898,8 +20535,8 @@ static __exception int next_token(JSParseState *s)
             int flags, radix;
             flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL |
                 ATOD_ACCEPT_UNDERSCORES;
-#ifdef CONFIG_BIGNUM
             flags |= ATOD_ACCEPT_SUFFIX;
+#ifdef CONFIG_BIGNUM
             if (s->cur_func->js_mode & JS_MODE_MATH) {
                 flags |= ATOD_MODE_BIGINT;
                 if (s->cur_func->js_mode & JS_MODE_MATH)
@@ -22108,7 +21745,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
 
 /* add a private field variable in the current scope */
 static int add_private_class_field(JSParseState *s, JSFunctionDef *fd,
-                                   JSAtom name, JSVarKindEnum var_kind)
+                                   JSAtom name, JSVarKindEnum var_kind, BOOL is_static)
 {
     JSContext *ctx = s->ctx;
     JSVarDef *vd;
@@ -22120,6 +21757,7 @@ static int add_private_class_field(JSParseState *s, JSFunctionDef *fd,
     vd = &fd->vars[idx];
     vd->is_lexical = 1;
     vd->is_const = 1;
+    vd->is_static_private = is_static;
     return idx;
 }
 
@@ -23066,20 +22704,23 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
             JSFunctionDef *method_fd;
 
             if (is_private) {
-                int idx, var_kind;
+                int idx, var_kind, is_static1;
                 idx = find_private_class_field(ctx, fd, name, fd->scope_level);
                 if (idx >= 0) {
                     var_kind = fd->vars[idx].var_kind;
+                    is_static1 = fd->vars[idx].is_static_private;
                     if (var_kind == JS_VAR_PRIVATE_FIELD ||
                         var_kind == JS_VAR_PRIVATE_METHOD ||
                         var_kind == JS_VAR_PRIVATE_GETTER_SETTER ||
-                        var_kind == (JS_VAR_PRIVATE_GETTER + is_set)) {
+                        var_kind == (JS_VAR_PRIVATE_GETTER + is_set) ||
+                        (var_kind == (JS_VAR_PRIVATE_GETTER + 1 - is_set) &&
+                         is_static != is_static1)) {
                         goto private_field_already_defined;
                     }
                     fd->vars[idx].var_kind = JS_VAR_PRIVATE_GETTER_SETTER;
                 } else {
                     if (add_private_class_field(s, fd, name,
-                                                JS_VAR_PRIVATE_GETTER + is_set) < 0)
+                                                JS_VAR_PRIVATE_GETTER + is_set, is_static) < 0)
                         goto fail;
                 }
                 if (add_brand(s, &class_fields[is_static]) < 0)
@@ -23105,7 +22746,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                         goto fail;
                     emit_atom(s, setter_name);
                     ret = add_private_class_field(s, fd, setter_name,
-                                                  JS_VAR_PRIVATE_SETTER);
+                                                  JS_VAR_PRIVATE_SETTER, is_static);
                     JS_FreeAtom(ctx, setter_name);
                     if (ret < 0)
                         goto fail;
@@ -23140,7 +22781,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                     goto private_field_already_defined;
                 }
                 if (add_private_class_field(s, fd, name,
-                                            JS_VAR_PRIVATE_FIELD) < 0)
+                                            JS_VAR_PRIVATE_FIELD, is_static) < 0)
                     goto fail;
                 emit_op(s, OP_private_symbol);
                 emit_atom(s, name);
@@ -23247,7 +22888,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                     goto fail;
                 }
                 if (add_private_class_field(s, fd, name,
-                                            JS_VAR_PRIVATE_METHOD) < 0)
+                                            JS_VAR_PRIVATE_METHOD, is_static) < 0)
                     goto fail;
                 emit_op(s, OP_set_home_object);
                 emit_op(s, OP_set_name);
@@ -25015,6 +24656,8 @@ static __exception int js_parse_delete(JSParseState *s)
     case OP_scope_get_private_field:
         return js_parse_error(s, "cannot delete a private class field");
     case OP_get_super_value:
+        fd->byte_code.size = fd->last_opcode_pos;
+        fd->last_opcode_pos = -1;
         emit_op(s, OP_throw_error);
         emit_atom(s, JS_ATOM_NULL);
         emit_u8(s, JS_THROW_ERROR_DELETE_SUPER);
@@ -30181,6 +29824,7 @@ static int resolve_scope_private_field(JSContext *ctx, JSFunctionDef *s,
                 /* obj func value */
                 dbuf_putc(bc, OP_call_method);
                 dbuf_put_u16(bc, 1);
+                dbuf_putc(bc, OP_drop);
             }
             break;
         default:
@@ -30305,12 +29949,13 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
         is_arg_scope = (scope_idx == ARG_SCOPE_END);
         if (!is_arg_scope) {
             /* add unscoped variables */
+            /* XXX: propagate is_const and var_kind too ? */
             for(i = 0; i < fd->arg_count; i++) {
                 vd = &fd->args[i];
                 if (vd->var_name != JS_ATOM_NULL) {
                     get_closure_var(ctx, s, fd,
-                                    TRUE, i, vd->var_name, FALSE, FALSE,
-                                    JS_VAR_NORMAL);
+                                    TRUE, i, vd->var_name, FALSE,
+                                    vd->is_lexical, JS_VAR_NORMAL);
                 }
             }
             for(i = 0; i < fd->var_count; i++) {
@@ -30320,8 +29965,8 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
                     vd->var_name != JS_ATOM__ret_ &&
                     vd->var_name != JS_ATOM_NULL) {
                     get_closure_var(ctx, s, fd,
-                                    FALSE, i, vd->var_name, FALSE, FALSE,
-                                    JS_VAR_NORMAL);
+                                    FALSE, i, vd->var_name, FALSE,
+                                    vd->is_lexical, JS_VAR_NORMAL);
                 }
             }
         } else {
@@ -30330,8 +29975,8 @@ static void add_eval_variables(JSContext *ctx, JSFunctionDef *s)
                 /* do not close top level last result */
                 if (vd->scope_level == 0 && is_var_in_arg_scope(vd)) {
                     get_closure_var(ctx, s, fd,
-                                    FALSE, i, vd->var_name, FALSE, FALSE,
-                                    JS_VAR_NORMAL);
+                                    FALSE, i, vd->var_name, FALSE,
+                                    vd->is_lexical, JS_VAR_NORMAL);
                 }
             }
         }
@@ -32258,7 +31903,7 @@ static __exception int ss_check(JSContext *ctx, StackSizeState *s,
     if (s->stack_level_tab[pos] != 0xffff) {
         /* already explored: check that the stack size is consistent */
         if (s->stack_level_tab[pos] != stack_len) {
-            JS_ThrowInternalError(ctx, "unconsistent stack size: %d %d (pc=%d)",
+            JS_ThrowInternalError(ctx, "inconsistent stack size: %d %d (pc=%d)",
                                   s->stack_level_tab[pos], stack_len, pos);
             return -1;
         } else {
@@ -34156,7 +33801,6 @@ static void JS_WriteString(BCWriterState *s, JSString *p)
     }
 }
 
-#ifdef CONFIG_BIGNUM
 static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
 {
     uint32_t tag, tag1;
@@ -34171,12 +33815,14 @@ static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
     case JS_TAG_BIG_INT:
         tag1 = BC_TAG_BIG_INT;
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         tag1 = BC_TAG_BIG_FLOAT;
         break;
     case JS_TAG_BIG_DECIMAL:
         tag1 = BC_TAG_BIG_DECIMAL;
         break;
+#endif        
     default:
         abort();
     }
@@ -34291,7 +33937,6 @@ static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
     }
     return 0;
 }
-#endif /* CONFIG_BIGNUM */
 
 static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj);
 
@@ -34648,8 +34293,8 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
             case JS_CLASS_NUMBER:
             case JS_CLASS_STRING:
             case JS_CLASS_BOOLEAN:
-#ifdef CONFIG_BIGNUM
             case JS_CLASS_BIG_INT:
+#ifdef CONFIG_BIGNUM
             case JS_CLASS_BIG_FLOAT:
             case JS_CLASS_BIG_DECIMAL:
 #endif
@@ -34671,14 +34316,14 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                 goto fail;
         }
         break;
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
     case JS_TAG_BIG_DECIMAL:
+#endif
         if (JS_WriteBigNum(s, obj))
             goto fail;
         break;
-#endif
     default:
     invalid_tag:
         JS_ThrowInternalError(s->ctx, "unsupported tag (%d)", tag);
@@ -35070,7 +34715,6 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     return 0;
 }
 
-#ifdef CONFIG_BIGNUM
 static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
 {
     JSValue obj = JS_UNDEFINED;
@@ -35090,12 +34734,14 @@ static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
     case BC_TAG_BIG_INT:
         obj = JS_MKPTR(JS_TAG_BIG_INT, p);
         break;
+#ifdef CONFIG_BIGNUM
     case BC_TAG_BIG_FLOAT:
         obj = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
         break;
     case BC_TAG_BIG_DECIMAL:
         obj = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
         break;
+#endif        
     default:
         abort();
     }
@@ -35202,7 +34848,6 @@ static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
     JS_FreeValue(s->ctx, obj);
     return JS_EXCEPTION;
 }
-#endif /* CONFIG_BIGNUM */
 
 static JSValue JS_ReadObjectRec(BCReaderState *s);
 
@@ -35827,13 +35472,13 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
     case BC_TAG_OBJECT_VALUE:
         obj = JS_ReadObjectValue(s);
         break;
-#ifdef CONFIG_BIGNUM
     case BC_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
     case BC_TAG_BIG_FLOAT:
     case BC_TAG_BIG_DECIMAL:
+#endif
         obj = JS_ReadBigNum(s, tag);
         break;
-#endif
     case BC_TAG_OBJECT_REFERENCE:
         {
             uint32_t val;
@@ -36265,10 +35910,10 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val)
     case JS_TAG_OBJECT:
     case JS_TAG_EXCEPTION:
         return JS_DupValue(ctx, val);
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
         goto set_value;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_FLOAT);
         goto set_value;
@@ -38323,6 +37968,41 @@ static int JS_isConcatSpreadable(JSContext *ctx, JSValueConst obj)
     return JS_IsArray(ctx, obj);
 }
 
+static JSValue js_array_at(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
+{
+    JSValue obj, ret;
+    int64_t len, idx;
+    JSValue *arrp;
+    uint32_t count;
+    
+    obj = JS_ToObject(ctx, this_val);
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+
+    if (JS_ToInt64Sat(ctx, &idx, argv[0]))
+        goto exception;
+
+    if (idx < 0)
+        idx = len + idx;
+    if (idx < 0 || idx >= len) {
+        ret = JS_UNDEFINED;
+    } else if (js_get_fast_array(ctx, obj, &arrp, &count) && idx < count) {
+        ret = JS_DupValue(ctx, arrp[idx]);
+    } else {
+        int present = JS_TryGetPropertyInt64(ctx, obj, idx, &ret);
+        if (present < 0)
+            goto exception;
+        if (!present)
+            ret = JS_UNDEFINED;
+    }
+    JS_FreeValue(ctx, obj);
+    return ret;
+ exception:
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
 static JSValue js_array_concat(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
 {
@@ -38821,13 +38501,21 @@ static JSValue js_array_lastIndexOf(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+enum {
+    special_find,
+    special_findIndex,
+    special_findLast,
+    special_findLastIndex,
+};
+
 static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv, int findIndex)
+                             int argc, JSValueConst *argv, int mode)
 {
     JSValueConst func, this_arg;
     JSValueConst args[3];
     JSValue obj, val, index_val, res;
-    int64_t len, k;
+    int64_t len, k, end;
+    int dir;
 
     index_val = JS_UNDEFINED;
     val = JS_UNDEFINED;
@@ -38843,7 +38531,18 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
     if (argc > 1)
         this_arg = argv[1];
 
-    for(k = 0; k < len; k++) {
+    if (mode == special_findLast || mode == special_findLastIndex) {
+        k = len - 1;
+        dir = -1;
+        end = -1;
+    } else {
+        k = 0;
+        dir = 1;
+        end = len;
+    }
+
+    // TODO(bnoordhuis) add fast path for fast arrays
+    for(; k != end; k += dir) {
         index_val = JS_NewInt64(ctx, k);
         if (JS_IsException(index_val))
             goto exception;
@@ -38857,7 +38556,7 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(res))
             goto exception;
         if (JS_ToBoolFree(ctx, res)) {
-            if (findIndex) {
+            if (mode == special_findIndex || mode == special_findLastIndex) {
                 JS_FreeValue(ctx, val);
                 JS_FreeValue(ctx, obj);
                 return index_val;
@@ -38871,7 +38570,7 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
         JS_FreeValue(ctx, index_val);
     }
     JS_FreeValue(ctx, obj);
-    if (findIndex)
+    if (mode == special_findIndex || mode == special_findLastIndex)
         return JS_NewInt32(ctx, -1);
     else
         return JS_UNDEFINED;
@@ -39684,6 +39383,7 @@ static const JSCFunctionListEntry js_iterator_proto_funcs[] = {
 };
 
 static const JSCFunctionListEntry js_array_proto_funcs[] = {
+    JS_CFUNC_DEF("at", 1, js_array_at ),
     JS_CFUNC_DEF("concat", 1, js_array_concat ),
     JS_CFUNC_MAGIC_DEF("every", 1, js_array_every, special_every ),
     JS_CFUNC_MAGIC_DEF("some", 1, js_array_every, special_some ),
@@ -39693,8 +39393,10 @@ static const JSCFunctionListEntry js_array_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("reduce", 1, js_array_reduce, special_reduce ),
     JS_CFUNC_MAGIC_DEF("reduceRight", 1, js_array_reduce, special_reduceRight ),
     JS_CFUNC_DEF("fill", 1, js_array_fill ),
-    JS_CFUNC_MAGIC_DEF("find", 1, js_array_find, 0 ),
-    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_array_find, 1 ),
+    JS_CFUNC_MAGIC_DEF("find", 1, js_array_find, special_find ),
+    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_array_find, special_findIndex ),
+    JS_CFUNC_MAGIC_DEF("findLast", 1, js_array_find, special_findLast ),
+    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_array_find, special_findLastIndex ),
     JS_CFUNC_DEF("indexOf", 1, js_array_indexOf ),
     JS_CFUNC_DEF("lastIndexOf", 1, js_array_lastIndexOf ),
     JS_CFUNC_DEF("includes", 1, js_array_includes ),
@@ -39736,9 +39438,10 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
         if (JS_IsException(val))
             return val;
         switch(JS_VALUE_GET_TAG(val)) {
-#ifdef CONFIG_BIGNUM
         case JS_TAG_BIG_INT:
+#ifdef CONFIG_BIGNUM
         case JS_TAG_BIG_FLOAT:
+#endif            
             {
                 JSBigFloat *p = JS_VALUE_GET_PTR(val);
                 double d;
@@ -39747,6 +39450,7 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
                 val = __JS_NewFloat64(ctx, d);
             }
             break;
+#ifdef CONFIG_BIGNUM
         case JS_TAG_BIG_DECIMAL:
             val = JS_ToStringFree(ctx, val);
             if (JS_IsException(val))
@@ -40381,7 +40085,7 @@ static JSValue js_string_charCodeAt(JSContext *ctx, JSValueConst this_val,
 }
 
 static JSValue js_string_charAt(JSContext *ctx, JSValueConst this_val,
-                                int argc, JSValueConst *argv)
+                                int argc, JSValueConst *argv, int is_at)
 {
     JSValue val, ret;
     JSString *p;
@@ -40395,8 +40099,13 @@ static JSValue js_string_charAt(JSContext *ctx, JSValueConst this_val,
         JS_FreeValue(ctx, val);
         return JS_EXCEPTION;
     }
+    if (idx < 0 && is_at)
+        idx += p->len;
     if (idx < 0 || idx >= p->len) {
-        ret = js_new_string8(ctx, NULL, 0);
+        if (is_at)
+            ret = JS_UNDEFINED;
+        else
+            ret = js_new_string8(ctx, NULL, 0);
     } else {
         if (p->is_wide_char)
             c = p->u.str16[idx];
@@ -41655,8 +41364,9 @@ static const JSCFunctionListEntry js_string_funcs[] = {
 
 static const JSCFunctionListEntry js_string_proto_funcs[] = {
     JS_PROP_INT32_DEF("length", 0, JS_PROP_CONFIGURABLE ),
+    JS_CFUNC_MAGIC_DEF("at", 1, js_string_charAt, 1 ),
     JS_CFUNC_DEF("charCodeAt", 1, js_string_charCodeAt ),
-    JS_CFUNC_DEF("charAt", 1, js_string_charAt ),
+    JS_CFUNC_MAGIC_DEF("charAt", 1, js_string_charAt, 0 ),
     JS_CFUNC_DEF("concat", 1, js_string_concat ),
     JS_CFUNC_DEF("codePointAt", 1, js_string_codePointAt ),
     JS_CFUNC_MAGIC_DEF("indexOf", 1, js_string_indexOf, 0 ),
@@ -42818,7 +42528,7 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
 {
     // [Symbol.match](str)
     JSValueConst rx = this_val;
-    JSValue A, S, result, matchStr;
+    JSValue A, S, flags, result, matchStr;
     int global, n, fullUnicode, isEmpty;
     JSString *p;
 
@@ -42826,16 +42536,23 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
     A = JS_UNDEFINED;
+    flags = JS_UNDEFINED;
     result = JS_UNDEFINED;
     matchStr = JS_UNDEFINED;
     S = JS_ToString(ctx, argv[0]);
     if (JS_IsException(S))
         goto exception;
 
-    global = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_global));
-    if (global < 0)
+    flags = JS_GetProperty(ctx, rx, JS_ATOM_flags);
+    if (JS_IsException(flags))
+        goto exception;
+    flags = JS_ToStringFree(ctx, flags);
+    if (JS_IsException(flags))
         goto exception;
+    p = JS_VALUE_GET_STRING(flags);
 
+    // TODO(bnoordhuis) query 'u' flag the same way?
+    global = (-1 != string_indexof_char(p, 'g', 0));
     if (!global) {
         A = JS_RegExpExec(ctx, rx, S);
     } else {
@@ -42879,12 +42596,14 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
         }
     }
     JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, flags);
     JS_FreeValue(ctx, S);
     return A;
 
 exception:
     JS_FreeValue(ctx, A);
     JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, flags);
     JS_FreeValue(ctx, S);
     return JS_EXCEPTION;
 }
@@ -43127,8 +42846,8 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
     // [Symbol.replace](str, rep)
     JSValueConst rx = this_val, rep = argv[1];
     JSValueConst args[6];
-    JSValue str, rep_val, matched, tab, rep_str, namedCaptures, res;
-    JSString *sp, *rp;
+    JSValue flags, str, rep_val, matched, tab, rep_str, namedCaptures, res;
+    JSString *p, *sp, *rp;
     StringBuffer b_s, *b = &b_s;
     ValueBuffer v_b, *results = &v_b;
     int nextSourcePosition, n, j, functionalReplace, is_global, fullUnicode;
@@ -43144,6 +42863,7 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
     rep_val = JS_UNDEFINED;
     matched = JS_UNDEFINED;
     tab = JS_UNDEFINED;
+    flags = JS_UNDEFINED;
     rep_str = JS_UNDEFINED;
     namedCaptures = JS_UNDEFINED;
 
@@ -43160,10 +42880,18 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
             goto exception;
         rp = JS_VALUE_GET_STRING(rep_val);
     }
-    fullUnicode = 0;
-    is_global = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_global));
-    if (is_global < 0)
+
+    flags = JS_GetProperty(ctx, rx, JS_ATOM_flags);
+    if (JS_IsException(flags))
         goto exception;
+    flags = JS_ToStringFree(ctx, flags);
+    if (JS_IsException(flags))
+        goto exception;
+    p = JS_VALUE_GET_STRING(flags);
+
+    // TODO(bnoordhuis) query 'u' flag the same way?
+    fullUnicode = 0;
+    is_global = (-1 != string_indexof_char(p, 'g', 0));
     if (is_global) {
         fullUnicode = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_unicode));
         if (fullUnicode < 0)
@@ -43297,6 +43025,7 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
     value_buffer_free(results);
     JS_FreeValue(ctx, rep_val);
     JS_FreeValue(ctx, matched);
+    JS_FreeValue(ctx, flags);
     JS_FreeValue(ctx, tab);
     JS_FreeValue(ctx, rep_str);
     JS_FreeValue(ctx, namedCaptures);
@@ -43839,10 +43568,8 @@ static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
     JSValue v;
     JSValueConst args[2];
 
-    if (JS_IsObject(val)
-#ifdef CONFIG_BIGNUM
-    ||  JS_IsBigInt(ctx, val)   /* XXX: probably useless */
-#endif
+    if (JS_IsObject(val) ||
+        JS_IsBigInt(ctx, val)   /* XXX: probably useless */
         ) {
             JSValue f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
             if (JS_IsException(f))
@@ -43880,9 +43607,7 @@ static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
 #endif
     case JS_TAG_BOOL:
     case JS_TAG_NULL:
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
-#endif
     case JS_TAG_EXCEPTION:
         return val;
     default:
@@ -43933,15 +43658,16 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
             ret = string_buffer_concat_value(jsc->b, p->u.object_data);
             JS_FreeValue(ctx, val);
             return ret;
-        }
+        } else
 #ifdef CONFIG_BIGNUM
-        else if (cl == JS_CLASS_BIG_FLOAT) {
+        if (cl == JS_CLASS_BIG_FLOAT) {
             return string_buffer_concat_value_free(jsc->b, val);
-        } else if (cl == JS_CLASS_BIG_INT) {
+        } else
+#endif
+        if (cl == JS_CLASS_BIG_INT) {
             JS_ThrowTypeError(ctx, "bigint are forbidden in JSON.stringify");
             goto exception;
         }
-#endif
         v = js_array_includes(ctx, jsc->stack, 1, (JSValueConst *)&val);
         if (JS_IsException(v))
             goto exception;
@@ -44071,11 +43797,9 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
     case JS_TAG_NULL:
     concat_value:
         return string_buffer_concat_value_free(jsc->b, val);
-#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_INT:
         JS_ThrowTypeError(ctx, "bigint are forbidden in JSON.stringify");
         goto exception;
-#endif
     default:
         JS_FreeValue(ctx, val);
         return 0;
@@ -44365,8 +44089,8 @@ static JSValue js_reflect_set(JSContext *ctx, JSValueConst this_val,
     atom = JS_ValueToAtom(ctx, prop);
     if (unlikely(atom == JS_ATOM_NULL))
         return JS_EXCEPTION;
-    ret = JS_SetPropertyGeneric(ctx, obj, atom,
-                                JS_DupValue(ctx, val), receiver, 0);
+    ret = JS_SetPropertyInternal(ctx, obj, atom,
+                                 JS_DupValue(ctx, val), receiver, 0);
     JS_FreeAtom(ctx, atom);
     if (ret < 0)
         return JS_EXCEPTION;
@@ -44713,9 +44437,9 @@ static int js_proxy_set(JSContext *ctx, JSValueConst obj, JSAtom atom,
     if (!s)
         return -1;
     if (JS_IsUndefined(method)) {
-        return JS_SetPropertyGeneric(ctx, s->target, atom,
-                                     JS_DupValue(ctx, value), receiver,
-                                     flags);
+        return JS_SetPropertyInternal(ctx, s->target, atom,
+                                      JS_DupValue(ctx, value), receiver,
+                                      flags);
     }
     atom_val = JS_AtomToValue(ctx, atom);
     if (JS_IsException(atom_val)) {
@@ -45248,6 +44972,10 @@ static int js_proxy_isArray(JSContext *ctx, JSValueConst obj)
     JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
     if (!s)
         return FALSE;
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        return -1;
+    }
     if (s->is_revoked) {
         JS_ThrowTypeErrorRevokedProxy(ctx);
         return -1;
@@ -48103,20 +47831,19 @@ static JSValue set_date_field(JSContext *ctx, JSValueConst this_val,
     res = get_date_fields(ctx, this_val, fields, is_local, first_field == 0);
     if (res < 0)
         return JS_EXCEPTION;
+
+    // Argument coercion is observable and must be done unconditionally.
+    n = min_int(argc, end_field - first_field);
+    for(i = 0; i < n; i++) {
+        if (JS_ToFloat64(ctx, &a, argv[i]))
+            return JS_EXCEPTION;
+        if (!isfinite(a))
+            res = FALSE;
+        fields[first_field + i] = trunc(a);
+    }
     if (res && argc > 0) {
-        n = end_field - first_field;
-        if (argc < n)
-            n = argc;
-        for(i = 0; i < n; i++) {
-            if (JS_ToFloat64(ctx, &a, argv[i]))
-                return JS_EXCEPTION;
-            if (!isfinite(a))
-                goto done;
-            fields[first_field + i] = trunc(a);
-        }
         d = set_date_fields(fields, is_local);
     }
-done:
     return JS_SetThisTimeValue(ctx, this_val, d);
 }
 
@@ -48387,8 +48114,11 @@ static int string_get_signed_digits(JSString *sp, int *pp, int64_t *pval) {
         p++;
  
     res = string_get_digits(sp, &p, pval);
-    if (res == 0 && sgn == '-')
+    if (res == 0 && sgn == '-') {
+        if (*pval == 0)
+            return -1; // reject negative zero
         *pval = -*pval;
+    }
     *pp = p;
     return res;
 }
@@ -49139,6 +48869,7 @@ void JS_AddIntrinsicOperators(JSContext *ctx)
     js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT]);
     js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
 }
+#endif /* CONFIG_BIGNUM */
 
 /* BigInt */
 
@@ -49156,11 +48887,17 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
     case JS_TAG_BIG_INT:
         break;
     case JS_TAG_FLOAT64:
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_FLOAT:
+#endif        
         {
             bf_t *a, a_s;
             
             a = JS_ToBigFloat(ctx, &a_s, val);
+            if (!a) {
+                JS_FreeValue(ctx, val);
+                return JS_EXCEPTION;
+            }
             if (!bf_is_finite(a)) {
                 JS_FreeValue(ctx, val);
                 val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to bigint");
@@ -49190,11 +48927,13 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
                 bf_delete(a);
         }
         break;
+#ifdef CONFIG_BIGNUM
     case JS_TAG_BIG_DECIMAL:
         val = JS_ToStringFree(ctx, val);
          if (JS_IsException(val))
             break;
         goto redo;
+#endif        
     case JS_TAG_STRING:
         val = JS_StringToBigIntErr(ctx, val);
         break;
@@ -49267,6 +49006,7 @@ static JSValue js_bigint_valueOf(JSContext *ctx, JSValueConst this_val,
     return js_thisBigIntValue(ctx, this_val);
 }
 
+#ifdef CONFIG_BIGNUM
 static JSValue js_bigint_div(JSContext *ctx,
                               JSValueConst this_val,
                               int argc, JSValueConst *argv, int magic)
@@ -49395,6 +49135,7 @@ static JSValue js_bigint_op1(JSContext *ctx,
     JS_FreeBigInt(ctx, a, &a_s);
     return JS_NewBigInt64(ctx, res);
 }
+#endif
 
 static JSValue js_bigint_asUintN(JSContext *ctx,
                                   JSValueConst this_val,
@@ -49439,6 +49180,7 @@ static JSValue js_bigint_asUintN(JSContext *ctx,
 static const JSCFunctionListEntry js_bigint_funcs[] = {
     JS_CFUNC_MAGIC_DEF("asUintN", 2, js_bigint_asUintN, 0 ),
     JS_CFUNC_MAGIC_DEF("asIntN", 2, js_bigint_asUintN, 1 ),
+#ifdef CONFIG_BIGNUM
     /* QuickJS extensions */
     JS_CFUNC_MAGIC_DEF("tdiv", 2, js_bigint_div, BF_RNDZ ),
     JS_CFUNC_MAGIC_DEF("fdiv", 2, js_bigint_div, BF_RNDD ),
@@ -49452,6 +49194,7 @@ static const JSCFunctionListEntry js_bigint_funcs[] = {
     JS_CFUNC_MAGIC_DEF("sqrtrem", 1, js_bigint_sqrt, 1 ),
     JS_CFUNC_MAGIC_DEF("floorLog2", 1, js_bigint_op1, 0 ),
     JS_CFUNC_MAGIC_DEF("ctz", 1, js_bigint_op1, 1 ),
+#endif    
 };
 
 static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
@@ -49470,7 +49213,7 @@ void JS_AddIntrinsicBigInt(JSContext *ctx)
     rt->bigint_ops.unary_arith = js_unary_arith_bigint;
     rt->bigint_ops.binary_arith = js_binary_arith_bigint;
     rt->bigint_ops.compare = js_compare_bigfloat;
-    
+
     ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
                                js_bigint_proto_funcs,
@@ -49481,6 +49224,8 @@ void JS_AddIntrinsicBigInt(JSContext *ctx)
                                countof(js_bigint_funcs));
 }
 
+#ifdef CONFIG_BIGNUM
+
 /* BigFloat */
 
 static JSValue js_thisBigFloatValue(JSContext *ctx, JSValueConst this_val)
@@ -49954,6 +49699,10 @@ static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
     if (JS_IsException(op1))
         return op1;
     a = JS_ToBigFloat(ctx, &a_s, op1);
+    if (!a) {
+        JS_FreeValue(ctx, op1);
+        return JS_EXCEPTION;
+    }
     fe = &ctx->fp_env;
     if (argc > 1) {
         fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
@@ -50052,7 +49801,11 @@ static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
         return op2;
     }
     a = JS_ToBigFloat(ctx, &a_s, op1);
+    if (!a)
+        goto fail1;
     b = JS_ToBigFloat(ctx, &b_s, op2);
+    if (!b)
+        goto fail2;
     fe = &ctx->fp_env;
     if (argc > 2) {
         fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
@@ -50062,10 +49815,12 @@ static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
     res = JS_NewBigFloat(ctx);
     if (JS_IsException(res)) {
     fail:
-        if (a == &a_s)
-            bf_delete(a);
         if (b == &b_s)
             bf_delete(b);
+    fail2:
+        if (a == &a_s)
+            bf_delete(a);
+    fail1:
         JS_FreeValue(ctx, op1);
         JS_FreeValue(ctx, op2);
         return JS_EXCEPTION;
@@ -51014,8 +50769,19 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     /* XXX: create auto_initializer */
     {
         /* initialize Array.prototype[Symbol.unscopables] */
-        char const unscopables[] = "copyWithin" "\0" "entries" "\0" "fill" "\0" "find" "\0"
-            "findIndex" "\0" "flat" "\0" "flatMap" "\0" "includes" "\0" "keys" "\0" "values" "\0";
+        char const unscopables[] =
+            "copyWithin" "\0"
+            "entries" "\0"
+            "fill" "\0"
+            "find" "\0"
+            "findIndex" "\0"
+            "findLast" "\0"
+            "findLastIndex" "\0"
+            "flat" "\0"
+            "flatMap" "\0"
+            "includes" "\0"
+            "keys" "\0"
+            "values" "\0";
         const char *p = unscopables;
         obj1 = JS_NewObjectProto(ctx, JS_NULL);
         for(p = unscopables; *p; p += strlen(p) + 1) {
@@ -51139,9 +50905,7 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
 
 static uint8_t const typed_array_size_log2[JS_TYPED_ARRAY_COUNT] = {
     0, 0, 0, 1, 1, 2, 2,
-#ifdef CONFIG_BIGNUM
     3, 3, /* BigInt64Array, BigUint64Array */
-#endif
     2, 3
 };
 
@@ -51702,6 +51466,32 @@ static JSValue js_typed_array_set_internal(JSContext *ctx,
     return JS_EXCEPTION;
 }
 
+static JSValue js_typed_array_at(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    JSObject *p;
+    int64_t idx, len;
+
+    p = get_typed_array(ctx, this_val, 0);
+    if (!p)
+        return JS_EXCEPTION;
+
+    if (typed_array_is_detached(ctx, p)) {
+        JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return JS_EXCEPTION;
+    }
+
+    if (JS_ToInt64Sat(ctx, &idx, argv[0]))
+        return JS_EXCEPTION;
+
+    len = p->u.array.count;
+    if (idx < 0)
+        idx = len + idx;
+    if (idx < 0 || idx >= len)
+        return JS_UNDEFINED;
+    return JS_GetPropertyInt64(ctx, this_val, idx);
+}
+
 static JSValue js_typed_array_set(JSContext *ctx,
                                   JSValueConst this_val,
                                   int argc, JSValueConst *argv)
@@ -51991,14 +51781,10 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
         if (JS_ToUint32(ctx, &v, argv[0]))
             return JS_EXCEPTION;
         v64 = v;
-    } else
-#ifdef CONFIG_BIGNUM
-    if (p->class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
+    } else if (p->class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
         if (JS_ToBigInt64(ctx, (int64_t *)&v64, argv[0]))
             return JS_EXCEPTION;
-    } else
-#endif
-    {
+    } else {
         double d;
         if (JS_ToFloat64(ctx, &d, argv[0]))
             return JS_EXCEPTION;
@@ -52060,12 +51846,13 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
 }
 
 static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv, int findIndex)
+                                   int argc, JSValueConst *argv, int mode)
 {
     JSValueConst func, this_arg;
     JSValueConst args[3];
     JSValue val, index_val, res;
-    int len, k;
+    int len, k, end;
+    int dir;
 
     val = JS_UNDEFINED;
     len = js_typed_array_get_length_internal(ctx, this_val);
@@ -52080,7 +51867,17 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
     if (argc > 1)
         this_arg = argv[1];
 
-    for(k = 0; k < len; k++) {
+    if (mode == special_findLast || mode == special_findLastIndex) {
+        k = len - 1;
+        dir = -1;
+        end = -1;
+    } else {
+        k = 0;
+        dir = 1;
+        end = len;
+    }
+
+    for(; k != end; k += dir) {
         index_val = JS_NewInt32(ctx, k);
         val = JS_GetPropertyValue(ctx, this_val, index_val);
         if (JS_IsException(val))
@@ -52092,7 +51889,7 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(res))
             goto exception;
         if (JS_ToBoolFree(ctx, res)) {
-            if (findIndex) {
+            if (mode == special_findIndex || mode == special_findLastIndex) {
                 JS_FreeValue(ctx, val);
                 return index_val;
             } else {
@@ -52101,7 +51898,7 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
         }
         JS_FreeValue(ctx, val);
     }
-    if (findIndex)
+    if (mode == special_findIndex || mode == special_findLastIndex)
         return JS_NewInt32(ctx, -1);
     else
         return JS_UNDEFINED;
@@ -52185,9 +51982,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         d = JS_VALUE_GET_FLOAT64(argv[0]);
         v64 = d;
         is_int = (v64 == d);
-    } else
-#ifdef CONFIG_BIGNUM
-    if (tag == JS_TAG_BIG_INT) {
+    } else if (tag == JS_TAG_BIG_INT) {
         JSBigFloat *p1 = JS_VALUE_GET_PTR(argv[0]);
         
         if (p->class_id == JS_CLASS_BIG_INT64_ARRAY) {
@@ -52201,9 +51996,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         }
         d = 0;
         is_bigint = 1;
-    } else
-#endif
-    {
+    } else {
         goto done;
     }
 
@@ -52320,7 +52113,6 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
             }
         }
         break;
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
         if (is_bigint || (is_math_mode(ctx) && is_int &&
                           v64 >= -MAX_SAFE_INTEGER &&
@@ -52344,7 +52136,6 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
             }
         }
         break;
-#endif
     }
 
 done:
@@ -52625,7 +52416,6 @@ static int js_TA_cmp_uint32(const void *a, const void *b, void *opaque) {
     return (y < x) - (y > x);
 }
 
-#ifdef CONFIG_BIGNUM
 static int js_TA_cmp_int64(const void *a, const void *b, void *opaque) {
     int64_t x = *(const int64_t *)a;
     int64_t y = *(const int64_t *)b;
@@ -52637,7 +52427,6 @@ static int js_TA_cmp_uint64(const void *a, const void *b, void *opaque) {
     uint64_t y = *(const uint64_t *)b;
     return (y < x) - (y > x);
 }
-#endif
 
 static int js_TA_cmp_float32(const void *a, const void *b, void *opaque) {
     return js_cmp_doubles(*(const float *)a, *(const float *)b);
@@ -52671,7 +52460,6 @@ static JSValue js_TA_get_uint32(JSContext *ctx, const void *a) {
     return JS_NewUint32(ctx, *(const uint32_t *)a);
 }
 
-#ifdef CONFIG_BIGNUM
 static JSValue js_TA_get_int64(JSContext *ctx, const void *a) {
     return JS_NewBigInt64(ctx, *(int64_t *)a);
 }
@@ -52679,7 +52467,6 @@ static JSValue js_TA_get_int64(JSContext *ctx, const void *a) {
 static JSValue js_TA_get_uint64(JSContext *ctx, const void *a) {
     return JS_NewBigUint64(ctx, *(uint64_t *)a);
 }
-#endif
 
 static JSValue js_TA_get_float32(JSContext *ctx, const void *a) {
     return __JS_NewFloat64(ctx, *(const float *)a);
@@ -52795,7 +52582,6 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             tsc.getfun = js_TA_get_uint32;
             cmpfun = js_TA_cmp_uint32;
             break;
-#ifdef CONFIG_BIGNUM
         case JS_CLASS_BIG_INT64_ARRAY:
             tsc.getfun = js_TA_get_int64;
             cmpfun = js_TA_cmp_int64;
@@ -52804,7 +52590,6 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             tsc.getfun = js_TA_get_uint64;
             cmpfun = js_TA_cmp_uint64;
             break;
-#endif
         case JS_CLASS_FLOAT32_ARRAY:
             tsc.getfun = js_TA_get_float32;
             cmpfun = js_TA_cmp_float32;
@@ -52892,6 +52677,7 @@ static const JSCFunctionListEntry js_typed_array_base_funcs[] = {
 
 static const JSCFunctionListEntry js_typed_array_base_proto_funcs[] = {
     JS_CGETSET_DEF("length", js_typed_array_get_length, NULL ),
+    JS_CFUNC_DEF("at", 1, js_typed_array_at ),
     JS_CGETSET_MAGIC_DEF("buffer", js_typed_array_get_buffer, NULL, 0 ),
     JS_CGETSET_MAGIC_DEF("byteLength", js_typed_array_get_byteLength, NULL, 0 ),
     JS_CGETSET_MAGIC_DEF("byteOffset", js_typed_array_get_byteOffset, NULL, 0 ),
@@ -52910,8 +52696,10 @@ static const JSCFunctionListEntry js_typed_array_base_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("reduce", 1, js_array_reduce, special_reduce | special_TA ),
     JS_CFUNC_MAGIC_DEF("reduceRight", 1, js_array_reduce, special_reduceRight | special_TA ),
     JS_CFUNC_DEF("fill", 1, js_typed_array_fill ),
-    JS_CFUNC_MAGIC_DEF("find", 1, js_typed_array_find, 0 ),
-    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_typed_array_find, 1 ),
+    JS_CFUNC_MAGIC_DEF("find", 1, js_typed_array_find, special_find ),
+    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_typed_array_find, special_findIndex ),
+    JS_CFUNC_MAGIC_DEF("findLast", 1, js_typed_array_find, special_findLast ),
+    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_typed_array_find, special_findLastIndex ),
     JS_CFUNC_DEF("reverse", 0, js_typed_array_reverse ),
     JS_CFUNC_DEF("slice", 2, js_typed_array_slice ),
     JS_CFUNC_DEF("subarray", 2, js_typed_array_subarray ),
@@ -53062,7 +52850,7 @@ static JSValue js_typed_array_constructor_ta(JSContext *ctx,
 {
     JSObject *p, *src_buffer;
     JSTypedArray *ta;
-    JSValue ctor, obj, buffer;
+    JSValue obj, buffer;
     uint32_t len, i;
     int size_log2;
     JSArrayBuffer *src_abuf, *abuf;
@@ -53079,19 +52867,9 @@ static JSValue js_typed_array_constructor_ta(JSContext *ctx,
     len = p->u.array.count;
     src_buffer = ta->buffer;
     src_abuf = src_buffer->u.array_buffer;
-    if (!src_abuf->shared) {
-        ctor = JS_SpeciesConstructor(ctx, JS_MKPTR(JS_TAG_OBJECT, src_buffer),
-                                     JS_UNDEFINED);
-        if (JS_IsException(ctor))
-            goto fail;
-    } else {
-        /* force ArrayBuffer default constructor */
-        ctor = JS_UNDEFINED;
-    }
     size_log2 = typed_array_size_log2(classid);
-    buffer = js_array_buffer_constructor1(ctx, ctor,
+    buffer = js_array_buffer_constructor1(ctx, JS_UNDEFINED,
                                           (uint64_t)len << size_log2);
-    JS_FreeValue(ctx, ctor);
     if (JS_IsException(buffer))
         goto fail;
     /* necessary because it could have been detached */
@@ -53329,7 +53107,6 @@ static JSValue js_dataview_getValue(JSContext *ctx,
         if (is_swap)
             v = bswap32(v);
         return JS_NewUint32(ctx, v);
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
         {
             uint64_t v;
@@ -53348,7 +53125,6 @@ static JSValue js_dataview_getValue(JSContext *ctx,
             return JS_NewBigUint64(ctx, v);
         }
         break;
-#endif
     case JS_CLASS_FLOAT32_ARRAY:
         {
             union {
@@ -53402,14 +53178,10 @@ static JSValue js_dataview_setValue(JSContext *ctx,
     if (class_id <= JS_CLASS_UINT32_ARRAY) {
         if (JS_ToUint32(ctx, &v, val))
             return JS_EXCEPTION;
-    } else
-#ifdef CONFIG_BIGNUM
-    if (class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
+    } else if (class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
         if (JS_ToBigInt64(ctx, (int64_t *)&v64, val))
             return JS_EXCEPTION;
-    } else
-#endif
-    {
+    } else {
         double d;
         if (JS_ToFloat64(ctx, &d, val))
             return JS_EXCEPTION;
@@ -53457,10 +53229,8 @@ static JSValue js_dataview_setValue(JSContext *ctx,
             v = bswap32(v);
         put_u32(ptr, v);
         break;
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
     case JS_CLASS_BIG_UINT64_ARRAY:
-#endif
     case JS_CLASS_FLOAT64_ARRAY:
         if (is_swap)
             v64 = bswap64(v64);
@@ -53482,10 +53252,8 @@ static const JSCFunctionListEntry js_dataview_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("getUint16", 1, js_dataview_getValue, JS_CLASS_UINT16_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getInt32", 1, js_dataview_getValue, JS_CLASS_INT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getUint32", 1, js_dataview_getValue, JS_CLASS_UINT32_ARRAY ),
-#ifdef CONFIG_BIGNUM
     JS_CFUNC_MAGIC_DEF("getBigInt64", 1, js_dataview_getValue, JS_CLASS_BIG_INT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getBigUint64", 1, js_dataview_getValue, JS_CLASS_BIG_UINT64_ARRAY ),
-#endif
     JS_CFUNC_MAGIC_DEF("getFloat32", 1, js_dataview_getValue, JS_CLASS_FLOAT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getFloat64", 1, js_dataview_getValue, JS_CLASS_FLOAT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setInt8", 2, js_dataview_setValue, JS_CLASS_INT8_ARRAY ),
@@ -53494,10 +53262,8 @@ static const JSCFunctionListEntry js_dataview_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("setUint16", 2, js_dataview_setValue, JS_CLASS_UINT16_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setInt32", 2, js_dataview_setValue, JS_CLASS_INT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setUint32", 2, js_dataview_setValue, JS_CLASS_UINT32_ARRAY ),
-#ifdef CONFIG_BIGNUM
     JS_CFUNC_MAGIC_DEF("setBigInt64", 2, js_dataview_setValue, JS_CLASS_BIG_INT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setBigUint64", 2, js_dataview_setValue, JS_CLASS_BIG_UINT64_ARRAY ),
-#endif
     JS_CFUNC_MAGIC_DEF("setFloat32", 2, js_dataview_setValue, JS_CLASS_FLOAT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setFloat64", 2, js_dataview_setValue, JS_CLASS_FLOAT64_ARRAY ),
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "DataView", JS_PROP_CONFIGURABLE ),
@@ -53534,20 +53300,12 @@ static void *js_atomics_get_ptr(JSContext *ctx,
     if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         goto fail;
     p = JS_VALUE_GET_OBJ(obj);
-#ifdef CONFIG_BIGNUM
     if (is_waitable)
         err = (p->class_id != JS_CLASS_INT32_ARRAY &&
                p->class_id != JS_CLASS_BIG_INT64_ARRAY);
     else
         err = !(p->class_id >= JS_CLASS_INT8_ARRAY &&
                 p->class_id <= JS_CLASS_BIG_UINT64_ARRAY);
-#else
-    if (is_waitable)
-        err = (p->class_id != JS_CLASS_INT32_ARRAY);
-    else
-        err = !(p->class_id >= JS_CLASS_INT8_ARRAY &&
-                p->class_id <= JS_CLASS_UINT32_ARRAY);
-#endif
     if (err) {
     fail:
         JS_ThrowTypeError(ctx, "integer TypedArray expected");
@@ -53589,11 +53347,7 @@ static JSValue js_atomics_op(JSContext *ctx,
                              int argc, JSValueConst *argv, int op)
 {
     int size_log2;
-#ifdef CONFIG_BIGNUM
     uint64_t v, a, rep_val;
-#else
-    uint32_t v, a, rep_val;
-#endif
     void *ptr;
     JSValue ret;
     JSClassID class_id;
@@ -53607,7 +53361,6 @@ static JSValue js_atomics_op(JSContext *ctx,
     if (op == ATOMICS_OP_LOAD) {
         v = 0;
     } else {
-#ifdef CONFIG_BIGNUM
         if (size_log2 == 3) {
             int64_t v64;
             if (JS_ToBigInt64(ctx, &v64, argv[2]))
@@ -53618,9 +53371,7 @@ static JSValue js_atomics_op(JSContext *ctx,
                     return JS_EXCEPTION;
                 rep_val = v64;
             }
-        } else
-#endif
-        {
+        } else {
                 uint32_t v32;
                 if (JS_ToUint32(ctx, &v32, argv[2]))
                     return JS_EXCEPTION;
@@ -53637,7 +53388,6 @@ static JSValue js_atomics_op(JSContext *ctx,
 
    switch(op | (size_log2 << 3)) {
             
-#ifdef CONFIG_BIGNUM
 #define OP(op_name, func_name)                          \
     case ATOMICS_OP_ ## op_name | (0 << 3):             \
        a = func_name((_Atomic(uint8_t) *)ptr, v);       \
@@ -53651,18 +53401,7 @@ static JSValue js_atomics_op(JSContext *ctx,
     case ATOMICS_OP_ ## op_name | (3 << 3):             \
         a = func_name((_Atomic(uint64_t) *)ptr, v);     \
         break;
-#else
-#define OP(op_name, func_name)                          \
-    case ATOMICS_OP_ ## op_name | (0 << 3):             \
-       a = func_name((_Atomic(uint8_t) *)ptr, v);       \
-       break;                                           \
-    case ATOMICS_OP_ ## op_name | (1 << 3):             \
-        a = func_name((_Atomic(uint16_t) *)ptr, v);     \
-        break;                                          \
-    case ATOMICS_OP_ ## op_name | (2 << 3):             \
-        a = func_name((_Atomic(uint32_t) *)ptr, v);     \
-        break;
-#endif
+       
         OP(ADD, atomic_fetch_add)
         OP(AND, atomic_fetch_and)
         OP(OR, atomic_fetch_or)
@@ -53680,11 +53419,9 @@ static JSValue js_atomics_op(JSContext *ctx,
     case ATOMICS_OP_LOAD | (2 << 3):
         a = atomic_load((_Atomic(uint32_t) *)ptr);
         break;
-#ifdef CONFIG_BIGNUM
     case ATOMICS_OP_LOAD | (3 << 3):
         a = atomic_load((_Atomic(uint64_t) *)ptr);
         break;
-#endif
         
     case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
         {
@@ -53707,7 +53444,6 @@ static JSValue js_atomics_op(JSContext *ctx,
             a = v1;
         }
         break;
-#ifdef CONFIG_BIGNUM
     case ATOMICS_OP_COMPARE_EXCHANGE | (3 << 3):
         {
             uint64_t v1 = v;
@@ -53715,7 +53451,6 @@ static JSValue js_atomics_op(JSContext *ctx,
             a = v1;
         }
         break;
-#endif
     default:
         abort();
     }
@@ -53740,14 +53475,12 @@ static JSValue js_atomics_op(JSContext *ctx,
     case JS_CLASS_UINT32_ARRAY:
         ret = JS_NewUint32(ctx, a);
         break;
-#ifdef CONFIG_BIGNUM
     case JS_CLASS_BIG_INT64_ARRAY:
         ret = JS_NewBigInt64(ctx, a);
         break;
     case JS_CLASS_BIG_UINT64_ARRAY:
         ret = JS_NewBigUint64(ctx, a);
         break;
-#endif
     default:
         abort();
     }
@@ -53767,7 +53500,6 @@ static JSValue js_atomics_store(JSContext *ctx,
                              argv[0], argv[1], 0);
     if (!ptr)
         return JS_EXCEPTION;
-#ifdef CONFIG_BIGNUM
     if (size_log2 == 3) {
         int64_t v64;
         ret = JS_ToBigIntValueFree(ctx, JS_DupValue(ctx, argv[2]));
@@ -53780,9 +53512,7 @@ static JSValue js_atomics_store(JSContext *ctx,
         if (abuf->detached)
             return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
         atomic_store((_Atomic(uint64_t) *)ptr, v64);
-    } else
-#endif
-    {
+    } else {
         uint32_t v;
         /* XXX: spec, would be simpler to return the written value */
         ret = JS_ToIntegerFree(ctx, JS_DupValue(ctx, argv[2]));
@@ -53818,11 +53548,7 @@ static JSValue js_atomics_isLockFree(JSContext *ctx,
     int v, ret;
     if (JS_ToInt32Sat(ctx, &v, argv[0]))
         return JS_EXCEPTION;
-    ret = (v == 1 || v == 2 || v == 4
-#ifdef CONFIG_BIGNUM
-           || v == 8
-#endif
-           );
+    ret = (v == 1 || v == 2 || v == 4 || v == 8);
     return JS_NewBool(ctx, ret);
 }
 
@@ -53854,13 +53580,10 @@ static JSValue js_atomics_wait(JSContext *ctx,
                              argv[0], argv[1], 2);
     if (!ptr)
         return JS_EXCEPTION;
-#ifdef CONFIG_BIGNUM
     if (size_log2 == 3) {
         if (JS_ToBigInt64(ctx, &v, argv[2]))
             return JS_EXCEPTION;
-    } else
-#endif
-    {        
+    } else {        
         if (JS_ToInt32(ctx, &v32, argv[2]))
             return JS_EXCEPTION;
         v = v32;
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 215e7b2fc9..296137e741 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -734,13 +734,13 @@ JSValue JS_GetPropertyStr(JSContext *ctx, JSValueConst this_obj,
 JSValue JS_GetPropertyUint32(JSContext *ctx, JSValueConst this_obj,
                              uint32_t idx);
 
-int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
-                           JSAtom prop, JSValue val,
+int JS_SetPropertyInternal(JSContext *ctx, JSValueConst obj,
+                           JSAtom prop, JSValue val, JSValueConst this_obj,
                            int flags);
 static inline int JS_SetProperty(JSContext *ctx, JSValueConst this_obj,
                                  JSAtom prop, JSValue val)
 {
-    return JS_SetPropertyInternal(ctx, this_obj, prop, val, JS_PROP_THROW);
+    return JS_SetPropertyInternal(ctx, this_obj, prop, val, this_obj, JS_PROP_THROW);
 }
 int JS_SetPropertyUint32(JSContext *ctx, JSValueConst this_obj,
                          uint32_t idx, JSValue val);

From 0c00c48895919fc02da3f191a2da06addeb07f09 Mon Sep 17 00:00:00 2001
From: ftk <ftk@users.noreply.github.com>
Date: Thu, 21 Dec 2023 15:18:36 +0300
Subject: [PATCH 184/185] qjs.cpp: port script type autodetection and a few
 other features from quickjs/qjs.c interpreter should fix some issues with
 quickjs tests failing (#65)

---
 qjs.cpp | 83 ++++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 71 insertions(+), 12 deletions(-)

diff --git a/qjs.cpp b/qjs.cpp
index 70e215c6f5..79fd87f8ba 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -2,23 +2,65 @@
 #include "quickjs/quickjs-libc.h"
 
 #include <iostream>
+#include <string_view>
+
+static bool bignum_ext = false;
+
+/* also used to initialize the worker context */
+static JSContext *JS_NewCustomContext(JSRuntime *rt)
+{
+    JSContext *ctx;
+    ctx = JS_NewContext(rt);
+    if (!ctx)
+        return NULL;
+    if (bignum_ext) {
+        JS_AddIntrinsicBigFloat(ctx);
+        JS_AddIntrinsicBigDecimal(ctx);
+        JS_AddIntrinsicOperators(ctx);
+        JS_EnableBignumExt(ctx, true);
+    }
+    /* system modules */
+    js_init_module_std(ctx, "std");
+    js_init_module_os(ctx, "os");
+    return ctx;
+}
 
 int main(int argc, char ** argv)
 {
-    using namespace qjs;
+    qjs::Runtime runtime;
+    auto rt = runtime.rt;
+
+    js_std_set_worker_new_context_func(JS_NewCustomContext);
+    js_std_init_handlers(rt);
 
-    Runtime runtime;
-    Context context(runtime);
+    /* loader for ES6 modules */
+    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
 
-    auto rt = runtime.rt;
+    qjs::Context context(JS_NewCustomContext(rt));
     auto ctx = context.ctx;
 
-    js_std_init_handlers(rt);
-    js_std_add_helpers(ctx, argc - 1, argv + 1);
+    int flags = -1;
+    int optind = 1;
+    // load as ES6 module
+    if(argv[optind] && (argv[optind] == std::string_view{"-m"} || argv[optind] == std::string_view{"--module"}))
+    {
+        flags = JS_EVAL_TYPE_MODULE;
+        optind++;
+    }
+    // load as ES6 script
+    else if(argv[optind] && argv[optind] == std::string_view{"--script"})
+    {
+        flags = JS_EVAL_TYPE_GLOBAL;
+        optind++;
+    }
+    // enable bignum
+    if(argv[optind] && argv[optind] == std::string_view{"--bignum"})
+    {
+        bignum_ext = true;
+        optind++;
+    }
 
-    /* system modules */
-    js_init_module_std(ctx, "std");
-    js_init_module_os(ctx, "os");
+    js_std_add_helpers(ctx, argc - optind, argv + optind);
 
     /* make 'std' and 'os' visible to non module code */
     context.eval(R"xxx(
@@ -28,12 +70,29 @@ int main(int argc, char ** argv)
         globalThis.os = os;
     )xxx", "<input>", JS_EVAL_TYPE_MODULE);
 
+
     try
     {
-        if(argv[1])
-            context.evalFile(argv[1], JS_EVAL_TYPE_MODULE);
+        if(auto filename = argv[optind])
+        {
+            auto buf = qjs::detail::readFile(filename);
+            if (!buf)
+                throw std::runtime_error{std::string{"can't read file: "} + filename};
+
+            // autodetect file type
+            if(flags == -1)
+                flags = JS_DetectModule(buf->data(), buf->size()) ? JS_EVAL_TYPE_MODULE : JS_EVAL_TYPE_GLOBAL;
+
+            context.eval(*buf, filename, flags);
+        }
+        else
+        {
+            std::cout << argv[0] << " [--module|--script] [--bignum] <filename>" << std::endl;
+            js_std_free_handlers(rt);
+            return 1;
+        }
     }
-    catch(exception & e)
+    catch(qjs::exception & e)
     {
         auto exc = e.get();
         std::cerr << (exc.isError() ? "Error: " : "Throw: ") << (std::string)exc << std::endl;

From 681988e43bd2e44f8d4c6537efc957ebf6fc6f87 Mon Sep 17 00:00:00 2001
From: nitram <8461554+2bam@users.noreply.github.com>
Date: Fri, 4 Jul 2025 18:16:10 +0200
Subject: [PATCH 185/185] Update QuickJS dependency to version 2025-04-26.

Fix quickjspp code and cmake issues.
Update git patches to match new version of quicks.
Remove bignum support (removed from QuickJS).
Fix module loading to keep old API semantics.
- In new QuickJS module load fails with a rejected promise
- Make failure in a module load always throws an qjs::exception.
- This is needed to pass the "exception" unit test.
Add QuickJS LICENCE file.

Update QuickJS to match https://github.com/bellard/quickjs/ master.
Commit date Sat Jun 28 17:41:58 2025 +0200
Commit hash 458c34d29d0d262f824ea1c0e01aa0e3790669da
---
 qjs.cpp                                       |    19 +-
 quickjs/CMakeLists.txt                        |    10 +-
 quickjs/LICENSE                               |    22 +
 quickjs/VERSION                               |     2 +-
 quickjs/cutils.c                              |     8 +-
 quickjs/cutils.h                              |   148 +-
 quickjs/dtoa.c                                |  1620 ++
 quickjs/dtoa.h                                |    83 +
 quickjs/libbf.c                               |  8473 -------
 quickjs/libbf.h                               |   535 -
 quickjs/libregexp-opcode.h                    |    17 +-
 quickjs/libregexp.c                           |  1552 +-
 quickjs/libregexp.h                           |    55 +-
 quickjs/libunicode-table.h                    |  3977 +--
 quickjs/libunicode.c                          |   935 +-
 quickjs/libunicode.h                          |   116 +-
 quickjs/list.h                                |     7 +-
 quickjs/patches/2025-04-26-freebsd.patch      |    14 +
 ...atch => 2025-04-26-getclassid-const.patch} |    31 +-
 ...ropertyvalue_uninitialized_read_fix.patch} |    10 +-
 ...h => 2025-04-26-unhandled_rejection.patch} |    22 +-
 quickjs/patches/freebsd.patch                 |    18 -
 quickjs/quickjs-atom.h                        |    43 +-
 quickjs/quickjs-libc.c                        |  1135 +-
 quickjs/quickjs-libc.h                        |    13 +-
 quickjs/quickjs-opcode.h                      |    35 +-
 quickjs/quickjs.c                             | 20636 +++++++++-------
 quickjs/quickjs.h                             |   224 +-
 quickjspp.hpp                                 |    27 +-
 test/class.cpp                                |     2 +-
 30 files changed, 18590 insertions(+), 21199 deletions(-)
 create mode 100644 quickjs/LICENSE
 create mode 100644 quickjs/dtoa.c
 create mode 100644 quickjs/dtoa.h
 delete mode 100644 quickjs/libbf.c
 delete mode 100644 quickjs/libbf.h
 create mode 100644 quickjs/patches/2025-04-26-freebsd.patch
 rename quickjs/patches/{getclassid.patch => 2025-04-26-getclassid-const.patch} (51%)
 rename quickjs/patches/{getpropertyvalue_uninitialized_read_fix.patch => 2025-04-26-getpropertyvalue_uninitialized_read_fix.patch} (61%)
 rename quickjs/patches/{unhandled_rejection.patch => 2025-04-26-unhandled_rejection.patch} (84%)
 delete mode 100644 quickjs/patches/freebsd.patch

diff --git a/qjs.cpp b/qjs.cpp
index 79fd87f8ba..83def9f467 100644
--- a/qjs.cpp
+++ b/qjs.cpp
@@ -4,8 +4,6 @@
 #include <iostream>
 #include <string_view>
 
-static bool bignum_ext = false;
-
 /* also used to initialize the worker context */
 static JSContext *JS_NewCustomContext(JSRuntime *rt)
 {
@@ -13,12 +11,7 @@ static JSContext *JS_NewCustomContext(JSRuntime *rt)
     ctx = JS_NewContext(rt);
     if (!ctx)
         return NULL;
-    if (bignum_ext) {
-        JS_AddIntrinsicBigFloat(ctx);
-        JS_AddIntrinsicBigDecimal(ctx);
-        JS_AddIntrinsicOperators(ctx);
-        JS_EnableBignumExt(ctx, true);
-    }
+
     /* system modules */
     js_init_module_std(ctx, "std");
     js_init_module_os(ctx, "os");
@@ -34,7 +27,7 @@ int main(int argc, char ** argv)
     js_std_init_handlers(rt);
 
     /* loader for ES6 modules */
-    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
+    JS_SetModuleLoaderFunc2(rt, NULL, js_module_loader, NULL, NULL);
 
     qjs::Context context(JS_NewCustomContext(rt));
     auto ctx = context.ctx;
@@ -53,12 +46,6 @@ int main(int argc, char ** argv)
         flags = JS_EVAL_TYPE_GLOBAL;
         optind++;
     }
-    // enable bignum
-    if(argv[optind] && argv[optind] == std::string_view{"--bignum"})
-    {
-        bignum_ext = true;
-        optind++;
-    }
 
     js_std_add_helpers(ctx, argc - optind, argv + optind);
 
@@ -87,7 +74,7 @@ int main(int argc, char ** argv)
         }
         else
         {
-            std::cout << argv[0] << " [--module|--script] [--bignum] <filename>" << std::endl;
+            std::cout << argv[0] << " [--module|--script] <filename>" << std::endl;
             js_std_free_handlers(rt);
             return 1;
         }
diff --git a/quickjs/CMakeLists.txt b/quickjs/CMakeLists.txt
index 2664223d55..f220106bc8 100644
--- a/quickjs/CMakeLists.txt
+++ b/quickjs/CMakeLists.txt
@@ -2,7 +2,15 @@ project(quickjs LANGUAGES C)
 
 file(STRINGS VERSION version)
 
-set(quickjs_src quickjs.c libbf.c libunicode.c libregexp.c cutils.c quickjs-libc.c)
+set(quickjs_src 
+  cutils.c
+  dtoa.c
+  libregexp.c
+  libunicode.c
+  quickjs-libc.c
+  quickjs.c
+)
+
 set(quickjs_def CONFIG_VERSION="${version}" _GNU_SOURCE CONFIG_BIGNUM)
 
 add_library(quickjs ${quickjs_src})
diff --git a/quickjs/LICENSE b/quickjs/LICENSE
new file mode 100644
index 0000000000..2cf449dd3e
--- /dev/null
+++ b/quickjs/LICENSE
@@ -0,0 +1,22 @@
+QuickJS Javascript Engine
+
+Copyright (c) 2017-2021 Fabrice Bellard
+Copyright (c) 2017-2021 Charlie Gordon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/quickjs/VERSION b/quickjs/VERSION
index 08d122201d..c76e76d1f1 100644
--- a/quickjs/VERSION
+++ b/quickjs/VERSION
@@ -1 +1 @@
-2023-12-09
+2025-04-26
diff --git a/quickjs/cutils.c b/quickjs/cutils.c
index a02fb76886..c038cf44ca 100644
--- a/quickjs/cutils.c
+++ b/quickjs/cutils.c
@@ -1,6 +1,6 @@
 /*
  * C utilities
- * 
+ *
  * Copyright (c) 2017 Fabrice Bellard
  * Copyright (c) 2018 Charlie Gordon
  *
@@ -140,7 +140,7 @@ int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
         if (dbuf_realloc(s, s->size + len))
             return -1;
     }
-    memcpy(s->buf + s->size, data, len);
+    memcpy_no_ub(s->buf + s->size, data, len);
     s->size += len;
     return 0;
 }
@@ -172,10 +172,12 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
     va_list ap;
     char buf[128];
     int len;
-    
+
     va_start(ap, fmt);
     len = vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
+    if (len < 0)
+        return -1;
     if (len < sizeof(buf)) {
         /* fast case */
         return dbuf_put(s, (uint8_t *)buf, len);
diff --git a/quickjs/cutils.h b/quickjs/cutils.h
index 31f7cd84a0..9fcb7a6079 100644
--- a/quickjs/cutils.h
+++ b/quickjs/cutils.h
@@ -1,6 +1,6 @@
 /*
  * C utilities
- * 
+ *
  * Copyright (c) 2017 Fabrice Bellard
  * Copyright (c) 2018 Charlie Gordon
  *
@@ -26,11 +26,9 @@
 #define CUTILS_H
 
 #include <stdlib.h>
+#include <string.h>
 #include <inttypes.h>
 
-/* set if CPU is big endian */
-#undef WORDS_BIGENDIAN
-
 #define likely(x)       __builtin_expect(!!(x), 1)
 #define unlikely(x)     __builtin_expect(!!(x), 0)
 #define force_inline inline __attribute__((always_inline))
@@ -48,6 +46,16 @@
 #ifndef countof
 #define countof(x) (sizeof(x) / sizeof((x)[0]))
 #endif
+#ifndef container_of
+/* return the pointer of type 'type *' containing 'ptr' as field 'member' */
+#define container_of(ptr, type, member) ((type *)((uint8_t *)(ptr) - offsetof(type, member)))
+#endif
+
+#if !defined(_MSC_VER) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#define minimum_length(n)  static n
+#else
+#define minimum_length(n)  n
+#endif
 
 typedef int BOOL;
 
@@ -63,6 +71,12 @@ char *pstrcat(char *buf, int buf_size, const char *s);
 int strstart(const char *str, const char *val, const char **ptr);
 int has_suffix(const char *str, const char *suffix);
 
+/* Prevent UB when n == 0 and (src == NULL or dest == NULL) */
+static inline void memcpy_no_ub(void *dest, const void *src, size_t n) {
+    if (n)
+        memcpy(dest, src, n);
+}
+
 static inline int max_int(int a, int b)
 {
     if (a > b)
@@ -207,28 +221,34 @@ static inline void put_u8(uint8_t *tab, uint8_t val)
     *tab = val;
 }
 
+#ifndef bswap16
 static inline uint16_t bswap16(uint16_t x)
 {
     return (x >> 8) | (x << 8);
 }
+#endif
 
+#ifndef bswap32
 static inline uint32_t bswap32(uint32_t v)
 {
     return ((v & 0xff000000) >> 24) | ((v & 0x00ff0000) >>  8) |
         ((v & 0x0000ff00) <<  8) | ((v & 0x000000ff) << 24);
 }
+#endif
 
+#ifndef bswap64
 static inline uint64_t bswap64(uint64_t v)
 {
-    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) | 
-        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) | 
-        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) | 
-        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) | 
-        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) | 
-        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) | 
-        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) | 
+    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
+        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
+        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
+        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
+        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
+        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
+        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
         ((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
 }
+#endif
 
 /* XXX: should take an extra argument to pass slack information to the caller */
 typedef void *DynBufReallocFunc(void *opaque, void *ptr, size_t size);
@@ -278,6 +298,36 @@ static inline void dbuf_set_error(DynBuf *s)
 int unicode_to_utf8(uint8_t *buf, unsigned int c);
 int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp);
 
+static inline BOOL is_surrogate(uint32_t c)
+{
+    return (c >> 11) == (0xD800 >> 11); // 0xD800-0xDFFF
+}
+
+static inline BOOL is_hi_surrogate(uint32_t c)
+{
+    return (c >> 10) == (0xD800 >> 10); // 0xD800-0xDBFF
+}
+
+static inline BOOL is_lo_surrogate(uint32_t c)
+{
+    return (c >> 10) == (0xDC00 >> 10); // 0xDC00-0xDFFF
+}
+
+static inline uint32_t get_hi_surrogate(uint32_t c)
+{
+    return (c >> 10) - (0x10000 >> 10) + 0xD800;
+}
+
+static inline uint32_t get_lo_surrogate(uint32_t c)
+{
+    return (c & 0x3FF) | 0xDC00;
+}
+
+static inline uint32_t from_surrogate(uint32_t hi, uint32_t lo)
+{
+    return 0x10000 + 0x400 * (hi - 0xD800) + (lo - 0xDC00);
+}
+
 static inline int from_hex(int c)
 {
     if (c >= '0' && c <= '9')
@@ -294,4 +344,80 @@ void rqsort(void *base, size_t nmemb, size_t size,
             int (*cmp)(const void *, const void *, void *),
             void *arg);
 
+static inline uint64_t float64_as_uint64(double d)
+{
+    union {
+        double d;
+        uint64_t u64;
+    } u;
+    u.d = d;
+    return u.u64;
+}
+
+static inline double uint64_as_float64(uint64_t u64)
+{
+    union {
+        double d;
+        uint64_t u64;
+    } u;
+    u.u64 = u64;
+    return u.d;
+}
+
+static inline double fromfp16(uint16_t v)
+{
+    double d;
+    uint32_t v1;
+    v1 = v & 0x7fff;
+    if (unlikely(v1 >= 0x7c00))
+        v1 += 0x1f8000; /* NaN or infinity */
+    d = uint64_as_float64(((uint64_t)(v >> 15) << 63) | ((uint64_t)v1 << (52 - 10)));
+    return d * 0x1p1008;
+}
+
+static inline uint16_t tofp16(double d)
+{
+    uint64_t a, addend;
+    uint32_t v, sgn;
+    int shift;
+    
+    a = float64_as_uint64(d);
+    sgn = a >> 63;
+    a = a & 0x7fffffffffffffff;
+    if (unlikely(a > 0x7ff0000000000000)) {
+        /* nan */
+        v = 0x7c01;
+    } else if (a < 0x3f10000000000000) { /* 0x1p-14 */
+        /* subnormal f16 number or zero */
+        if (a <= 0x3e60000000000000) { /* 0x1p-25 */
+            v = 0x0000; /* zero */
+        } else {
+            shift = 1051 - (a >> 52);
+            a = ((uint64_t)1 << 52) | (a & (((uint64_t)1 << 52) - 1));
+            addend = ((a >> shift) & 1) + (((uint64_t)1 << (shift - 1)) - 1);
+            v = (a + addend) >> shift;
+        }
+    } else {
+        /* normal number or infinity */
+        a -= 0x3f00000000000000; /* adjust the exponent */
+        /* round */
+        addend = ((a >> (52 - 10)) & 1) + (((uint64_t)1 << (52 - 11)) - 1);
+        v = (a + addend) >> (52 - 10);
+        /* overflow ? */
+        if (unlikely(v > 0x7c00))
+            v = 0x7c00;
+    }
+    return v | (sgn << 15);
+}
+
+static inline int isfp16nan(uint16_t v)
+{
+    return (v & 0x7FFF) > 0x7C00;
+}
+
+static inline int isfp16zero(uint16_t v)
+{
+    return (v & 0x7FFF) == 0;
+}
+
 #endif  /* CUTILS_H */
diff --git a/quickjs/dtoa.c b/quickjs/dtoa.c
new file mode 100644
index 0000000000..ac1be8d8e1
--- /dev/null
+++ b/quickjs/dtoa.c
@@ -0,0 +1,1620 @@
+/*
+ * Tiny float64 printing and parsing library
+ *
+ * Copyright (c) 2024 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <inttypes.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <math.h>
+#include <setjmp.h>
+
+#include "cutils.h"
+#include "dtoa.h"
+
+/* 
+   TODO:
+   - test n_digits=101 instead of 100
+   - simplify subnormal handling
+   - reduce max memory usage
+   - free format: could add shortcut if exact result
+   - use 64 bit limb_t when possible
+   - use another algorithm for free format dtoa in base 10 (ryu ?)
+*/
+
+#define USE_POW5_TABLE
+/* use fast path to print small integers in free format */
+#define USE_FAST_INT
+
+#define LIMB_LOG2_BITS 5
+
+#define LIMB_BITS (1 << LIMB_LOG2_BITS)
+
+typedef int32_t slimb_t;
+typedef uint32_t limb_t;
+typedef uint64_t dlimb_t;
+
+#define LIMB_DIGITS 9
+
+#define JS_RADIX_MAX 36
+
+#define DBIGNUM_LEN_MAX 52 /* ~ 2^(1072+53)*36^100 (dtoa) */
+#define MANT_LEN_MAX 18 /* < 36^100 */
+
+typedef intptr_t mp_size_t;
+
+/* the represented number is sum(i, tab[i]*2^(LIMB_BITS * i)) */
+typedef struct {
+    int len; /* >= 1 */
+    limb_t tab[];
+} mpb_t;
+
+static limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n)
+{
+    size_t i;
+    limb_t k, a;
+
+    k=b;
+    for(i=0;i<n;i++) {
+        if (k == 0)
+            break;
+        a = tab[i] + k;
+        k = (a < k);
+        tab[i] = a;
+    }
+    return k;
+}
+
+/* tabr[] = taba[] * b + l. Return the high carry */
+static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n, 
+                      limb_t b, limb_t l)
+{
+    limb_t i;
+    dlimb_t t;
+
+    for(i = 0; i < n; i++) {
+        t = (dlimb_t)taba[i] * (dlimb_t)b + l;
+        tabr[i] = t;
+        l = t >> LIMB_BITS;
+    }
+    return l;
+}
+
+/* WARNING: d must be >= 2^(LIMB_BITS-1) */
+static inline limb_t udiv1norm_init(limb_t d)
+{
+    limb_t a0, a1;
+    a1 = -d - 1;
+    a0 = -1;
+    return (((dlimb_t)a1 << LIMB_BITS) | a0) / d;
+}
+
+/* return the quotient and the remainder in '*pr'of 'a1*2^LIMB_BITS+a0
+   / d' with 0 <= a1 < d. */
+static inline limb_t udiv1norm(limb_t *pr, limb_t a1, limb_t a0,
+                                limb_t d, limb_t d_inv)
+{
+    limb_t n1m, n_adj, q, r, ah;
+    dlimb_t a;
+    n1m = ((slimb_t)a0 >> (LIMB_BITS - 1));
+    n_adj = a0 + (n1m & d);
+    a = (dlimb_t)d_inv * (a1 - n1m) + n_adj;
+    q = (a >> LIMB_BITS) + a1;
+    /* compute a - q * r and update q so that the remainder is between
+       0 and d - 1 */
+    a = ((dlimb_t)a1 << LIMB_BITS) | a0;
+    a = a - (dlimb_t)q * d - d;
+    ah = a >> LIMB_BITS;
+    q += 1 + ah;
+    r = (limb_t)a + (ah & d);
+    *pr = r;
+    return q;
+}
+
+static limb_t mp_div1(limb_t *tabr, const limb_t *taba, limb_t n,
+                      limb_t b, limb_t r)
+{
+    slimb_t i;
+    dlimb_t a1;
+    for(i = n - 1; i >= 0; i--) {
+        a1 = ((dlimb_t)r << LIMB_BITS) | taba[i];
+        tabr[i] = a1 / b;
+        r = a1 % b;
+    }
+    return r;
+}
+
+/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift). 
+   1 <= shift <= LIMB_BITS - 1 */
+static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+                     int shift, limb_t high)
+{
+    mp_size_t i;
+    limb_t l, a;
+
+    assert(shift >= 1 && shift < LIMB_BITS);
+    l = high;
+    for(i = n - 1; i >= 0; i--) {
+        a = tab[i];
+        tab_r[i] = (a >> shift) | (l << (LIMB_BITS - shift));
+        l = a;
+    }
+    return l & (((limb_t)1 << shift) - 1);
+}
+
+/* r = (a << shift) + low. 1 <= shift <= LIMB_BITS - 1, 0 <= low <
+   2^shift. */
+static limb_t mp_shl(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+              int shift, limb_t low)
+{
+    mp_size_t i;
+    limb_t l, a;
+
+    assert(shift >= 1 && shift < LIMB_BITS);
+    l = low;
+    for(i = 0; i < n; i++) {
+        a = tab[i];
+        tab_r[i] = (a << shift) | l;
+        l = (a >> (LIMB_BITS - shift)); 
+    }
+    return l;
+}
+
+static no_inline limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
+                                    limb_t b, limb_t r, limb_t b_inv, int shift)
+{
+    slimb_t i;
+
+    if (shift != 0) {
+        r = (r << shift) | mp_shl(tabr, taba, n, shift, 0);
+    }
+    for(i = n - 1; i >= 0; i--) {
+        tabr[i] = udiv1norm(&r, r, taba[i], b, b_inv);
+    }
+    r >>= shift;
+    return r;
+}
+
+static __maybe_unused void mpb_dump(const char *str, const mpb_t *a)
+{
+    int i;
+    
+    printf("%s= 0x", str);
+    for(i = a->len - 1; i >= 0; i--) {
+        printf("%08x", a->tab[i]);
+        if (i != 0)
+            printf("_");
+    }
+    printf("\n");
+}
+
+static void mpb_renorm(mpb_t *r)
+{
+    while (r->len > 1 && r->tab[r->len - 1] == 0)
+        r->len--;
+}
+
+#ifdef USE_POW5_TABLE
+static const uint32_t pow5_table[17] = {
+    0x00000005, 0x00000019, 0x0000007d, 0x00000271, 
+    0x00000c35, 0x00003d09, 0x0001312d, 0x0005f5e1, 
+    0x001dcd65, 0x009502f9, 0x02e90edd, 0x0e8d4a51, 
+    0x48c27395, 0x6bcc41e9, 0x1afd498d, 0x86f26fc1, 
+    0xa2bc2ec5, 
+};
+
+static const uint8_t pow5h_table[4] = {
+    0x00000001, 0x00000007, 0x00000023, 0x000000b1, 
+};
+
+static const uint32_t pow5_inv_table[13] = {
+    0x99999999, 0x47ae147a, 0x0624dd2f, 0xa36e2eb1,
+    0x4f8b588e, 0x0c6f7a0b, 0xad7f29ab, 0x5798ee23,
+    0x12e0be82, 0xb7cdfd9d, 0x5fd7fe17, 0x19799812,
+    0xc25c2684,
+};
+#endif
+
+/* return a^b */
+static uint64_t pow_ui(uint32_t a, uint32_t b)
+{
+    int i, n_bits;
+    uint64_t r;
+    if (b == 0)
+        return 1;
+    if (b == 1)
+        return a;
+#ifdef USE_POW5_TABLE
+    if ((a == 5 || a == 10) && b <= 17) {
+        r = pow5_table[b - 1];
+        if (b >= 14) {
+            r |= (uint64_t)pow5h_table[b - 14] << 32;
+        }
+        if (a == 10)
+            r <<= b;
+        return r;
+    }
+#endif
+    r = a;
+    n_bits = 32 - clz32(b);
+    for(i = n_bits - 2; i >= 0; i--) {
+        r *= r;
+        if ((b >> i) & 1)
+            r *= a;
+    }
+    return r;
+}
+
+static uint32_t pow_ui_inv(uint32_t *pr_inv, int *pshift, uint32_t a, uint32_t b)
+{
+    uint32_t r_inv, r;
+    int shift;
+#ifdef USE_POW5_TABLE
+    if (a == 5 && b >= 1 && b <= 13) {
+        r = pow5_table[b - 1];
+        shift = clz32(r);
+        r <<= shift;
+        r_inv = pow5_inv_table[b - 1];
+    } else
+#endif
+    {
+        r = pow_ui(a, b);
+        shift = clz32(r);
+        r <<= shift;
+        r_inv = udiv1norm_init(r);
+    }
+    *pshift = shift;
+    *pr_inv = r_inv;
+    return r;
+}
+
+enum {
+    JS_RNDN, /* round to nearest, ties to even */
+    JS_RNDNA, /* round to nearest, ties away from zero */
+    JS_RNDZ,
+};
+
+static int mpb_get_bit(const mpb_t *r, int k)
+{
+    int l;
+    
+    l = (unsigned)k / LIMB_BITS;
+    k = k & (LIMB_BITS - 1);
+    if (l >= r->len)
+        return 0;
+    else
+        return (r->tab[l] >> k) & 1;
+}
+
+/* compute round(r / 2^shift). 'shift' can be negative */
+static void mpb_shr_round(mpb_t *r, int shift, int rnd_mode)
+{
+    int l, i;
+
+    if (shift == 0)
+        return;
+    if (shift < 0) {
+        shift = -shift;
+        l = (unsigned)shift / LIMB_BITS;
+        shift = shift & (LIMB_BITS - 1);
+        if (shift != 0) {
+            r->tab[r->len] = mp_shl(r->tab, r->tab, r->len, shift, 0);
+            r->len++;
+            mpb_renorm(r);
+        }
+        if (l > 0) {
+            for(i = r->len - 1; i >= 0; i--)
+                r->tab[i + l] = r->tab[i];
+            for(i = 0; i < l; i++)
+                r->tab[i] = 0;
+            r->len += l;
+        }
+    } else {
+        limb_t bit1, bit2;
+        int k, add_one;
+        
+        switch(rnd_mode) {
+        default:
+        case JS_RNDZ:
+            add_one = 0;
+            break;
+        case JS_RNDN:
+        case JS_RNDNA:
+            bit1 = mpb_get_bit(r, shift - 1);
+            if (bit1) {
+                if (rnd_mode == JS_RNDNA) {
+                    bit2 = 1;
+                } else {
+                    /* bit2 = oring of all the bits after bit1 */
+                    bit2 = 0;
+                    if (shift >= 2) {
+                        k = shift - 1;
+                        l = (unsigned)k / LIMB_BITS;
+                        k = k & (LIMB_BITS - 1);
+                        for(i = 0; i < min_int(l, r->len); i++)
+                            bit2 |= r->tab[i];
+                        if (l < r->len)
+                            bit2 |= r->tab[l] & (((limb_t)1 << k) - 1);
+                    }
+                }
+                if (bit2) {
+                    add_one = 1;
+                } else {
+                    /* round to even */
+                    add_one = mpb_get_bit(r, shift);
+                }
+            } else {
+                add_one = 0;
+            }
+            break;
+        }
+
+        l = (unsigned)shift / LIMB_BITS;
+        shift = shift & (LIMB_BITS - 1);
+        if (l >= r->len) {
+            r->len = 1;
+            r->tab[0] = add_one;
+        } else {
+            if (l > 0) {
+                r->len -= l;
+                for(i = 0; i < r->len; i++)
+                    r->tab[i] = r->tab[i + l];
+            }
+            if (shift != 0) {
+                mp_shr(r->tab, r->tab, r->len, shift, 0);
+                mpb_renorm(r);
+            }
+            if (add_one) {
+                limb_t a;
+                a = mp_add_ui(r->tab, 1, r->len);
+                if (a)
+                    r->tab[r->len++] = a;
+            }
+        }
+    }
+}
+
+/* return -1, 0 or 1 */
+static int mpb_cmp(const mpb_t *a, const mpb_t *b)
+{
+    mp_size_t i;
+    if (a->len < b->len)
+        return -1;
+    else if (a->len > b->len)
+        return 1;
+    for(i = a->len - 1; i >= 0; i--) {
+        if (a->tab[i] != b->tab[i]) {
+            if (a->tab[i] < b->tab[i])
+                return -1;
+            else
+                return 1;
+        }
+    }
+    return 0;
+}
+
+static void mpb_set_u64(mpb_t *r, uint64_t m)
+{
+#if LIMB_BITS == 64
+    r->tab[0] = m;
+    r->len = 1;
+#else
+    r->tab[0] = m;
+    r->tab[1] = m >> LIMB_BITS;
+    if (r->tab[1] == 0)
+        r->len = 1;
+    else
+        r->len = 2;
+#endif
+}
+
+static uint64_t mpb_get_u64(mpb_t *r)
+{
+#if LIMB_BITS == 64
+    return r->tab[0];
+#else
+    if (r->len == 1) {
+        return r->tab[0];
+    } else {
+        return r->tab[0] | ((uint64_t)r->tab[1] << LIMB_BITS);
+    }
+#endif
+}
+
+/* floor_log2() = position of the first non zero bit or -1 if zero. */
+static int mpb_floor_log2(mpb_t *a)
+{
+    limb_t v;
+    v = a->tab[a->len - 1];
+    if (v == 0)
+        return -1;
+    else
+        return a->len * LIMB_BITS - 1 - clz32(v);
+}
+
+#define MUL_LOG2_RADIX_BASE_LOG2 24
+
+/* round((1 << MUL_LOG2_RADIX_BASE_LOG2)/log2(i + 2)) */
+static const uint32_t mul_log2_radix_table[JS_RADIX_MAX - 1] = {
+    0x000000, 0xa1849d, 0x000000, 0x6e40d2, 
+    0x6308c9, 0x5b3065, 0x000000, 0x50c24e, 
+    0x4d104d, 0x4a0027, 0x4768ce, 0x452e54, 
+    0x433d00, 0x418677, 0x000000, 0x3ea16b, 
+    0x3d645a, 0x3c43c2, 0x3b3b9a, 0x3a4899, 
+    0x39680b, 0x3897b3, 0x37d5af, 0x372069, 
+    0x367686, 0x35d6df, 0x354072, 0x34b261, 
+    0x342bea, 0x33ac62, 0x000000, 0x32bfd9, 
+    0x3251dd, 0x31e8d6, 0x318465,
+};
+
+/* return floor(a / log2(radix)) for -2048 <= a <= 2047 */
+static int mul_log2_radix(int a, int radix)
+{
+    int radix_bits, mult;
+
+    if ((radix & (radix - 1)) == 0) {
+        /* if the radix is a power of two better to do it exactly */
+        radix_bits = 31 - clz32(radix);
+        if (a < 0)
+            a -= radix_bits - 1;
+        return a / radix_bits;
+    } else {
+        mult = mul_log2_radix_table[radix - 2];
+        return ((int64_t)a * mult) >> MUL_LOG2_RADIX_BASE_LOG2;
+    }
+}
+
+#if 0
+static void build_mul_log2_radix_table(void)
+{
+    int base, radix, mult, col, base_log2;
+
+    base_log2 = 24;
+    base = 1 << base_log2;
+    col = 0;
+    for(radix = 2; radix <= 36; radix++) {
+        if ((radix & (radix - 1)) == 0)
+            mult = 0;
+        else
+            mult = lrint((double)base / log2(radix));
+        printf("0x%06x, ", mult);
+        if (++col == 4) {
+            printf("\n");
+            col = 0;
+        }
+    }
+    printf("\n");
+}
+
+static void mul_log2_radix_test(void)
+{
+    int radix, i, ref, r;
+    
+    for(radix = 2; radix <= 36; radix++) {
+        for(i = -2048; i <= 2047; i++) {
+            ref = (int)floor((double)i / log2(radix));
+            r = mul_log2_radix(i, radix);
+            if (ref != r) {
+                printf("ERROR: radix=%d i=%d r=%d ref=%d\n",
+                       radix, i, r, ref);
+                exit(1);
+            }
+        }
+    }
+    if (0)
+        build_mul_log2_radix_table();
+}
+#endif
+
+static void u32toa_len(char *buf, uint32_t n, size_t len)
+{
+    int digit, i;
+    for(i = len - 1; i >= 0; i--) {
+        digit = n % 10;
+        n = n / 10;
+        buf[i] = digit + '0';
+    }
+}
+
+/* for power of 2 radixes. len >= 1 */
+static void u64toa_bin_len(char *buf, uint64_t n, unsigned int radix_bits, int len)
+{
+    int digit, i;
+    unsigned int mask;
+
+    mask = (1 << radix_bits) - 1;
+    for(i = len - 1; i >= 0; i--) {
+        digit = n & mask;
+        n >>= radix_bits;
+        if (digit < 10)
+            digit += '0';
+        else
+            digit += 'a' - 10;
+        buf[i] = digit;
+    }
+}
+
+/* len >= 1. 2 <= radix <= 36 */
+static void limb_to_a(char *buf, limb_t n, unsigned int radix, int len)
+{
+    int digit, i;
+
+    if (radix == 10) {
+        /* specific case with constant divisor */
+#if LIMB_BITS == 32
+        u32toa_len(buf, n, len);
+#else
+        /* XXX: optimize */
+        for(i = len - 1; i >= 0; i--) {
+            digit = (limb_t)n % 10;
+            n = (limb_t)n / 10;
+            buf[i] = digit + '0';
+        }
+#endif
+    } else {
+        for(i = len - 1; i >= 0; i--) {
+            digit = (limb_t)n % radix;
+            n = (limb_t)n / radix;
+            if (digit < 10)
+                digit += '0';
+            else
+                digit += 'a' - 10;
+            buf[i] = digit;
+        }
+    }
+}
+
+size_t u32toa(char *buf, uint32_t n)
+{
+    char buf1[10], *q;
+    size_t len;
+    
+    q = buf1 + sizeof(buf1);
+    do {
+        *--q = n % 10 + '0';
+        n /= 10;
+    } while (n != 0);
+    len = buf1 + sizeof(buf1) - q;
+    memcpy(buf, q, len);
+    return len;
+}
+
+size_t i32toa(char *buf, int32_t n)
+{
+    if (n >= 0) {
+        return u32toa(buf, n);
+    } else {
+        buf[0] = '-';
+        return u32toa(buf + 1, -(uint32_t)n) + 1;
+    }
+}
+
+#ifdef USE_FAST_INT
+size_t u64toa(char *buf, uint64_t n)
+{
+    if (n < 0x100000000) {
+        return u32toa(buf, n);
+    } else {
+        uint64_t n1;
+        char *q = buf;
+        uint32_t n2;
+        
+        n1 = n / 1000000000;
+        n %= 1000000000;
+        if (n1 >= 0x100000000) {
+            n2 = n1 / 1000000000;
+            n1 = n1 % 1000000000;
+            /* at most two digits */
+            if (n2 >= 10) {
+                *q++ = n2 / 10 + '0';
+                n2 %= 10;
+            }
+            *q++ = n2 + '0';
+            u32toa_len(q, n1, 9);
+            q += 9;
+        } else {
+            q += u32toa(q, n1);
+        }
+        u32toa_len(q, n, 9);
+        q += 9;
+        return q - buf;
+    }
+}
+
+size_t i64toa(char *buf, int64_t n)
+{
+    if (n >= 0) {
+        return u64toa(buf, n);
+    } else {
+        buf[0] = '-';
+        return u64toa(buf + 1, -(uint64_t)n) + 1;
+    }
+}
+
+/* XXX: only tested for 1 <= n < 2^53 */
+size_t u64toa_radix(char *buf, uint64_t n, unsigned int radix)
+{
+    int radix_bits, l;
+    if (likely(radix == 10))
+        return u64toa(buf, n);
+    if ((radix & (radix - 1)) == 0) {
+        radix_bits = 31 - clz32(radix);
+        if (n == 0)
+            l = 1;
+        else
+            l = (64 - clz64(n) + radix_bits - 1) / radix_bits;
+        u64toa_bin_len(buf, n, radix_bits, l);
+        return l;
+    } else {
+        char buf1[41], *q; /* maximum length for radix = 3 */
+        size_t len;
+        int digit;
+        q = buf1 + sizeof(buf1);
+        do {
+            digit = n % radix;
+            n /= radix;
+            if (digit < 10)
+                digit += '0';
+            else
+                digit += 'a' - 10;
+            *--q = digit;
+        } while (n != 0);
+        len = buf1 + sizeof(buf1) - q;
+        memcpy(buf, q, len);
+        return len;
+    }
+}
+
+size_t i64toa_radix(char *buf, int64_t n, unsigned int radix)
+{
+    if (n >= 0) {
+        return u64toa_radix(buf, n, radix);
+    } else {
+        buf[0] = '-';
+        return u64toa_radix(buf + 1, -(uint64_t)n, radix) + 1;
+    }
+}
+#endif /* USE_FAST_INT */
+
+static const uint8_t digits_per_limb_table[JS_RADIX_MAX - 1] = {
+#if LIMB_BITS == 32
+32,20,16,13,12,11,10,10, 9, 9, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+#else
+64,40,32,27,24,22,21,20,19,18,17,17,16,16,16,15,15,15,14,14,14,14,13,13,13,13,13,13,13,12,12,12,12,12,12,
+#endif
+};
+
+static const uint32_t radix_base_table[JS_RADIX_MAX - 1] = {
+ 0x00000000, 0xcfd41b91, 0x00000000, 0x48c27395,
+ 0x81bf1000, 0x75db9c97, 0x40000000, 0xcfd41b91,
+ 0x3b9aca00, 0x8c8b6d2b, 0x19a10000, 0x309f1021,
+ 0x57f6c100, 0x98c29b81, 0x00000000, 0x18754571,
+ 0x247dbc80, 0x3547667b, 0x4c4b4000, 0x6b5a6e1d,
+ 0x94ace180, 0xcaf18367, 0x0b640000, 0x0e8d4a51,
+ 0x1269ae40, 0x17179149, 0x1cb91000, 0x23744899,
+ 0x2b73a840, 0x34e63b41, 0x40000000, 0x4cfa3cc1,
+ 0x5c13d840, 0x6d91b519, 0x81bf1000,
+};
+
+/* XXX: remove the table ? */
+static uint8_t dtoa_max_digits_table[JS_RADIX_MAX - 1] = {
+    54, 35, 28, 24, 22, 20, 19, 18, 17, 17, 16, 16, 15, 15, 15, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 12,
+};
+
+/* we limit the maximum number of significant digits for atod to about
+   128 bits of precision for non power of two bases. The only
+   requirement for Javascript is at least 20 digits in base 10. For
+   power of two bases, we do an exact rounding in all the cases. */
+static uint8_t atod_max_digits_table[JS_RADIX_MAX - 1] = {
+     64, 80, 32, 55, 49, 45, 21, 40, 38, 37, 35, 34, 33, 32, 16, 31, 30, 30, 29, 29, 28, 28, 27, 27, 27, 26, 26, 26, 26, 25, 12, 25, 25, 24, 24,
+};
+
+/* if abs(d) >= B^max_exponent, it is an overflow */
+static const int16_t max_exponent[JS_RADIX_MAX - 1] = {
+ 1024,   647,   512,   442,   397,   365,   342,   324, 
+  309,   297,   286,   277,   269,   263,   256,   251, 
+  246,   242,   237,   234,   230,   227,   224,   221, 
+  218,   216,   214,   211,   209,   207,   205,   203, 
+  202,   200,   199, 
+};
+
+/* if abs(d) <= B^min_exponent, it is an underflow */
+static const int16_t min_exponent[JS_RADIX_MAX - 1] = {
+-1075,  -679,  -538,  -463,  -416,  -383,  -359,  -340, 
+ -324,  -311,  -300,  -291,  -283,  -276,  -269,  -263, 
+ -258,  -254,  -249,  -245,  -242,  -238,  -235,  -232, 
+ -229,  -227,  -224,  -222,  -220,  -217,  -215,  -214, 
+ -212,  -210,  -208, 
+};
+
+#if 0
+void build_tables(void)
+{
+    int r, j, radix, n, col, i;
+    
+    /* radix_base_table */
+    for(radix = 2; radix <= 36; radix++) {
+        r = 1;
+        for(j = 0; j < digits_per_limb_table[radix - 2]; j++) {
+            r *= radix;
+        }
+        printf(" 0x%08x,", r);
+        if ((radix % 4) == 1)
+            printf("\n");
+    }
+    printf("\n");
+
+    /* dtoa_max_digits_table */
+    for(radix = 2; radix <= 36; radix++) {
+        /* Note: over estimated when the radix is a power of two */
+        printf(" %d,", 1 + (int)ceil(53.0 / log2(radix)));
+    }
+    printf("\n");
+
+    /* atod_max_digits_table */
+    for(radix = 2; radix <= 36; radix++) {
+        if ((radix & (radix - 1)) == 0) {
+            /* 64 bits is more than enough */
+            n = (int)floor(64.0 / log2(radix));
+        } else {
+            n = (int)floor(128.0 / log2(radix));
+        }
+        printf(" %d,", n);
+    }
+    printf("\n");
+
+    printf("static const int16_t max_exponent[JS_RADIX_MAX - 1] = {\n");
+    col = 0;
+    for(radix = 2; radix <= 36; radix++) {
+        printf("%5d, ", (int)ceil(1024 / log2(radix)));
+        if (++col == 8) {
+            col = 0;
+            printf("\n");
+        }
+    }
+    printf("\n};\n\n");
+
+    printf("static const int16_t min_exponent[JS_RADIX_MAX - 1] = {\n");
+    col = 0; 
+    for(radix = 2; radix <= 36; radix++) {
+        printf("%5d, ", (int)floor(-1075 / log2(radix)));
+        if (++col == 8) {
+            col = 0;
+            printf("\n");
+        }
+    }
+    printf("\n};\n\n");
+
+    printf("static const uint32_t pow5_table[16] = {\n");
+    col = 0; 
+    for(i = 2; i <= 17; i++) {
+        r = 1;
+        for(j = 0; j < i; j++) {
+            r *= 5;
+        }
+        printf("0x%08x, ", r);
+        if (++col == 4) {
+            col = 0;
+            printf("\n");
+        }
+    }
+    printf("\n};\n\n");
+
+    /* high part */
+    printf("static const uint8_t pow5h_table[4] = {\n");
+    col = 0; 
+    for(i = 14; i <= 17; i++) {
+        uint64_t r1;
+        r1 = 1;
+        for(j = 0; j < i; j++) {
+            r1 *= 5;
+        }
+        printf("0x%08x, ", (uint32_t)(r1 >> 32));
+        if (++col == 4) {
+            col = 0;
+            printf("\n");
+        }
+    }
+    printf("\n};\n\n");
+}
+#endif
+
+/* n_digits >= 1. 0 <= dot_pos <= n_digits. If dot_pos == n_digits,
+   the dot is not displayed. 'a' is modified. */
+static int output_digits(char *buf,
+                         mpb_t *a, int radix, int n_digits1,
+                         int dot_pos)
+{
+    int n_digits, digits_per_limb, radix_bits, n, len;
+
+    n_digits = n_digits1;
+    if ((radix & (radix - 1)) == 0) {
+        /* radix = 2^radix_bits */
+        radix_bits = 31 - clz32(radix);
+    } else {
+        radix_bits = 0;
+    }
+    digits_per_limb = digits_per_limb_table[radix - 2];
+    if (radix_bits != 0) {
+        for(;;) {
+            n = min_int(n_digits, digits_per_limb);
+            n_digits -= n;
+            u64toa_bin_len(buf + n_digits, a->tab[0], radix_bits, n);
+            if (n_digits == 0)
+                break;
+            mpb_shr_round(a, digits_per_limb * radix_bits, JS_RNDZ);
+        }
+    } else {
+        limb_t r;
+        while (n_digits != 0) {
+            n = min_int(n_digits, digits_per_limb);
+            n_digits -= n;
+            r = mp_div1(a->tab, a->tab, a->len, radix_base_table[radix - 2], 0);
+            mpb_renorm(a);
+            limb_to_a(buf + n_digits, r, radix, n);
+        }
+    }
+
+    /* add the dot */
+    len = n_digits1;
+    if (dot_pos != n_digits1) {
+        memmove(buf + dot_pos + 1, buf + dot_pos, n_digits1 - dot_pos);
+        buf[dot_pos] = '.';
+        len++;
+    }
+    return len;
+}
+
+/* return (a, e_offset) such that a = a * (radix1*2^radix_shift)^f *
+   2^-e_offset. 'f' can be negative. */
+static int mul_pow(mpb_t *a, int radix1, int radix_shift, int f, BOOL is_int, int e)
+{
+    int e_offset, d, n, n0;
+
+    e_offset = -f * radix_shift;
+    if (radix1 != 1) {
+        d = digits_per_limb_table[radix1 - 2];
+        if (f >= 0) {
+            limb_t h, b;
+            
+            b = 0;
+            n0 = 0;
+            while (f != 0) {
+                n = min_int(f, d);
+                if (n != n0) {
+                    b = pow_ui(radix1, n);
+                    n0 = n;
+                }
+                h = mp_mul1(a->tab, a->tab, a->len, b, 0);
+                if (h != 0) {
+                    a->tab[a->len++] = h;
+                }
+                f -= n;
+            }
+        } else {
+            int extra_bits, l, shift;
+            limb_t r, rem, b, b_inv;
+            
+            f = -f;
+            l = (f + d - 1) / d; /* high bound for the number of limbs (XXX: make it better) */
+            e_offset += l * LIMB_BITS;
+            if (!is_int) {
+                /* at least 'e' bits are needed in the final result for rounding */
+                extra_bits = max_int(e - mpb_floor_log2(a), 0);
+            } else {
+                /* at least two extra bits are needed in the final result
+                   for rounding */
+                extra_bits = max_int(2 + e - e_offset, 0);
+            }
+            e_offset += extra_bits;
+            mpb_shr_round(a, -(l * LIMB_BITS + extra_bits), JS_RNDZ);
+            
+            b = 0;
+            b_inv = 0;
+            shift = 0;
+            n0 = 0;
+            rem = 0;
+            while (f != 0) {
+                n = min_int(f, d);
+                if (n != n0) {
+                    b = pow_ui_inv(&b_inv, &shift, radix1, n);
+                    n0 = n;
+                }
+                r = mp_div1norm(a->tab, a->tab, a->len, b, 0, b_inv, shift);
+                rem |= r;
+                mpb_renorm(a);
+                f -= n;
+            }
+            /* if the remainder is non zero, use it for rounding */
+            a->tab[0] |= (rem != 0);
+        }
+    }
+    return e_offset;
+}
+
+/* tmp1 = round(m*2^e*radix^f). 'tmp0' is a temporary storage */
+static void mul_pow_round(mpb_t *tmp1, uint64_t m, int e, int radix1, int radix_shift, int f,
+                          int rnd_mode)
+{
+    int e_offset;
+
+    mpb_set_u64(tmp1, m);
+    e_offset = mul_pow(tmp1, radix1, radix_shift, f, TRUE, e);
+    mpb_shr_round(tmp1, -e + e_offset, rnd_mode);
+}
+
+/* return round(a*2^e_offset) rounded as a float64. 'a' is modified */
+static uint64_t round_to_d(int *pe, mpb_t *a, int e_offset, int rnd_mode)
+{
+    int e;
+    uint64_t m;
+
+    if (a->tab[0] == 0 && a->len == 1) {
+        /* zero result */
+        m = 0;
+        e = 0; /* don't care */
+    } else {
+        int prec, prec1, e_min;
+        e = mpb_floor_log2(a) + 1 - e_offset;
+        prec1 = 53;
+        e_min = -1021;
+        if (e < e_min) {
+            /* subnormal result or zero */
+            prec = prec1 - (e_min - e);
+        } else {
+            prec = prec1;
+        }
+        mpb_shr_round(a, e + e_offset - prec, rnd_mode);
+        m = mpb_get_u64(a);
+        m <<= (53 - prec);
+        /* mantissa overflow due to rounding */
+        if (m >= (uint64_t)1 << 53) {
+            m >>= 1;
+            e++;
+        }
+    }
+    *pe = e;
+    return m;
+}
+
+/* return (m, e) such that m*2^(e-53) = round(a * radix^f) with 2^52
+   <= m < 2^53 or m = 0.
+   'a' is modified. */
+static uint64_t mul_pow_round_to_d(int *pe, mpb_t *a,
+                                   int radix1, int radix_shift, int f, int rnd_mode)
+{
+    int e_offset;
+
+    e_offset = mul_pow(a, radix1, radix_shift, f, FALSE, 55);
+    return round_to_d(pe, a, e_offset, rnd_mode);
+}
+
+#ifdef JS_DTOA_DUMP_STATS
+static int out_len_count[17];
+
+void js_dtoa_dump_stats(void)
+{
+    int i, sum;
+    sum = 0;
+    for(i = 0; i < 17; i++)
+        sum += out_len_count[i];
+    for(i = 0; i < 17; i++) {
+        printf("%2d %8d %5.2f%%\n",
+               i + 1, out_len_count[i], (double)out_len_count[i] / sum * 100);
+    }
+}
+#endif
+
+/* return a maximum bound of the string length. The bound depends on
+   'd' only if format = JS_DTOA_FORMAT_FRAC or if JS_DTOA_EXP_DISABLED
+   is enabled. */
+int js_dtoa_max_len(double d, int radix, int n_digits, int flags)
+{
+    int fmt = flags & JS_DTOA_FORMAT_MASK;
+    int n, e;
+    uint64_t a;
+
+    if (fmt != JS_DTOA_FORMAT_FRAC) {
+        if (fmt == JS_DTOA_FORMAT_FREE) {
+            n = dtoa_max_digits_table[radix - 2];
+        } else {
+            n = n_digits;
+        }
+        if ((flags & JS_DTOA_EXP_MASK) == JS_DTOA_EXP_DISABLED) {
+            /* no exponential */
+            a = float64_as_uint64(d);
+            e = (a >> 52) & 0x7ff;
+            if (e == 0x7ff) {
+                /* NaN, Infinity */
+                n = 0;
+            } else {
+                e -= 1023;
+                /* XXX: adjust */
+                n += 10 + abs(mul_log2_radix(e - 1, radix));
+            }
+        } else {
+            /* extra: sign, 1 dot and exponent "e-1000" */
+            n += 1 + 1 + 6;
+        }
+    } else {
+        a = float64_as_uint64(d);
+        e = (a >> 52) & 0x7ff;
+        if (e == 0x7ff) {
+            /* NaN, Infinity */
+            n = 0;
+        } else {
+            /* high bound for the integer part */
+            e -= 1023;
+            /* x < 2^(e + 1) */
+            if (e < 0) {
+                n = 1;
+            } else {
+                n = 2 + mul_log2_radix(e - 1, radix);
+            }
+            /* sign, extra digit, 1 dot */
+            n += 1 + 1 + 1 + n_digits;
+        }
+    }
+    return max_int(n, 9); /* also include NaN and [-]Infinity */
+}
+
+#if defined(__SANITIZE_ADDRESS__) && 0
+static void *dtoa_malloc(uint64_t **pptr, size_t size)
+{
+    return malloc(size);
+}
+static void dtoa_free(void *ptr)
+{
+    free(ptr);
+}
+#else
+static void *dtoa_malloc(uint64_t **pptr, size_t size)
+{
+    void *ret;
+    ret = *pptr;
+    *pptr += (size + 7) / 8;
+    return ret;
+}
+
+static void dtoa_free(void *ptr)
+{
+}
+#endif
+
+/* return the length */
+int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
+            JSDTOATempMem *tmp_mem)
+{
+    uint64_t a, m, *mptr = tmp_mem->mem;
+    int e, sgn, l, E, P, i, E_max, radix1, radix_shift;
+    char *q;
+    mpb_t *tmp1, *mant_max;
+    int fmt = flags & JS_DTOA_FORMAT_MASK;
+
+    tmp1 = dtoa_malloc(&mptr, sizeof(mpb_t) + sizeof(limb_t) * DBIGNUM_LEN_MAX);
+    mant_max = dtoa_malloc(&mptr, sizeof(mpb_t) + sizeof(limb_t) * MANT_LEN_MAX);
+    assert((mptr - tmp_mem->mem) <= sizeof(JSDTOATempMem) / sizeof(mptr[0]));
+
+    radix_shift = ctz32(radix);
+    radix1 = radix >> radix_shift;
+    a = float64_as_uint64(d);
+    sgn = a >> 63;
+    e = (a >> 52) & 0x7ff;
+    m = a & (((uint64_t)1 << 52) - 1);
+    q = buf;
+    if (e == 0x7ff) {
+        if (m == 0) {
+            if (sgn)
+                *q++ = '-';
+            memcpy(q, "Infinity", 8);
+            q += 8;
+        } else {
+            memcpy(q, "NaN", 3);
+            q += 3;
+        }
+        goto done;
+    } else if (e == 0) {
+        if (m == 0) {
+            tmp1->len = 1;
+            tmp1->tab[0] = 0;
+            E = 1;
+            if (fmt == JS_DTOA_FORMAT_FREE)
+                P = 1;
+            else if (fmt == JS_DTOA_FORMAT_FRAC)
+                P = n_digits + 1;
+            else
+                P = n_digits;
+            /* "-0" is displayed as "0" if JS_DTOA_MINUS_ZERO is not present */
+            if (sgn && (flags & JS_DTOA_MINUS_ZERO))
+                *q++ = '-';
+            goto output;
+        }
+        /* denormal number: convert to a normal number */
+        l = clz64(m) - 11;
+        e -= l - 1;
+        m <<= l;
+    } else {
+        m |= (uint64_t)1 << 52;
+    }
+    if (sgn)
+        *q++ = '-';
+    /* remove the bias */
+    e -= 1022;
+    /* d = 2^(e-53)*m */
+    //    printf("m=0x%016" PRIx64 " e=%d\n", m, e);
+#ifdef USE_FAST_INT
+    if (fmt == JS_DTOA_FORMAT_FREE &&
+        e >= 1 && e <= 53 &&
+        (m & (((uint64_t)1 << (53 - e)) - 1)) == 0 &&
+        (flags & JS_DTOA_EXP_MASK) != JS_DTOA_EXP_ENABLED) {
+        m >>= 53 - e;
+        /* 'm' is never zero */
+        q += u64toa_radix(q, m, radix);
+        goto done;
+    }
+#endif
+    
+    /* this choice of E implies F=round(x*B^(P-E) is such as: 
+       B^(P-1) <= F < 2.B^P. */
+    E = 1 + mul_log2_radix(e - 1, radix);
+    
+    if (fmt == JS_DTOA_FORMAT_FREE) {
+        int P_max, E0, e1, E_found, P_found;
+        uint64_t m1, mant_found, mant, mant_max1;
+        /* P_max is guarranteed to work by construction */
+        P_max = dtoa_max_digits_table[radix - 2];
+        E0 = E;
+        E_found = 0;
+        P_found = 0;
+        mant_found = 0;
+        /* find the minimum number of digits by successive tries */
+        P = P_max; /* P_max is guarateed to work */
+        for(;;) {
+            /* mant_max always fits on 64 bits */
+            mant_max1 = pow_ui(radix, P);
+            /* compute the mantissa in base B */
+            E = E0;
+            for(;;) {
+                /* XXX: add inexact flag */
+                mul_pow_round(tmp1, m, e - 53, radix1, radix_shift, P - E, JS_RNDN);
+                mant = mpb_get_u64(tmp1);
+                if (mant < mant_max1)
+                    break;
+                E++; /* at most one iteration is possible */
+            }
+            /* remove useless trailing zero digits */
+            while ((mant % radix) == 0) {
+                mant /= radix;
+                P--;
+            }
+            /* garanteed to work for P = P_max */
+            if (P_found == 0)
+                goto prec_found;
+            /* convert back to base 2 */
+            mpb_set_u64(tmp1, mant);
+            m1 = mul_pow_round_to_d(&e1, tmp1, radix1, radix_shift, E - P, JS_RNDN);
+            //            printf("P=%2d: m=0x%016" PRIx64 " e=%d m1=0x%016" PRIx64 " e1=%d\n", P, m, e, m1, e1);
+            /* Note: (m, e) is never zero here, so the exponent for m1
+               = 0 does not matter */
+            if (m1 == m && e1 == e) {
+            prec_found:
+                P_found = P;
+                E_found = E;
+                mant_found = mant;
+                if (P == 1)
+                    break;
+                P--; /* try lower exponent */
+            } else {
+                break;
+            }
+        }
+        P = P_found;
+        E = E_found;
+        mpb_set_u64(tmp1, mant_found);
+#ifdef JS_DTOA_DUMP_STATS
+        if (radix == 10) {
+            out_len_count[P - 1]++;
+        }
+#endif        
+    } else if (fmt == JS_DTOA_FORMAT_FRAC) {
+        int len;
+
+        assert(n_digits >= 0 && n_digits <= JS_DTOA_MAX_DIGITS);
+        /* P = max_int(E, 1) + n_digits; */
+        /* frac is rounded using RNDNA */
+        mul_pow_round(tmp1, m, e - 53, radix1, radix_shift, n_digits, JS_RNDNA);
+
+        /* we add one extra digit on the left and remove it if needed
+           to avoid testing if the result is < radix^P */
+        len = output_digits(q, tmp1, radix, max_int(E + 1, 1) + n_digits,
+                            max_int(E + 1, 1));
+        if (q[0] == '0' && len >= 2 && q[1] != '.') {
+            len--;
+            memmove(q, q + 1, len);
+        }
+        q += len;
+        goto done;
+    } else {
+        int pow_shift;
+        assert(n_digits >= 1 && n_digits <= JS_DTOA_MAX_DIGITS);
+        P = n_digits;
+        /* mant_max = radix^P */
+        mant_max->len = 1;
+        mant_max->tab[0] = 1;
+        pow_shift = mul_pow(mant_max, radix1, radix_shift, P, FALSE, 0);
+        mpb_shr_round(mant_max, pow_shift, JS_RNDZ);
+        
+        for(;;) {
+            /* fixed and frac are rounded using RNDNA */
+            mul_pow_round(tmp1, m, e - 53, radix1, radix_shift, P - E, JS_RNDNA);
+            if (mpb_cmp(tmp1, mant_max) < 0)
+                break;
+            E++; /* at most one iteration is possible */
+        }
+    }
+ output:
+    if (fmt == JS_DTOA_FORMAT_FIXED)
+        E_max = n_digits;
+    else
+        E_max = dtoa_max_digits_table[radix - 2] + 4;
+    if ((flags & JS_DTOA_EXP_MASK) == JS_DTOA_EXP_ENABLED ||
+        ((flags & JS_DTOA_EXP_MASK) == JS_DTOA_EXP_AUTO && (E <= -6 || E > E_max))) {
+        q += output_digits(q, tmp1, radix, P, 1);
+        E--;
+        if (radix == 10) {
+            *q++ = 'e';
+        } else if (radix1 == 1 && radix_shift <= 4) {
+            E *= radix_shift;
+            *q++ = 'p';
+        } else {
+            *q++ = '@';
+        }
+        if (E < 0) {
+            *q++ = '-';
+            E = -E;
+        } else {
+            *q++ = '+';
+        }
+        q += u32toa(q, E);
+    } else if (E <= 0) {
+        *q++ = '0';
+        *q++ = '.';
+        for(i = 0; i < -E; i++)
+            *q++ = '0';
+        q += output_digits(q, tmp1, radix, P, P);
+    } else {
+        q += output_digits(q, tmp1, radix, P, min_int(P, E));
+        for(i = 0; i < E - P; i++)
+            *q++ = '0';
+    }
+ done:
+    *q = '\0';
+    dtoa_free(mant_max);
+    dtoa_free(tmp1);
+    return q - buf;
+}
+
+static inline int to_digit(int c)
+{
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    else if (c >= 'A' && c <= 'Z')
+        return c - 'A' + 10;
+    else if (c >= 'a' && c <= 'z')
+        return c - 'a' + 10;
+    else
+        return 36;
+}
+
+/* r = r * radix_base + a. radix_base = 0 means radix_base = 2^32 */
+static void mpb_mul1_base(mpb_t *r, limb_t radix_base, limb_t a)
+{
+    int i;
+    if (r->tab[0] == 0 && r->len == 1) {
+        r->tab[0] = a;
+    } else {
+        if (radix_base == 0) {
+            for(i = r->len; i >= 0; i--) {
+                r->tab[i + 1] = r->tab[i];
+            }
+            r->tab[0] = a;
+        } else {
+            r->tab[r->len] = mp_mul1(r->tab, r->tab, r->len,
+                                     radix_base, a);
+        }
+        r->len++;
+        mpb_renorm(r);
+    }
+}
+
+/* XXX: add fast path for small integers */
+double js_atod(const char *str, const char **pnext, int radix, int flags,
+               JSATODTempMem *tmp_mem)
+{
+    uint64_t *mptr = tmp_mem->mem;
+    const char *p, *p_start;
+    limb_t cur_limb, radix_base, extra_digits;
+    int is_neg, digit_count, limb_digit_count, digits_per_limb, sep, radix1, radix_shift;
+    int radix_bits, expn, e, max_digits, expn_offset, dot_pos, sig_pos, pos;
+    mpb_t *tmp0;
+    double dval;
+    BOOL is_bin_exp, is_zero, expn_overflow;
+    uint64_t m, a;
+
+    tmp0 = dtoa_malloc(&mptr, sizeof(mpb_t) + sizeof(limb_t) * DBIGNUM_LEN_MAX);
+    assert((mptr - tmp_mem->mem) <= sizeof(JSATODTempMem) / sizeof(mptr[0]));
+    /* optional separator between digits */
+    sep = (flags & JS_ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
+
+    p = str;
+    is_neg = 0;
+    if (p[0] == '+') {
+        p++;
+        p_start = p;
+    } else if (p[0] == '-') {
+        is_neg = 1;
+        p++;
+        p_start = p;
+    } else {
+        p_start = p;
+    }
+    
+    if (p[0] == '0') {
+        if ((p[1] == 'x' || p[1] == 'X') &&
+            (radix == 0 || radix == 16)) {
+            p += 2;
+            radix = 16;
+        } else if ((p[1] == 'o' || p[1] == 'O') &&
+                   radix == 0 && (flags & JS_ATOD_ACCEPT_BIN_OCT)) {
+            p += 2;
+            radix = 8;
+        } else if ((p[1] == 'b' || p[1] == 'B') &&
+                   radix == 0 && (flags & JS_ATOD_ACCEPT_BIN_OCT)) {
+            p += 2;
+            radix = 2;
+        } else if ((p[1] >= '0' && p[1] <= '9') &&
+                   radix == 0 && (flags & JS_ATOD_ACCEPT_LEGACY_OCTAL)) {
+            int i;
+            sep = 256;
+            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
+                continue;
+            if (p[i] == '8' || p[i] == '9')
+                goto no_prefix;
+            p += 1;
+            radix = 8;
+        } else {
+            goto no_prefix;
+        }
+        /* there must be a digit after the prefix */
+        if (to_digit((uint8_t)*p) >= radix)
+            goto fail;
+    no_prefix: ;
+    } else {
+        if (!(flags & JS_ATOD_INT_ONLY) && strstart(p, "Infinity", &p))
+            goto overflow;
+    }
+    if (radix == 0)
+        radix = 10;
+
+    cur_limb = 0;
+    expn_offset = 0;
+    digit_count = 0;
+    limb_digit_count = 0;
+    max_digits = atod_max_digits_table[radix - 2];
+    digits_per_limb = digits_per_limb_table[radix - 2];
+    radix_base = radix_base_table[radix - 2];
+    radix_shift = ctz32(radix);
+    radix1 = radix >> radix_shift;
+    if (radix1 == 1) {
+        /* radix = 2^radix_bits */
+        radix_bits = radix_shift;
+    } else {
+        radix_bits = 0;
+    }
+    tmp0->len = 1;
+    tmp0->tab[0] = 0;
+    extra_digits = 0;
+    pos = 0;
+    dot_pos = -1;
+    /* skip leading zeros */
+    for(;;) {
+        if (*p == '.' && (p > p_start || to_digit(p[1]) < radix) &&
+            !(flags & JS_ATOD_INT_ONLY)) {
+            if (*p == sep)
+                goto fail;
+            if (dot_pos >= 0)
+                break;
+            dot_pos = pos;
+            p++;
+        }
+        if (*p == sep && p > p_start && p[1] == '0')
+            p++;
+        if (*p != '0')
+            break;
+        p++;
+        pos++;
+    }
+    
+    sig_pos = pos;
+    for(;;) {
+        limb_t c;
+        if (*p == '.' && (p > p_start || to_digit(p[1]) < radix) &&
+            !(flags & JS_ATOD_INT_ONLY)) {
+            if (*p == sep)
+                goto fail;
+            if (dot_pos >= 0)
+                break;
+            dot_pos = pos;
+            p++;
+        }
+        if (*p == sep && p > p_start && to_digit(p[1]) < radix)
+            p++;
+        c = to_digit(*p);
+        if (c >= radix)
+            break;
+        p++;
+        pos++;
+        if (digit_count < max_digits) {
+            /* XXX: could be faster when radix_bits != 0 */
+            cur_limb = cur_limb * radix + c;
+            limb_digit_count++;
+            if (limb_digit_count == digits_per_limb) {
+                mpb_mul1_base(tmp0, radix_base, cur_limb);
+                cur_limb = 0;
+                limb_digit_count = 0;
+            }
+            digit_count++;
+        } else {
+            extra_digits |= c;
+        }
+    }
+    if (limb_digit_count != 0) {
+        mpb_mul1_base(tmp0, pow_ui(radix, limb_digit_count), cur_limb);
+    }
+    if (digit_count == 0) {
+        is_zero = TRUE;
+        expn_offset = 0;
+    } else {
+        is_zero = FALSE;
+        if (dot_pos < 0)
+            dot_pos = pos;
+        expn_offset = sig_pos + digit_count - dot_pos;
+    }
+    
+    /* Use the extra digits for rounding if the base is a power of
+       two. Otherwise they are just truncated. */
+    if (radix_bits != 0 && extra_digits != 0) {
+        tmp0->tab[0] |= 1;
+    }
+    
+    /* parse the exponent, if any */
+    expn = 0;
+    expn_overflow = FALSE;
+    is_bin_exp = FALSE;
+    if (!(flags & JS_ATOD_INT_ONLY) &&
+        ((radix == 10 && (*p == 'e' || *p == 'E')) ||
+         (radix != 10 && (*p == '@' ||
+                          (radix_bits >= 1 && radix_bits <= 4 && (*p == 'p' || *p == 'P'))))) &&
+        p > p_start) {
+        BOOL exp_is_neg;
+        int c;
+        is_bin_exp = (*p == 'p' || *p == 'P');
+        p++;
+        exp_is_neg = 0;
+        if (*p == '+') {
+            p++;
+        } else if (*p == '-') {
+            exp_is_neg = 1;
+            p++;
+        }
+        c = to_digit(*p);
+        if (c >= 10)
+            goto fail; /* XXX: could stop before the exponent part */
+        expn = c;
+        p++;
+        for(;;) {
+            if (*p == sep && to_digit(p[1]) < 10)
+                p++;
+            c = to_digit(*p);
+            if (c >= 10)
+                break;
+            if (!expn_overflow) {
+                if (unlikely(expn > ((INT32_MAX - 2 - 9) / 10))) {
+                    expn_overflow = TRUE;
+                } else {
+                    expn = expn * 10 + c;
+                }
+            }
+            p++;
+        }
+        if (exp_is_neg)
+            expn = -expn;
+        /* if zero result, the exponent can be arbitrarily large */
+        if (!is_zero && expn_overflow) {
+            if (exp_is_neg)
+                a = 0;
+            else
+                a = (uint64_t)0x7ff << 52; /* infinity */
+            goto done;
+        }
+    }
+
+    if (p == p_start)
+        goto fail;
+
+    if (is_zero) {
+        a = 0;
+    } else {
+        int expn1;
+        if (radix_bits != 0) {
+            if (!is_bin_exp)
+                expn *= radix_bits;
+            expn -= expn_offset * radix_bits;
+            expn1 = expn + digit_count * radix_bits;
+            if (expn1 >= 1024 + radix_bits)
+                goto overflow;
+            else if (expn1 <= -1075)
+                goto underflow;
+            m = round_to_d(&e, tmp0, -expn, JS_RNDN);
+        } else {
+            expn -= expn_offset;
+            expn1 = expn + digit_count;
+            if (expn1 >= max_exponent[radix - 2] + 1)
+                goto overflow;
+            else if (expn1 <= min_exponent[radix - 2])
+                goto underflow;
+            m = mul_pow_round_to_d(&e, tmp0, radix1, radix_shift, expn, JS_RNDN);
+        }
+        if (m == 0) {
+        underflow:
+            a = 0;
+        } else if (e > 1024) {
+        overflow:
+            /* overflow */
+            a = (uint64_t)0x7ff << 52;
+        } else if (e < -1073) {
+            /* underflow */
+            /* XXX: check rounding */
+            a = 0;
+        } else if (e < -1021) {
+            /* subnormal */
+            a = m >> (-e - 1021);
+        } else {
+            a = ((uint64_t)(e + 1022) << 52) | (m & (((uint64_t)1 << 52) - 1));
+        }
+    }
+ done:
+    a |= (uint64_t)is_neg << 63;
+    dval = uint64_as_float64(a);
+ done1:
+    if (pnext)
+        *pnext = p;
+    dtoa_free(tmp0);
+    return dval;
+ fail:
+    dval = NAN;
+    goto done1;
+}
diff --git a/quickjs/dtoa.h b/quickjs/dtoa.h
new file mode 100644
index 0000000000..de76f1a3fe
--- /dev/null
+++ b/quickjs/dtoa.h
@@ -0,0 +1,83 @@
+/*
+ * Tiny float64 printing and parsing library
+ *
+ * Copyright (c) 2024 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+//#define JS_DTOA_DUMP_STATS
+
+/* maximum number of digits for fixed and frac formats */
+#define JS_DTOA_MAX_DIGITS 101
+
+/* radix != 10 is only supported with flags = JS_DTOA_FORMAT_FREE */
+/* use as many digits as necessary */
+#define JS_DTOA_FORMAT_FREE  (0 << 0)
+/* use n_digits significant digits (1 <= n_digits <= JS_DTOA_MAX_DIGITS) */
+#define JS_DTOA_FORMAT_FIXED (1 << 0)
+/* force fractional format: [-]dd.dd with n_digits fractional digits.
+   0 <= n_digits <= JS_DTOA_MAX_DIGITS */
+#define JS_DTOA_FORMAT_FRAC  (2 << 0)
+#define JS_DTOA_FORMAT_MASK  (3 << 0)
+
+/* select exponential notation either in fixed or free format */
+#define JS_DTOA_EXP_AUTO     (0 << 2)
+#define JS_DTOA_EXP_ENABLED  (1 << 2)
+#define JS_DTOA_EXP_DISABLED (2 << 2)
+#define JS_DTOA_EXP_MASK     (3 << 2)
+
+#define JS_DTOA_MINUS_ZERO   (1 << 4) /* show the minus sign for -0 */
+
+/* only accepts integers (no dot, no exponent) */
+#define JS_ATOD_INT_ONLY       (1 << 0)
+/* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
+#define JS_ATOD_ACCEPT_BIN_OCT (1 << 1)
+/* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
+#define JS_ATOD_ACCEPT_LEGACY_OCTAL  (1 << 2)
+/* accept _ between digits as a digit separator */
+#define JS_ATOD_ACCEPT_UNDERSCORES  (1 << 3)
+
+typedef struct {
+    uint64_t mem[37];
+} JSDTOATempMem;
+
+typedef struct {
+    uint64_t mem[27];
+} JSATODTempMem;
+
+/* return a maximum bound of the string length */
+int js_dtoa_max_len(double d, int radix, int n_digits, int flags);
+/* return the string length */
+int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
+            JSDTOATempMem *tmp_mem);
+double js_atod(const char *str, const char **pnext, int radix, int flags,
+               JSATODTempMem *tmp_mem);
+
+#ifdef JS_DTOA_DUMP_STATS
+void js_dtoa_dump_stats(void);
+#endif
+
+/* additional exported functions */
+size_t u32toa(char *buf, uint32_t n);
+size_t i32toa(char *buf, int32_t n);
+size_t u64toa(char *buf, uint64_t n);
+size_t i64toa(char *buf, int64_t n);
+size_t u64toa_radix(char *buf, uint64_t n, unsigned int radix);
+size_t i64toa_radix(char *buf, int64_t n, unsigned int radix);
diff --git a/quickjs/libbf.c b/quickjs/libbf.c
deleted file mode 100644
index 234b956b4d..0000000000
--- a/quickjs/libbf.c
+++ /dev/null
@@ -1,8473 +0,0 @@
-/*
- * Tiny arbitrary precision floating point library
- * 
- * Copyright (c) 2017-2021 Fabrice Bellard
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <inttypes.h>
-#include <math.h>
-#include <string.h>
-#include <assert.h>
-
-#ifdef __AVX2__
-#include <immintrin.h>
-#endif
-
-#include "cutils.h"
-#include "libbf.h"
-
-/* enable it to check the multiplication result */
-//#define USE_MUL_CHECK
-#ifdef CONFIG_BIGNUM
-/* enable it to use FFT/NTT multiplication */
-#define USE_FFT_MUL
-/* enable decimal floating point support */
-#define USE_BF_DEC
-#endif
-
-//#define inline __attribute__((always_inline))
-
-#ifdef __AVX2__
-#define FFT_MUL_THRESHOLD 100 /* in limbs of the smallest factor */
-#else
-#define FFT_MUL_THRESHOLD 100 /* in limbs of the smallest factor */
-#endif
-
-/* XXX: adjust */
-#define DIVNORM_LARGE_THRESHOLD 50
-#define UDIV1NORM_THRESHOLD 3
-
-#if LIMB_BITS == 64
-#define FMT_LIMB1 "%" PRIx64 
-#define FMT_LIMB "%016" PRIx64 
-#define PRId_LIMB PRId64
-#define PRIu_LIMB PRIu64
-
-#else
-
-#define FMT_LIMB1 "%x"
-#define FMT_LIMB "%08x"
-#define PRId_LIMB "d"
-#define PRIu_LIMB "u"
-
-#endif
-
-typedef intptr_t mp_size_t;
-
-typedef int bf_op2_func_t(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                          bf_flags_t flags);
-
-#ifdef USE_FFT_MUL
-
-#define FFT_MUL_R_OVERLAP_A (1 << 0)
-#define FFT_MUL_R_OVERLAP_B (1 << 1)
-#define FFT_MUL_R_NORESIZE  (1 << 2)
-
-static no_inline int fft_mul(bf_context_t *s,
-                             bf_t *res, limb_t *a_tab, limb_t a_len,
-                             limb_t *b_tab, limb_t b_len, int mul_flags);
-static void fft_clear_cache(bf_context_t *s);
-#endif
-#ifdef USE_BF_DEC
-static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos);
-#endif
-
-
-/* could leading zeros */
-static inline int clz(limb_t a)
-{
-    if (a == 0) {
-        return LIMB_BITS;
-    } else {
-#if LIMB_BITS == 64
-        return clz64(a);
-#else
-        return clz32(a);
-#endif
-    }
-}
-
-static inline int ctz(limb_t a)
-{
-    if (a == 0) {
-        return LIMB_BITS;
-    } else {
-#if LIMB_BITS == 64
-        return ctz64(a);
-#else
-        return ctz32(a);
-#endif
-    }
-}
-
-static inline int ceil_log2(limb_t a)
-{
-    if (a <= 1)
-        return 0;
-    else
-        return LIMB_BITS - clz(a - 1);
-}
-
-/* b must be >= 1 */
-static inline slimb_t ceil_div(slimb_t a, slimb_t b)
-{
-    if (a >= 0)
-        return (a + b - 1) / b;
-    else
-        return a / b;
-}
-
-/* b must be >= 1 */
-static inline slimb_t floor_div(slimb_t a, slimb_t b)
-{
-    if (a >= 0) {
-        return a / b;
-    } else {
-        return (a - b + 1) / b;
-    }
-}
-
-/* return r = a modulo b (0 <= r <= b - 1. b must be >= 1 */
-static inline limb_t smod(slimb_t a, slimb_t b)
-{
-    a = a % (slimb_t)b;
-    if (a < 0)
-        a += b;
-    return a;
-}
-
-/* signed addition with saturation */
-static inline slimb_t sat_add(slimb_t a, slimb_t b)
-{
-    slimb_t r;
-    r = a + b;
-    /* overflow ? */
-    if (((a ^ r) & (b ^ r)) < 0)
-        r = (a >> (LIMB_BITS - 1)) ^ (((limb_t)1 << (LIMB_BITS - 1)) - 1);
-    return r;
-}
-
-static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
-{
-    if (shift != 0)
-        low = (low >> shift) | (high << (LIMB_BITS - shift));
-    return low;
-}
-
-static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
-{
-    if (shift != 0)
-        return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
-    else
-        return a1;
-}
-
-#define malloc(s) malloc_is_forbidden(s)
-#define free(p) free_is_forbidden(p)
-#define realloc(p, s) realloc_is_forbidden(p, s)
-
-void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
-                     void *realloc_opaque)
-{
-    memset(s, 0, sizeof(*s));
-    s->realloc_func = realloc_func;
-    s->realloc_opaque = realloc_opaque;
-}
-
-void bf_context_end(bf_context_t *s)
-{
-    bf_clear_cache(s);
-}
-
-void bf_init(bf_context_t *s, bf_t *r)
-{
-    r->ctx = s;
-    r->sign = 0;
-    r->expn = BF_EXP_ZERO;
-    r->len = 0;
-    r->tab = NULL;
-}
-
-/* return 0 if OK, -1 if alloc error */
-int bf_resize(bf_t *r, limb_t len)
-{
-    limb_t *tab;
-    
-    if (len != r->len) {
-        tab = bf_realloc(r->ctx, r->tab, len * sizeof(limb_t));
-        if (!tab && len != 0)
-            return -1;
-        r->tab = tab;
-        r->len = len;
-    }
-    return 0;
-}
-
-/* return 0 or BF_ST_MEM_ERROR */
-int bf_set_ui(bf_t *r, uint64_t a)
-{
-    r->sign = 0;
-    if (a == 0) {
-        r->expn = BF_EXP_ZERO;
-        bf_resize(r, 0); /* cannot fail */
-    } 
-#if LIMB_BITS == 32
-    else if (a <= 0xffffffff)
-#else
-    else
-#endif
-    {
-        int shift;
-        if (bf_resize(r, 1))
-            goto fail;
-        shift = clz(a);
-        r->tab[0] = a << shift;
-        r->expn = LIMB_BITS - shift;
-    }
-#if LIMB_BITS == 32
-    else {
-        uint32_t a1, a0;
-        int shift;
-        if (bf_resize(r, 2))
-            goto fail;
-        a0 = a;
-        a1 = a >> 32;
-        shift = clz(a1);
-        r->tab[0] = a0 << shift;
-        r->tab[1] = shld(a1, a0, shift);
-        r->expn = 2 * LIMB_BITS - shift;
-    }
-#endif
-    return 0;
- fail:
-    bf_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-/* return 0 or BF_ST_MEM_ERROR */
-int bf_set_si(bf_t *r, int64_t a)
-{
-    int ret;
-
-    if (a < 0) {
-        ret = bf_set_ui(r, -a);
-        r->sign = 1;
-    } else {
-        ret = bf_set_ui(r, a);
-    }
-    return ret;
-}
-
-void bf_set_nan(bf_t *r)
-{
-    bf_resize(r, 0); /* cannot fail */
-    r->expn = BF_EXP_NAN;
-    r->sign = 0;
-}
-
-void bf_set_zero(bf_t *r, int is_neg)
-{
-    bf_resize(r, 0); /* cannot fail */
-    r->expn = BF_EXP_ZERO;
-    r->sign = is_neg;
-}
-
-void bf_set_inf(bf_t *r, int is_neg)
-{
-    bf_resize(r, 0); /* cannot fail */
-    r->expn = BF_EXP_INF;
-    r->sign = is_neg;
-}
-
-/* return 0 or BF_ST_MEM_ERROR */
-int bf_set(bf_t *r, const bf_t *a)
-{
-    if (r == a)
-        return 0;
-    if (bf_resize(r, a->len)) {
-        bf_set_nan(r);
-        return BF_ST_MEM_ERROR;
-    }
-    r->sign = a->sign;
-    r->expn = a->expn;
-    memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
-    return 0;
-}
-
-/* equivalent to bf_set(r, a); bf_delete(a) */
-void bf_move(bf_t *r, bf_t *a)
-{
-    bf_context_t *s = r->ctx;
-    if (r == a)
-        return;
-    bf_free(s, r->tab);
-    *r = *a;
-}
-
-static limb_t get_limbz(const bf_t *a, limb_t idx)
-{
-    if (idx >= a->len)
-        return 0;
-    else
-        return a->tab[idx];
-}
-
-/* get LIMB_BITS at bit position 'pos' in tab */
-static inline limb_t get_bits(const limb_t *tab, limb_t len, slimb_t pos)
-{
-    limb_t i, a0, a1;
-    int p;
-
-    i = pos >> LIMB_LOG2_BITS;
-    p = pos & (LIMB_BITS - 1);
-    if (i < len)
-        a0 = tab[i];
-    else
-        a0 = 0;
-    if (p == 0) {
-        return a0;
-    } else {
-        i++;
-        if (i < len)
-            a1 = tab[i];
-        else
-            a1 = 0;
-        return (a0 >> p) | (a1 << (LIMB_BITS - p));
-    }
-}
-
-static inline limb_t get_bit(const limb_t *tab, limb_t len, slimb_t pos)
-{
-    slimb_t i;
-    i = pos >> LIMB_LOG2_BITS;
-    if (i < 0 || i >= len)
-        return 0;
-    return (tab[i] >> (pos & (LIMB_BITS - 1))) & 1;
-}
-
-static inline limb_t limb_mask(int start, int last)
-{
-    limb_t v;
-    int n;
-    n = last - start + 1;
-    if (n == LIMB_BITS)
-        v = -1;
-    else
-        v = (((limb_t)1 << n) - 1) << start;
-    return v;
-}
-
-static limb_t mp_scan_nz(const limb_t *tab, mp_size_t n)
-{
-    mp_size_t i;
-    for(i = 0; i < n; i++) {
-        if (tab[i] != 0)
-            return 1;
-    }
-    return 0;
-}
-
-/* return != 0 if one bit between 0 and bit_pos inclusive is not zero. */
-static inline limb_t scan_bit_nz(const bf_t *r, slimb_t bit_pos)
-{
-    slimb_t pos;
-    limb_t v;
-    
-    pos = bit_pos >> LIMB_LOG2_BITS;
-    if (pos < 0)
-        return 0;
-    v = r->tab[pos] & limb_mask(0, bit_pos & (LIMB_BITS - 1));
-    if (v != 0)
-        return 1;
-    pos--;
-    while (pos >= 0) {
-        if (r->tab[pos] != 0)
-            return 1;
-        pos--;
-    }
-    return 0;
-}
-
-/* return the addend for rounding. Note that prec can be <= 0 (for
-   BF_FLAG_RADPNT_PREC) */
-static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
-                          slimb_t prec, int rnd_mode)
-{
-    int add_one, inexact;
-    limb_t bit1, bit0;
-    
-    if (rnd_mode == BF_RNDF) {
-        bit0 = 1; /* faithful rounding does not honor the INEXACT flag */
-    } else {
-        /* starting limb for bit 'prec + 1' */
-        bit0 = scan_bit_nz(r, l * LIMB_BITS - 1 - bf_max(0, prec + 1));
-    }
-
-    /* get the bit at 'prec' */
-    bit1 = get_bit(r->tab, l, l * LIMB_BITS - 1 - prec);
-    inexact = (bit1 | bit0) != 0;
-    
-    add_one = 0;
-    switch(rnd_mode) {
-    case BF_RNDZ:
-        break;
-    case BF_RNDN:
-        if (bit1) {
-            if (bit0) {
-                add_one = 1;
-            } else {
-                /* round to even */
-                add_one =
-                    get_bit(r->tab, l, l * LIMB_BITS - 1 - (prec - 1));
-            }
-        }
-        break;
-    case BF_RNDD:
-    case BF_RNDU:
-        if (r->sign == (rnd_mode == BF_RNDD))
-            add_one = inexact;
-        break;
-    case BF_RNDA:
-        add_one = inexact;
-        break;
-    case BF_RNDNA:
-    case BF_RNDF:
-        add_one = bit1;
-        break;
-    default:
-        abort();
-    }
-    
-    if (inexact)
-        *pret |= BF_ST_INEXACT;
-    return add_one;
-}
-
-static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
-{
-    slimb_t i, l, e_max;
-    int rnd_mode;
-    
-    rnd_mode = flags & BF_RND_MASK;
-    if (prec == BF_PREC_INF ||
-        rnd_mode == BF_RNDN ||
-        rnd_mode == BF_RNDNA ||
-        rnd_mode == BF_RNDA ||
-        (rnd_mode == BF_RNDD && sign == 1) ||
-        (rnd_mode == BF_RNDU && sign == 0)) {
-        bf_set_inf(r, sign);
-    } else {
-        /* set to maximum finite number */
-        l = (prec + LIMB_BITS - 1) / LIMB_BITS;
-        if (bf_resize(r, l)) {
-            bf_set_nan(r);
-            return BF_ST_MEM_ERROR;
-        }
-        r->tab[0] = limb_mask((-prec) & (LIMB_BITS - 1),
-                              LIMB_BITS - 1);
-        for(i = 1; i < l; i++)
-            r->tab[i] = (limb_t)-1;
-        e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
-        r->expn = e_max;
-        r->sign = sign;
-    }
-    return BF_ST_OVERFLOW | BF_ST_INEXACT;
-}
-
-/* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
-   assumed to have length 'l' (1 <= l <= r->len). Note: 'prec1' can be
-   infinite (BF_PREC_INF). 'ret' is 0 or BF_ST_INEXACT if the result
-   is known to be inexact. Can fail with BF_ST_MEM_ERROR in case of
-   overflow not returning infinity. */
-static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
-                      int ret)
-{
-    limb_t v, a;
-    int shift, add_one, rnd_mode;
-    slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
-
-    /* e_min and e_max are computed to match the IEEE 754 conventions */
-    e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
-    e_min = -e_range + 3;
-    e_max = e_range;
-    
-    if (flags & BF_FLAG_RADPNT_PREC) {
-        /* 'prec' is the precision after the radix point */
-        if (prec1 != BF_PREC_INF)
-            prec = r->expn + prec1;
-        else
-            prec = prec1;
-    } else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
-        /* restrict the precision in case of potentially subnormal
-           result */
-        assert(prec1 != BF_PREC_INF);
-        prec = prec1 - (e_min - r->expn);
-    } else {
-        prec = prec1;
-    }
-
-    /* round to prec bits */
-    rnd_mode = flags & BF_RND_MASK;
-    add_one = bf_get_rnd_add(&ret, r, l, prec, rnd_mode);
-    
-    if (prec <= 0) {
-        if (add_one) {
-            bf_resize(r, 1); /* cannot fail */
-            r->tab[0] = (limb_t)1 << (LIMB_BITS - 1);
-            r->expn += 1 - prec;
-            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
-            return ret;
-        } else {
-            goto underflow;
-        }
-    } else if (add_one) {
-        limb_t carry;
-        
-        /* add one starting at digit 'prec - 1' */
-        bit_pos = l * LIMB_BITS - 1 - (prec - 1);
-        pos = bit_pos >> LIMB_LOG2_BITS;
-        carry = (limb_t)1 << (bit_pos & (LIMB_BITS - 1));
-        
-        for(i = pos; i < l; i++) {
-            v = r->tab[i] + carry;
-            carry = (v < carry);
-            r->tab[i] = v;
-            if (carry == 0)
-                break;
-        }
-        if (carry) {
-            /* shift right by one digit */
-            v = 1;
-            for(i = l - 1; i >= pos; i--) {
-                a = r->tab[i];
-                r->tab[i] = (a >> 1) | (v << (LIMB_BITS - 1));
-                v = a;
-            }
-            r->expn++;
-        }
-    }
-    
-    /* check underflow */
-    if (unlikely(r->expn < e_min)) {
-        if (flags & BF_FLAG_SUBNORMAL) {
-            /* if inexact, also set the underflow flag */
-            if (ret & BF_ST_INEXACT)
-                ret |= BF_ST_UNDERFLOW;
-        } else {
-        underflow:
-            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
-            bf_set_zero(r, r->sign);
-            return ret;
-        }
-    }
-    
-    /* check overflow */
-    if (unlikely(r->expn > e_max))
-        return bf_set_overflow(r, r->sign, prec1, flags);
-    
-    /* keep the bits starting at 'prec - 1' */
-    bit_pos = l * LIMB_BITS - 1 - (prec - 1);
-    i = bit_pos >> LIMB_LOG2_BITS;
-    if (i >= 0) {
-        shift = bit_pos & (LIMB_BITS - 1);
-        if (shift != 0)
-            r->tab[i] &= limb_mask(shift, LIMB_BITS - 1);
-    } else {
-        i = 0;
-    }
-    /* remove trailing zeros */
-    while (r->tab[i] == 0)
-        i++;
-    if (i > 0) {
-        l -= i;
-        memmove(r->tab, r->tab + i, l * sizeof(limb_t));
-    }
-    bf_resize(r, l); /* cannot fail */
-    return ret;
-}
-
-/* 'r' must be a finite number. */
-int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
-{
-    limb_t l, v, a;
-    int shift, ret;
-    slimb_t i;
-    
-    //    bf_print_str("bf_renorm", r);
-    l = r->len;
-    while (l > 0 && r->tab[l - 1] == 0)
-        l--;
-    if (l == 0) {
-        /* zero */
-        r->expn = BF_EXP_ZERO;
-        bf_resize(r, 0); /* cannot fail */
-        ret = 0;
-    } else {
-        r->expn -= (r->len - l) * LIMB_BITS;
-        /* shift to have the MSB set to '1' */
-        v = r->tab[l - 1];
-        shift = clz(v);
-        if (shift != 0) {
-            v = 0;
-            for(i = 0; i < l; i++) {
-                a = r->tab[i];
-                r->tab[i] = (a << shift) | (v >> (LIMB_BITS - shift));
-                v = a;
-            }
-            r->expn -= shift;
-        }
-        ret = __bf_round(r, prec1, flags, l, 0);
-    }
-    //    bf_print_str("r_final", r);
-    return ret;
-}
-
-/* return true if rounding can be done at precision 'prec' assuming
-   the exact result r is such that |r-a| <= 2^(EXP(a)-k). */
-/* XXX: check the case where the exponent would be incremented by the
-   rounding */
-int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
-{
-    BOOL is_rndn;
-    slimb_t bit_pos, n;
-    limb_t bit;
-    
-    if (a->expn == BF_EXP_INF || a->expn == BF_EXP_NAN)
-        return FALSE;
-    if (rnd_mode == BF_RNDF) {
-        return (k >= (prec + 1));
-    }
-    if (a->expn == BF_EXP_ZERO)
-        return FALSE;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
-    if (k < (prec + 2))
-        return FALSE;
-    bit_pos = a->len * LIMB_BITS - 1 - prec;
-    n = k - prec;
-    /* bit pattern for RNDN or RNDNA: 0111.. or 1000...
-       for other rounding modes: 000... or 111... 
-    */
-    bit = get_bit(a->tab, a->len, bit_pos);
-    bit_pos--;
-    n--;
-    bit ^= is_rndn;
-    /* XXX: slow, but a few iterations on average */
-    while (n != 0) {
-        if (get_bit(a->tab, a->len, bit_pos) != bit)
-            return TRUE;
-        bit_pos--;
-        n--;
-    }
-    return FALSE;
-}
-
-/* Cannot fail with BF_ST_MEM_ERROR. */
-int bf_round(bf_t *r, limb_t prec, bf_flags_t flags)
-{
-    if (r->len == 0)
-        return 0;
-    return __bf_round(r, prec, flags, r->len, 0);
-}
-
-/* for debugging */
-static __maybe_unused void dump_limbs(const char *str, const limb_t *tab, limb_t n)
-{
-    limb_t i;
-    printf("%s: len=%" PRId_LIMB "\n", str, n);
-    for(i = 0; i < n; i++) {
-        printf("%" PRId_LIMB ": " FMT_LIMB "\n",
-               i, tab[i]);
-    }
-}
-
-void mp_print_str(const char *str, const limb_t *tab, limb_t n)
-{
-    slimb_t i;
-    printf("%s= 0x", str);
-    for(i = n - 1; i >= 0; i--) {
-        if (i != (n - 1))
-            printf("_");
-        printf(FMT_LIMB, tab[i]);
-    }
-    printf("\n");
-}
-
-static __maybe_unused void mp_print_str_h(const char *str,
-                                          const limb_t *tab, limb_t n,
-                                          limb_t high)
-{
-    slimb_t i;
-    printf("%s= 0x", str);
-    printf(FMT_LIMB, high);
-    for(i = n - 1; i >= 0; i--) {
-        printf("_");
-        printf(FMT_LIMB, tab[i]);
-    }
-    printf("\n");
-}
-
-/* for debugging */
-void bf_print_str(const char *str, const bf_t *a)
-{
-    slimb_t i;
-    printf("%s=", str);
-
-    if (a->expn == BF_EXP_NAN) {
-        printf("NaN");
-    } else {
-        if (a->sign)
-            putchar('-');
-        if (a->expn == BF_EXP_ZERO) {
-            putchar('0');
-        } else if (a->expn == BF_EXP_INF) {
-            printf("Inf");
-        } else {
-            printf("0x0.");
-            for(i = a->len - 1; i >= 0; i--)
-                printf(FMT_LIMB, a->tab[i]);
-            printf("p%" PRId_LIMB, a->expn);
-        }
-    }
-    printf("\n");
-}
-
-/* compare the absolute value of 'a' and 'b'. Return < 0 if a < b, 0
-   if a = b and > 0 otherwise. */
-int bf_cmpu(const bf_t *a, const bf_t *b)
-{
-    slimb_t i;
-    limb_t len, v1, v2;
-    
-    if (a->expn != b->expn) {
-        if (a->expn < b->expn)
-            return -1;
-        else
-            return 1;
-    }
-    len = bf_max(a->len, b->len);
-    for(i = len - 1; i >= 0; i--) {
-        v1 = get_limbz(a, a->len - len + i);
-        v2 = get_limbz(b, b->len - len + i);
-        if (v1 != v2) {
-            if (v1 < v2)
-                return -1;
-            else
-                return 1;
-        }
-    }
-    return 0;
-}
-
-/* Full order: -0 < 0, NaN == NaN and NaN is larger than all other numbers */
-int bf_cmp_full(const bf_t *a, const bf_t *b)
-{
-    int res;
-    
-    if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-        if (a->expn == b->expn)
-            res = 0;
-        else if (a->expn == BF_EXP_NAN)
-            res = 1;
-        else
-            res = -1;
-    } else if (a->sign != b->sign) {
-        res = 1 - 2 * a->sign;
-    } else {
-        res = bf_cmpu(a, b);
-        if (a->sign)
-            res = -res;
-    }
-    return res;
-}
-
-/* Standard floating point comparison: return 2 if one of the operands
-   is NaN (unordered) or -1, 0, 1 depending on the ordering assuming
-   -0 == +0 */
-int bf_cmp(const bf_t *a, const bf_t *b)
-{
-    int res;
-    
-    if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-        res = 2;
-    } else if (a->sign != b->sign) {
-        if (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO)
-            res = 0;
-        else
-            res = 1 - 2 * a->sign;
-    } else {
-        res = bf_cmpu(a, b);
-        if (a->sign)
-            res = -res;
-    }
-    return res;
-}
-
-/* Compute the number of bits 'n' matching the pattern:
-   a= X1000..0
-   b= X0111..1
-              
-   When computing a-b, the result will have at least n leading zero
-   bits.
-
-   Precondition: a > b and a.expn - b.expn = 0 or 1
-*/
-static limb_t count_cancelled_bits(const bf_t *a, const bf_t *b)
-{
-    slimb_t bit_offset, b_offset, n;
-    int p, p1;
-    limb_t v1, v2, mask;
-
-    bit_offset = a->len * LIMB_BITS - 1;
-    b_offset = (b->len - a->len) * LIMB_BITS - (LIMB_BITS - 1) +
-        a->expn - b->expn;
-    n = 0;
-
-    /* first search the equals bits */
-    for(;;) {
-        v1 = get_limbz(a, bit_offset >> LIMB_LOG2_BITS);
-        v2 = get_bits(b->tab, b->len, bit_offset + b_offset);
-        //        printf("v1=" FMT_LIMB " v2=" FMT_LIMB "\n", v1, v2);
-        if (v1 != v2)
-            break;
-        n += LIMB_BITS;
-        bit_offset -= LIMB_BITS;
-    }
-    /* find the position of the first different bit */
-    p = clz(v1 ^ v2) + 1;
-    n += p;
-    /* then search for '0' in a and '1' in b */
-    p = LIMB_BITS - p;
-    if (p > 0) {
-        /* search in the trailing p bits of v1 and v2 */
-        mask = limb_mask(0, p - 1);
-        p1 = bf_min(clz(v1 & mask), clz((~v2) & mask)) - (LIMB_BITS - p);
-        n += p1;
-        if (p1 != p)
-            goto done;
-    }
-    bit_offset -= LIMB_BITS;
-    for(;;) {
-        v1 = get_limbz(a, bit_offset >> LIMB_LOG2_BITS);
-        v2 = get_bits(b->tab, b->len, bit_offset + b_offset);
-        //        printf("v1=" FMT_LIMB " v2=" FMT_LIMB "\n", v1, v2);
-        if (v1 != 0 || v2 != -1) {
-            /* different: count the matching bits */
-            p1 = bf_min(clz(v1), clz(~v2));
-            n += p1;
-            break;
-        }
-        n += LIMB_BITS;
-        bit_offset -= LIMB_BITS;
-    }
- done:
-    return n;
-}
-
-static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                           bf_flags_t flags, int b_neg)
-{
-    const bf_t *tmp;
-    int is_sub, ret, cmp_res, a_sign, b_sign;
-
-    a_sign = a->sign;
-    b_sign = b->sign ^ b_neg;
-    is_sub = a_sign ^ b_sign;
-    cmp_res = bf_cmpu(a, b);
-    if (cmp_res < 0) {
-        tmp = a;
-        a = b;
-        b = tmp;
-        a_sign = b_sign; /* b_sign is never used later */
-    }
-    /* abs(a) >= abs(b) */
-    if (cmp_res == 0 && is_sub && a->expn < BF_EXP_INF) {
-        /* zero result */
-        bf_set_zero(r, (flags & BF_RND_MASK) == BF_RNDD);
-        ret = 0;
-    } else if (a->len == 0 || b->len == 0) {
-        ret = 0;
-        if (a->expn >= BF_EXP_INF) {
-            if (a->expn == BF_EXP_NAN) {
-                /* at least one operand is NaN */
-                bf_set_nan(r);
-            } else if (b->expn == BF_EXP_INF && is_sub) {
-                /* infinities with different signs */
-                bf_set_nan(r);
-                ret = BF_ST_INVALID_OP;
-            } else {
-                bf_set_inf(r, a_sign);
-            }
-        } else {
-            /* at least one zero and not subtract */
-            bf_set(r, a);
-            r->sign = a_sign;
-            goto renorm;
-        }
-    } else {
-        slimb_t d, a_offset, b_bit_offset, i, cancelled_bits;
-        limb_t carry, v1, v2, u, r_len, carry1, precl, tot_len, z, sub_mask;
-
-        r->sign = a_sign;
-        r->expn = a->expn;
-        d = a->expn - b->expn;
-        /* must add more precision for the leading cancelled bits in
-           subtraction */
-        if (is_sub) {
-            if (d <= 1)
-                cancelled_bits = count_cancelled_bits(a, b);
-            else
-                cancelled_bits = 1;
-        } else {
-            cancelled_bits = 0;
-        }
-        
-        /* add two extra bits for rounding */
-        precl = (cancelled_bits + prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
-        tot_len = bf_max(a->len, b->len + (d + LIMB_BITS - 1) / LIMB_BITS);
-        r_len = bf_min(precl, tot_len);
-        if (bf_resize(r, r_len))
-            goto fail;
-        a_offset = a->len - r_len;
-        b_bit_offset = (b->len - r_len) * LIMB_BITS + d;
-
-        /* compute the bits before for the rounding */
-        carry = is_sub;
-        z = 0;
-        sub_mask = -is_sub;
-        i = r_len - tot_len;
-        while (i < 0) {
-            slimb_t ap, bp;
-            BOOL inflag;
-            
-            ap = a_offset + i;
-            bp = b_bit_offset + i * LIMB_BITS;
-            inflag = FALSE;
-            if (ap >= 0 && ap < a->len) {
-                v1 = a->tab[ap];
-                inflag = TRUE;
-            } else {
-                v1 = 0;
-            }
-            if (bp + LIMB_BITS > 0 && bp < (slimb_t)(b->len * LIMB_BITS)) {
-                v2 = get_bits(b->tab, b->len, bp);
-                inflag = TRUE;
-            } else {
-                v2 = 0;
-            }
-            if (!inflag) {
-                /* outside 'a' and 'b': go directly to the next value
-                   inside a or b so that the running time does not
-                   depend on the exponent difference */
-                i = 0;
-                if (ap < 0)
-                    i = bf_min(i, -a_offset);
-                /* b_bit_offset + i * LIMB_BITS + LIMB_BITS >= 1
-                   equivalent to 
-                   i >= ceil(-b_bit_offset + 1 - LIMB_BITS) / LIMB_BITS)
-                */
-                if (bp + LIMB_BITS <= 0)
-                    i = bf_min(i, (-b_bit_offset) >> LIMB_LOG2_BITS);
-            } else {
-                i++;
-            }
-            v2 ^= sub_mask;
-            u = v1 + v2;
-            carry1 = u < v1;
-            u += carry;
-            carry = (u < carry) | carry1;
-            z |= u;
-        }
-        /* and the result */
-        for(i = 0; i < r_len; i++) {
-            v1 = get_limbz(a, a_offset + i);
-            v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS);
-            v2 ^= sub_mask;
-            u = v1 + v2;
-            carry1 = u < v1;
-            u += carry;
-            carry = (u < carry) | carry1;
-            r->tab[i] = u;
-        }
-        /* set the extra bits for the rounding */
-        r->tab[0] |= (z != 0);
-
-        /* carry is only possible in add case */
-        if (!is_sub && carry) {
-            if (bf_resize(r, r_len + 1))
-                goto fail;
-            r->tab[r_len] = 1;
-            r->expn += LIMB_BITS;
-        }
-    renorm:
-        ret = bf_normalize_and_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bf_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-static int __bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                     bf_flags_t flags)
-{
-    return bf_add_internal(r, a, b, prec, flags, 0);
-}
-
-static int __bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                     bf_flags_t flags)
-{
-    return bf_add_internal(r, a, b, prec, flags, 1);
-}
-
-limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
-              limb_t n, limb_t carry)
-{
-    slimb_t i;
-    limb_t k, a, v, k1;
-    
-    k = carry;
-    for(i=0;i<n;i++) {
-        v = op1[i];
-        a = v + op2[i];
-        k1 = a < v;
-        a = a + k;
-        k = (a < k) | k1;
-        res[i] = a;
-    }
-    return k;
-}
-
-limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n)
-{
-    size_t i;
-    limb_t k, a;
-
-    k=b;
-    for(i=0;i<n;i++) {
-        if (k == 0)
-            break;
-        a = tab[i] + k;
-        k = (a < k);
-        tab[i] = a;
-    }
-    return k;
-}
-
-limb_t mp_sub(limb_t *res, const limb_t *op1, const limb_t *op2, 
-              mp_size_t n, limb_t carry)
-{
-    int i;
-    limb_t k, a, v, k1;
-    
-    k = carry;
-    for(i=0;i<n;i++) {
-        v = op1[i];
-        a = v - op2[i];
-        k1 = a > v;
-        v = a - k;
-        k = (v > a) | k1;
-        res[i] = v;
-    }
-    return k;
-}
-
-/* compute 0 - op2 */
-static limb_t mp_neg(limb_t *res, const limb_t *op2, mp_size_t n, limb_t carry)
-{
-    int i;
-    limb_t k, a, v, k1;
-    
-    k = carry;
-    for(i=0;i<n;i++) {
-        v = 0;
-        a = v - op2[i];
-        k1 = a > v;
-        v = a - k;
-        k = (v > a) | k1;
-        res[i] = v;
-    }
-    return k;
-}
-
-limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
-{
-    mp_size_t i;
-    limb_t k, a, v;
-    
-    k=b;
-    for(i=0;i<n;i++) {
-        v = tab[i];
-        a = v - k;
-        k = a > v;
-        tab[i] = a;
-        if (k == 0)
-            break;
-    }
-    return k;
-}
-
-/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift). 
-   1 <= shift <= LIMB_BITS - 1 */
-static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
-                     int shift, limb_t high)
-{
-    mp_size_t i;
-    limb_t l, a;
-
-    assert(shift >= 1 && shift < LIMB_BITS);
-    l = high;
-    for(i = n - 1; i >= 0; i--) {
-        a = tab[i];
-        tab_r[i] = (a >> shift) | (l << (LIMB_BITS - shift));
-        l = a;
-    }
-    return l & (((limb_t)1 << shift) - 1);
-}
-
-/* tabr[] = taba[] * b + l. Return the high carry */
-static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n, 
-                      limb_t b, limb_t l)
-{
-    limb_t i;
-    dlimb_t t;
-
-    for(i = 0; i < n; i++) {
-        t = (dlimb_t)taba[i] * (dlimb_t)b + l;
-        tabr[i] = t;
-        l = t >> LIMB_BITS;
-    }
-    return l;
-}
-
-/* tabr[] += taba[] * b, return the high word. */
-static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
-                          limb_t b)
-{
-    limb_t i, l;
-    dlimb_t t;
-    
-    l = 0;
-    for(i = 0; i < n; i++) {
-        t = (dlimb_t)taba[i] * (dlimb_t)b + l + tabr[i];
-        tabr[i] = t;
-        l = t >> LIMB_BITS;
-    }
-    return l;
-}
-
-/* size of the result : op1_size + op2_size. */
-static void mp_mul_basecase(limb_t *result, 
-                            const limb_t *op1, limb_t op1_size, 
-                            const limb_t *op2, limb_t op2_size) 
-{
-    limb_t i, r;
-    
-    result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
-    for(i=1;i<op2_size;i++) {
-        r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
-        result[i + op1_size] = r;
-    }
-}
-
-/* return 0 if OK, -1 if memory error */
-/* XXX: change API so that result can be allocated */
-int mp_mul(bf_context_t *s, limb_t *result, 
-           const limb_t *op1, limb_t op1_size, 
-           const limb_t *op2, limb_t op2_size) 
-{
-#ifdef USE_FFT_MUL
-    if (unlikely(bf_min(op1_size, op2_size) >= FFT_MUL_THRESHOLD)) {
-        bf_t r_s, *r = &r_s;
-        r->tab = result;
-        /* XXX: optimize memory usage in API */
-        if (fft_mul(s, r, (limb_t *)op1, op1_size,
-                    (limb_t *)op2, op2_size, FFT_MUL_R_NORESIZE))
-            return -1;
-    } else
-#endif
-    {
-        mp_mul_basecase(result, op1, op1_size, op2, op2_size);
-    }
-    return 0;
-}
-
-/* tabr[] -= taba[] * b. Return the value to substract to the high
-   word. */
-static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
-                          limb_t b)
-{
-    limb_t i, l;
-    dlimb_t t;
-    
-    l = 0;
-    for(i = 0; i < n; i++) {
-        t = tabr[i] - (dlimb_t)taba[i] * (dlimb_t)b - l;
-        tabr[i] = t;
-        l = -(t >> LIMB_BITS);
-    }
-    return l;
-}
-
-/* WARNING: d must be >= 2^(LIMB_BITS-1) */
-static inline limb_t udiv1norm_init(limb_t d)
-{
-    limb_t a0, a1;
-    a1 = -d - 1;
-    a0 = -1;
-    return (((dlimb_t)a1 << LIMB_BITS) | a0) / d;
-}
-
-/* return the quotient and the remainder in '*pr'of 'a1*2^LIMB_BITS+a0
-   / d' with 0 <= a1 < d. */
-static inline limb_t udiv1norm(limb_t *pr, limb_t a1, limb_t a0,
-                                limb_t d, limb_t d_inv)
-{
-    limb_t n1m, n_adj, q, r, ah;
-    dlimb_t a;
-    n1m = ((slimb_t)a0 >> (LIMB_BITS - 1));
-    n_adj = a0 + (n1m & d);
-    a = (dlimb_t)d_inv * (a1 - n1m) + n_adj;
-    q = (a >> LIMB_BITS) + a1;
-    /* compute a - q * r and update q so that the remainder is\
-       between 0 and d - 1 */
-    a = ((dlimb_t)a1 << LIMB_BITS) | a0;
-    a = a - (dlimb_t)q * d - d;
-    ah = a >> LIMB_BITS;
-    q += 1 + ah;
-    r = (limb_t)a + (ah & d);
-    *pr = r;
-    return q;
-}
-
-/* b must be >= 1 << (LIMB_BITS - 1) */
-static limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
-                          limb_t b, limb_t r)
-{
-    slimb_t i;
-
-    if (n >= UDIV1NORM_THRESHOLD) {
-        limb_t b_inv;
-        b_inv = udiv1norm_init(b);
-        for(i = n - 1; i >= 0; i--) {
-            tabr[i] = udiv1norm(&r, r, taba[i], b, b_inv);
-        }
-    } else {
-        dlimb_t a1;
-        for(i = n - 1; i >= 0; i--) {
-            a1 = ((dlimb_t)r << LIMB_BITS) | taba[i];
-            tabr[i] = a1 / b;
-            r = a1 % b;
-        }
-    }
-    return r;
-}
-
-static int mp_divnorm_large(bf_context_t *s, 
-                            limb_t *tabq, limb_t *taba, limb_t na, 
-                            const limb_t *tabb, limb_t nb);
-
-/* base case division: divides taba[0..na-1] by tabb[0..nb-1]. tabb[nb
-   - 1] must be >= 1 << (LIMB_BITS - 1). na - nb must be >= 0. 'taba'
-   is modified and contains the remainder (nb limbs). tabq[0..na-nb]
-   contains the quotient with tabq[na - nb] <= 1. */
-static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na, 
-                      const limb_t *tabb, limb_t nb)
-{
-    limb_t r, a, c, q, v, b1, b1_inv, n, dummy_r;
-    slimb_t i, j;
-
-    b1 = tabb[nb - 1];
-    if (nb == 1) {
-        taba[0] = mp_div1norm(tabq, taba, na, b1, 0);
-        return 0;
-    }
-    n = na - nb;
-    if (bf_min(n, nb) >= DIVNORM_LARGE_THRESHOLD) {
-        return mp_divnorm_large(s, tabq, taba, na, tabb, nb);
-    }
-    
-    if (n >= UDIV1NORM_THRESHOLD)
-        b1_inv = udiv1norm_init(b1);
-    else
-        b1_inv = 0;
-
-    /* first iteration: the quotient is only 0 or 1 */
-    q = 1;
-    for(j = nb - 1; j >= 0; j--) {
-        if (taba[n + j] != tabb[j]) {
-            if (taba[n + j] < tabb[j])
-                q = 0;
-            break;
-        }
-    }
-    tabq[n] = q;
-    if (q) {
-        mp_sub(taba + n, taba + n, tabb, nb, 0);
-    }
-    
-    for(i = n - 1; i >= 0; i--) {
-        if (unlikely(taba[i + nb] >= b1)) {
-            q = -1;
-        } else if (b1_inv) {
-            q = udiv1norm(&dummy_r, taba[i + nb], taba[i + nb - 1], b1, b1_inv);
-        } else {
-            dlimb_t al;
-            al = ((dlimb_t)taba[i + nb] << LIMB_BITS) | taba[i + nb - 1];
-            q = al / b1;
-            r = al % b1;
-        }
-        r = mp_sub_mul1(taba + i, tabb, nb, q);
-
-        v = taba[i + nb];
-        a = v - r;
-        c = (a > v);
-        taba[i + nb] = a;
-
-        if (c != 0) {
-            /* negative result */
-            for(;;) {
-                q--;
-                c = mp_add(taba + i, taba + i, tabb, nb, 0);
-                /* propagate carry and test if positive result */
-                if (c != 0) {
-                    if (++taba[i + nb] == 0) {
-                        break;
-                    }
-                }
-            }
-        }
-        tabq[i] = q;
-    }
-    return 0;
-}
-
-/* compute r=B^(2*n)/a such as a*r < B^(2*n) < a*r + 2 with n >= 1. 'a'
-   has n limbs with a[n-1] >= B/2 and 'r' has n+1 limbs with r[n] = 1.
-   
-   See Modern Computer Arithmetic by Richard P. Brent and Paul
-   Zimmermann, algorithm 3.5 */
-int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n)
-{
-    mp_size_t l, h, k, i;
-    limb_t *tabxh, *tabt, c, *tabu;
-    
-    if (n <= 2) {
-        /* return ceil(B^(2*n)/a) - 1 */
-        /* XXX: could avoid allocation */
-        tabu = bf_malloc(s, sizeof(limb_t) * (2 * n + 1));
-        tabt = bf_malloc(s, sizeof(limb_t) * (n + 2));
-        if (!tabt || !tabu)
-            goto fail;
-        for(i = 0; i < 2 * n; i++)
-            tabu[i] = 0;
-        tabu[2 * n] = 1;
-        if (mp_divnorm(s, tabt, tabu, 2 * n + 1, taba, n))
-            goto fail;
-        for(i = 0; i < n + 1; i++)
-            tabr[i] = tabt[i];
-        if (mp_scan_nz(tabu, n) == 0) {
-            /* only happens for a=B^n/2 */
-            mp_sub_ui(tabr, 1, n + 1);
-        }
-    } else {
-        l = (n - 1) / 2;
-        h = n - l;
-        /* n=2p  -> l=p-1, h = p + 1, k = p + 3
-           n=2p+1-> l=p,  h = p + 1; k = p + 2
-        */
-        tabt = bf_malloc(s, sizeof(limb_t) * (n + h + 1));
-        tabu = bf_malloc(s, sizeof(limb_t) * (n + 2 * h - l + 2));
-        if (!tabt || !tabu)
-            goto fail;
-        tabxh = tabr + l;
-        if (mp_recip(s, tabxh, taba + l, h))
-            goto fail;
-        if (mp_mul(s, tabt, taba, n, tabxh, h + 1)) /* n + h + 1 limbs */
-            goto fail;
-        while (tabt[n + h] != 0) {
-            mp_sub_ui(tabxh, 1, h + 1);
-            c = mp_sub(tabt, tabt, taba, n, 0);
-            mp_sub_ui(tabt + n, c, h + 1);
-        }
-        /* T = B^(n+h) - T */
-        mp_neg(tabt, tabt, n + h + 1, 0);
-        tabt[n + h]++;
-        if (mp_mul(s, tabu, tabt + l, n + h + 1 - l, tabxh, h + 1))
-            goto fail;
-        /* n + 2*h - l + 2 limbs */
-        k = 2 * h - l;
-        for(i = 0; i < l; i++)
-            tabr[i] = tabu[i + k];
-        mp_add(tabr + l, tabr + l, tabu + 2 * h, h, 0);
-    }
-    bf_free(s, tabt);
-    bf_free(s, tabu);
-    return 0;
- fail:
-    bf_free(s, tabt);
-    bf_free(s, tabu);
-    return -1;
-}
-
-/* return -1, 0 or 1 */
-static int mp_cmp(const limb_t *taba, const limb_t *tabb, mp_size_t n)
-{
-    mp_size_t i;
-    for(i = n - 1; i >= 0; i--) {
-        if (taba[i] != tabb[i]) {
-            if (taba[i] < tabb[i])
-                return -1;
-            else
-                return 1;
-        }
-    }
-    return 0;
-}
-
-//#define DEBUG_DIVNORM_LARGE
-//#define DEBUG_DIVNORM_LARGE2
-
-/* subquadratic divnorm */
-static int mp_divnorm_large(bf_context_t *s, 
-                            limb_t *tabq, limb_t *taba, limb_t na, 
-                            const limb_t *tabb, limb_t nb)
-{
-    limb_t *tabb_inv, nq, *tabt, i, n;
-    nq = na - nb;
-#ifdef DEBUG_DIVNORM_LARGE
-    printf("na=%d nb=%d nq=%d\n", (int)na, (int)nb, (int)nq);
-    mp_print_str("a", taba, na);
-    mp_print_str("b", tabb, nb);
-#endif
-    assert(nq >= 1);
-    n = nq;
-    if (nq < nb)
-        n++; 
-    tabb_inv = bf_malloc(s, sizeof(limb_t) * (n + 1));
-    tabt = bf_malloc(s, sizeof(limb_t) * 2 * (n + 1));
-    if (!tabb_inv || !tabt)
-        goto fail;
-
-    if (n >= nb) {
-        for(i = 0; i < n - nb; i++)
-            tabt[i] = 0;
-        for(i = 0; i < nb; i++)
-            tabt[i + n - nb] = tabb[i];
-    } else {
-        /* truncate B: need to increment it so that the approximate
-           inverse is smaller that the exact inverse */
-        for(i = 0; i < n; i++)
-            tabt[i] = tabb[i + nb - n];
-        if (mp_add_ui(tabt, 1, n)) {
-            /* tabt = B^n : tabb_inv = B^n */
-            memset(tabb_inv, 0, n * sizeof(limb_t));
-            tabb_inv[n] = 1;
-            goto recip_done;
-        }
-    }
-    if (mp_recip(s, tabb_inv, tabt, n))
-        goto fail;
- recip_done:
-    /* Q=A*B^-1 */
-    if (mp_mul(s, tabt, tabb_inv, n + 1, taba + na - (n + 1), n + 1))
-        goto fail;
-    
-    for(i = 0; i < nq + 1; i++)
-        tabq[i] = tabt[i + 2 * (n + 1) - (nq + 1)];
-#ifdef DEBUG_DIVNORM_LARGE
-    mp_print_str("q", tabq, nq + 1);
-#endif
-
-    bf_free(s, tabt);
-    bf_free(s, tabb_inv);
-    tabb_inv = NULL;
-    
-    /* R=A-B*Q */
-    tabt = bf_malloc(s, sizeof(limb_t) * (na + 1));
-    if (!tabt)
-        goto fail;
-    if (mp_mul(s, tabt, tabq, nq + 1, tabb, nb))
-        goto fail;
-    /* we add one more limb for the result */
-    mp_sub(taba, taba, tabt, nb + 1, 0);
-    bf_free(s, tabt);
-    /* the approximated quotient is smaller than than the exact one,
-       hence we may have to increment it */
-#ifdef DEBUG_DIVNORM_LARGE2
-    int cnt = 0;
-    static int cnt_max;
-#endif
-    for(;;) {
-        if (taba[nb] == 0 && mp_cmp(taba, tabb, nb) < 0)
-            break;
-        taba[nb] -= mp_sub(taba, taba, tabb, nb, 0);
-        mp_add_ui(tabq, 1, nq + 1);
-#ifdef DEBUG_DIVNORM_LARGE2
-        cnt++;
-#endif
-    }
-#ifdef DEBUG_DIVNORM_LARGE2
-    if (cnt > cnt_max) {
-        cnt_max = cnt;
-        printf("\ncnt=%d nq=%d nb=%d\n", cnt_max, (int)nq, (int)nb);
-    }
-#endif
-    return 0;
- fail:
-    bf_free(s, tabb_inv);
-    bf_free(s, tabt);
-    return -1;
-}
-
-int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-           bf_flags_t flags)
-{
-    int ret, r_sign;
-
-    if (a->len < b->len) {
-        const bf_t *tmp = a;
-        a = b;
-        b = tmp;
-    }
-    r_sign = a->sign ^ b->sign;
-    /* here b->len <= a->len */
-    if (b->len == 0) {
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            ret = 0;
-        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_INF) {
-            if ((a->expn == BF_EXP_INF && b->expn == BF_EXP_ZERO) ||
-                (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_INF)) {
-                bf_set_nan(r);
-                ret = BF_ST_INVALID_OP;
-            } else {
-                bf_set_inf(r, r_sign);
-                ret = 0;
-            }
-        } else {
-            bf_set_zero(r, r_sign);
-            ret = 0;
-        }
-    } else {
-        bf_t tmp, *r1 = NULL;
-        limb_t a_len, b_len, precl;
-        limb_t *a_tab, *b_tab;
-            
-        a_len = a->len;
-        b_len = b->len;
-        
-        if ((flags & BF_RND_MASK) == BF_RNDF) {
-            /* faithful rounding does not require using the full inputs */
-            precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
-            a_len = bf_min(a_len, precl);
-            b_len = bf_min(b_len, precl);
-        }
-        a_tab = a->tab + a->len - a_len;
-        b_tab = b->tab + b->len - b_len;
-        
-#ifdef USE_FFT_MUL
-        if (b_len >= FFT_MUL_THRESHOLD) {
-            int mul_flags = 0;
-            if (r == a)
-                mul_flags |= FFT_MUL_R_OVERLAP_A;
-            if (r == b)
-                mul_flags |= FFT_MUL_R_OVERLAP_B;
-            if (fft_mul(r->ctx, r, a_tab, a_len, b_tab, b_len, mul_flags))
-                goto fail;
-        } else
-#endif
-        {
-            if (r == a || r == b) {
-                bf_init(r->ctx, &tmp);
-                r1 = r;
-                r = &tmp;
-            }
-            if (bf_resize(r, a_len + b_len)) {
-#ifdef USE_FFT_MUL
-            fail:
-#endif                
-                bf_set_nan(r);
-                ret = BF_ST_MEM_ERROR;
-                goto done;
-            }
-            mp_mul_basecase(r->tab, a_tab, a_len, b_tab, b_len);
-        }
-        r->sign = r_sign;
-        r->expn = a->expn + b->expn;
-        ret = bf_normalize_and_round(r, prec, flags);
-    done:
-        if (r == &tmp)
-            bf_move(r1, &tmp);
-    }
-    return ret;
-}
-
-/* multiply 'r' by 2^e */
-int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags)
-{
-    slimb_t e_max;
-    if (r->len == 0)
-        return 0;
-    e_max = ((limb_t)1 << BF_EXT_EXP_BITS_MAX) - 1;
-    e = bf_max(e, -e_max);
-    e = bf_min(e, e_max);
-    r->expn += e;
-    return __bf_round(r, prec, flags, r->len, 0);
-}
-
-/* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
-   Infinite or Nan. */
-slimb_t bf_get_exp_min(const bf_t *a)
-{
-    slimb_t i;
-    limb_t v;
-    int k;
-    
-    for(i = 0; i < a->len; i++) {
-        v = a->tab[i];
-        if (v != 0) {
-            k = ctz(v);
-            return a->expn - (a->len - i) * LIMB_BITS + k;
-        }
-    }
-    return 0;
-}
-
-/* a and b must be finite numbers with a >= 0 and b > 0. 'q' is the
-   integer defined as floor(a/b) and r = a - q * b. */
-static void bf_tdivremu(bf_t *q, bf_t *r,
-                        const bf_t *a, const bf_t *b)
-{
-    if (bf_cmpu(a, b) < 0) {
-        bf_set_ui(q, 0);
-        bf_set(r, a);
-    } else {
-        bf_div(q, a, b, bf_max(a->expn - b->expn + 1, 2), BF_RNDZ);
-        bf_rint(q, BF_RNDZ);
-        bf_mul(r, q, b, BF_PREC_INF, BF_RNDZ);
-        bf_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
-    }
-}
-
-static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                    bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    int ret, r_sign;
-    limb_t n, nb, precl;
-    
-    r_sign = a->sign ^ b->sign;
-    if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_inf(r, r_sign);
-            return 0;
-        } else {
-            bf_set_zero(r, r_sign);
-            return 0;
-        }
-    } else if (a->expn == BF_EXP_ZERO) {
-        if (b->expn == BF_EXP_ZERO) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set_zero(r, r_sign);
-            return 0;
-        }
-    } else if (b->expn == BF_EXP_ZERO) {
-        bf_set_inf(r, r_sign);
-        return BF_ST_DIVIDE_ZERO;
-    }
-
-    /* number of limbs of the quotient (2 extra bits for rounding) */
-    precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
-    nb = b->len;
-    n = bf_max(a->len, precl);
-    
-    {
-        limb_t *taba, na;
-        slimb_t d;
-        
-        na = n + nb;
-        taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
-        if (!taba)
-            goto fail;
-        d = na - a->len;
-        memset(taba, 0, d * sizeof(limb_t));
-        memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
-        if (bf_resize(r, n + 1))
-            goto fail1;
-        if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
-        fail1:
-            bf_free(s, taba);
-            goto fail;
-        }
-        /* see if non zero remainder */
-        if (mp_scan_nz(taba, nb))
-            r->tab[0] |= 1;
-        bf_free(r->ctx, taba);
-        r->expn = a->expn - b->expn + LIMB_BITS;
-        r->sign = r_sign;
-        ret = bf_normalize_and_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bf_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-/* division and remainder. 
-   
-   rnd_mode is the rounding mode for the quotient. The additional
-   rounding mode BF_RND_EUCLIDIAN is supported.
-
-   'q' is an integer. 'r' is rounded with prec and flags (prec can be
-   BF_PREC_INF).
-*/
-int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
-              limb_t prec, bf_flags_t flags, int rnd_mode)
-{
-    bf_t a1_s, *a1 = &a1_s;
-    bf_t b1_s, *b1 = &b1_s;
-    int q_sign, ret;
-    BOOL is_ceil, is_rndn;
-    
-    assert(q != a && q != b);
-    assert(r != a && r != b);
-    assert(q != r);
-    
-    if (a->len == 0 || b->len == 0) {
-        bf_set_zero(q, 0);
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_ZERO) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set(r, a);
-            return bf_round(r, prec, flags);
-        }
-    }
-
-    q_sign = a->sign ^ b->sign;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
-    switch(rnd_mode) {
-    default:
-    case BF_RNDZ:
-    case BF_RNDN:
-    case BF_RNDNA:
-        is_ceil = FALSE;
-        break;
-    case BF_RNDD:
-        is_ceil = q_sign;
-        break;
-    case BF_RNDU:
-        is_ceil = q_sign ^ 1;
-        break;
-    case BF_RNDA:
-        is_ceil = TRUE;
-        break;
-    case BF_DIVREM_EUCLIDIAN:
-        is_ceil = a->sign;
-        break;
-    }
-
-    a1->expn = a->expn;
-    a1->tab = a->tab;
-    a1->len = a->len;
-    a1->sign = 0;
-    
-    b1->expn = b->expn;
-    b1->tab = b->tab;
-    b1->len = b->len;
-    b1->sign = 0;
-
-    /* XXX: could improve to avoid having a large 'q' */
-    bf_tdivremu(q, r, a1, b1);
-    if (bf_is_nan(q) || bf_is_nan(r))
-        goto fail;
-
-    if (r->len != 0) {
-        if (is_rndn) {
-            int res;
-            b1->expn--;
-            res = bf_cmpu(r, b1);
-            b1->expn++;
-            if (res > 0 ||
-                (res == 0 &&
-                 (rnd_mode == BF_RNDNA ||
-                  get_bit(q->tab, q->len, q->len * LIMB_BITS - q->expn)))) {
-                goto do_sub_r;
-            }
-        } else if (is_ceil) {
-        do_sub_r:
-            ret = bf_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
-            ret |= bf_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
-            if (ret & BF_ST_MEM_ERROR)
-                goto fail;
-        }
-    }
-
-    r->sign ^= a->sign;
-    q->sign = q_sign;
-    return bf_round(r, prec, flags);
- fail:
-    bf_set_nan(q);
-    bf_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-           bf_flags_t flags, int rnd_mode)
-{
-    bf_t q_s, *q = &q_s;
-    int ret;
-    
-    bf_init(r->ctx, q);
-    ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
-    bf_delete(q);
-    return ret;
-}
-
-static inline int bf_get_limb(slimb_t *pres, const bf_t *a, int flags)
-{
-#if LIMB_BITS == 32
-    return bf_get_int32(pres, a, flags);
-#else
-    return bf_get_int64(pres, a, flags);
-#endif
-}
-
-int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-              bf_flags_t flags, int rnd_mode)
-{
-    bf_t q_s, *q = &q_s;
-    int ret;
-    
-    bf_init(r->ctx, q);
-    ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
-    bf_get_limb(pq, q, BF_GET_INT_MOD);
-    bf_delete(q);
-    return ret;
-}
-
-static __maybe_unused inline limb_t mul_mod(limb_t a, limb_t b, limb_t m)
-{
-    dlimb_t t;
-    t = (dlimb_t)a * (dlimb_t)b;
-    return t % m;
-}
-
-#if defined(USE_MUL_CHECK)
-static limb_t mp_mod1(const limb_t *tab, limb_t n, limb_t m, limb_t r)
-{
-    slimb_t i;
-    dlimb_t t;
-
-    for(i = n - 1; i >= 0; i--) {
-        t = ((dlimb_t)r << LIMB_BITS) | tab[i];
-        r = t % m;
-    }
-    return r;
-}
-#endif
-
-static const uint16_t sqrt_table[192] = {
-128,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,144,145,146,147,148,149,150,150,151,152,153,154,155,155,156,157,158,159,160,160,161,162,163,163,164,165,166,167,167,168,169,170,170,171,172,173,173,174,175,176,176,177,178,178,179,180,181,181,182,183,183,184,185,185,186,187,187,188,189,189,190,191,192,192,193,193,194,195,195,196,197,197,198,199,199,200,201,201,202,203,203,204,204,205,206,206,207,208,208,209,209,210,211,211,212,212,213,214,214,215,215,216,217,217,218,218,219,219,220,221,221,222,222,223,224,224,225,225,226,226,227,227,228,229,229,230,230,231,231,232,232,233,234,234,235,235,236,236,237,237,238,238,239,240,240,241,241,242,242,243,243,244,244,245,245,246,246,247,247,248,248,249,249,250,250,251,251,252,252,253,253,254,254,255,
-};
-
-/* a >= 2^(LIMB_BITS - 2).  Return (s, r) with s=floor(sqrt(a)) and
-   r=a-s^2. 0 <= r <= 2 * s */
-static limb_t mp_sqrtrem1(limb_t *pr, limb_t a)
-{
-    limb_t s1, r1, s, r, q, u, num;
-    
-    /* use a table for the 16 -> 8 bit sqrt */
-    s1 = sqrt_table[(a >> (LIMB_BITS - 8)) - 64];
-    r1 = (a >> (LIMB_BITS - 16)) - s1 * s1;
-    if (r1 > 2 * s1) {
-        r1 -= 2 * s1 + 1;
-        s1++;
-    }
-    
-    /* one iteration to get a 32 -> 16 bit sqrt */
-    num = (r1 << 8) | ((a >> (LIMB_BITS - 32 + 8)) & 0xff);
-    q = num / (2 * s1); /* q <= 2^8 */
-    u = num % (2 * s1);
-    s = (s1 << 8) + q;
-    r = (u << 8) | ((a >> (LIMB_BITS - 32)) & 0xff);
-    r -= q * q;
-    if ((slimb_t)r < 0) {
-        s--;
-        r += 2 * s + 1;
-    }
-
-#if LIMB_BITS == 64
-    s1 = s;
-    r1 = r;
-    /* one more iteration for 64 -> 32 bit sqrt */
-    num = (r1 << 16) | ((a >> (LIMB_BITS - 64 + 16)) & 0xffff);
-    q = num / (2 * s1); /* q <= 2^16 */
-    u = num % (2 * s1);
-    s = (s1 << 16) + q;
-    r = (u << 16) | ((a >> (LIMB_BITS - 64)) & 0xffff);
-    r -= q * q;
-    if ((slimb_t)r < 0) {
-        s--;
-        r += 2 * s + 1;
-    }
-#endif
-    *pr = r;
-    return s;
-}
-
-/* return floor(sqrt(a)) */
-limb_t bf_isqrt(limb_t a)
-{
-    limb_t s, r;
-    int k;
-
-    if (a == 0)
-        return 0;
-    k = clz(a) & ~1;
-    s = mp_sqrtrem1(&r, a << k);
-    s >>= (k >> 1);
-    return s;
-}
-
-static limb_t mp_sqrtrem2(limb_t *tabs, limb_t *taba)
-{
-    limb_t s1, r1, s, q, u, a0, a1;
-    dlimb_t r, num;
-    int l;
-
-    a0 = taba[0];
-    a1 = taba[1];
-    s1 = mp_sqrtrem1(&r1, a1);
-    l = LIMB_BITS / 2;
-    num = ((dlimb_t)r1 << l) | (a0 >> l);
-    q = num / (2 * s1);
-    u = num % (2 * s1);
-    s = (s1 << l) + q;
-    r = ((dlimb_t)u << l) | (a0 & (((limb_t)1 << l) - 1));
-    if (unlikely((q >> l) != 0))
-        r -= (dlimb_t)1 << LIMB_BITS; /* special case when q=2^l */
-    else
-        r -= q * q;
-    if ((slimb_t)(r >> LIMB_BITS) < 0) {
-        s--;
-        r += 2 * (dlimb_t)s + 1;
-    }
-    tabs[0] = s;
-    taba[0] = r;
-    return r >> LIMB_BITS;
-}
-
-//#define DEBUG_SQRTREM
-
-/* tmp_buf must contain (n / 2 + 1 limbs). *prh contains the highest
-   limb of the remainder. */
-static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
-                          limb_t *tmp_buf, limb_t *prh)
-{
-    limb_t l, h, rh, ql, qh, c, i;
-    
-    if (n == 1) {
-        *prh = mp_sqrtrem2(tabs, taba);
-        return 0;
-    }
-#ifdef DEBUG_SQRTREM
-    mp_print_str("a", taba, 2 * n);
-#endif
-    l = n / 2;
-    h = n - l;
-    if (mp_sqrtrem_rec(s, tabs + l, taba + 2 * l, h, tmp_buf, &qh))
-        return -1;
-#ifdef DEBUG_SQRTREM
-    mp_print_str("s1", tabs + l, h);
-    mp_print_str_h("r1", taba + 2 * l, h, qh);
-    mp_print_str_h("r2", taba + l, n, qh);
-#endif
-    
-    /* the remainder is in taba + 2 * l. Its high bit is in qh */
-    if (qh) {
-        mp_sub(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
-    }
-    /* instead of dividing by 2*s, divide by s (which is normalized)
-       and update q and r */
-    if (mp_divnorm(s, tmp_buf, taba + l, n, tabs + l, h))
-        return -1;
-    qh += tmp_buf[l];
-    for(i = 0; i < l; i++)
-        tabs[i] = tmp_buf[i];
-    ql = mp_shr(tabs, tabs, l, 1, qh & 1);
-    qh = qh >> 1; /* 0 or 1 */
-    if (ql)
-        rh = mp_add(taba + l, taba + l, tabs + l, h, 0);
-    else
-        rh = 0;
-#ifdef DEBUG_SQRTREM
-    mp_print_str_h("q", tabs, l, qh);
-    mp_print_str_h("u", taba + l, h, rh);
-#endif
-    
-    mp_add_ui(tabs + l, qh, h);
-#ifdef DEBUG_SQRTREM
-    mp_print_str_h("s2", tabs, n, sh);
-#endif
-    
-    /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
-    /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
-    if (qh) {
-        c = qh;
-    } else {
-        if (mp_mul(s, taba + n, tabs, l, tabs, l))
-            return -1;
-        c = mp_sub(taba, taba, taba + n, 2 * l, 0);
-    }
-    rh -= mp_sub_ui(taba + 2 * l, c, n - 2 * l);
-    if ((slimb_t)rh < 0) {
-        mp_sub_ui(tabs, 1, n);
-        rh += mp_add_mul1(taba, tabs, n, 2);
-        rh += mp_add_ui(taba, 1, n);
-    }
-    *prh = rh;
-    return 0;
-}
-
-/* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= 2 ^ (LIMB_BITS
-   - 2). Return (s, r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2
-   * s. tabs has n limbs. r is returned in the lower n limbs of
-   taba. Its r[n] is the returned value of the function. */
-/* Algorithm from the article "Karatsuba Square Root" by Paul Zimmermann and
-   inspirated from its GMP implementation */
-int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
-{
-    limb_t tmp_buf1[8];
-    limb_t *tmp_buf;
-    mp_size_t n2;
-    int ret;
-    n2 = n / 2 + 1;
-    if (n2 <= countof(tmp_buf1)) {
-        tmp_buf = tmp_buf1;
-    } else {
-        tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
-        if (!tmp_buf)
-            return -1;
-    }
-    ret = mp_sqrtrem_rec(s, tabs, taba, n, tmp_buf, taba + n);
-    if (tmp_buf != tmp_buf1)
-        bf_free(s, tmp_buf);
-    return ret;
-}
-
-/* Integer square root with remainder. 'a' must be an integer. r =
-   floor(sqrt(a)) and rem = a - r^2.  BF_ST_INEXACT is set if the result
-   is inexact. 'rem' can be NULL if the remainder is not needed. */
-int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
-{
-    int ret;
-    
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-        } else if (a->expn == BF_EXP_INF && a->sign) {
-            goto invalid_op;
-        } else {
-            bf_set(r, a);
-        }
-        if (rem1)
-            bf_set_ui(rem1, 0);
-        ret = 0;
-    } else if (a->sign) {
- invalid_op:
-        bf_set_nan(r);
-        if (rem1)
-            bf_set_ui(rem1, 0);
-        ret = BF_ST_INVALID_OP;
-    } else {
-        bf_t rem_s, *rem;
-        
-        bf_sqrt(r, a, (a->expn + 1) / 2, BF_RNDZ);
-        bf_rint(r, BF_RNDZ);
-        /* see if the result is exact by computing the remainder */
-        if (rem1) {
-            rem = rem1;
-        } else {
-            rem = &rem_s;
-            bf_init(r->ctx, rem);
-        }
-        /* XXX: could avoid recomputing the remainder */
-        bf_mul(rem, r, r, BF_PREC_INF, BF_RNDZ);
-        bf_neg(rem);
-        bf_add(rem, rem, a, BF_PREC_INF, BF_RNDZ);
-        if (bf_is_nan(rem)) {
-            ret = BF_ST_MEM_ERROR;
-            goto done;
-        }
-        if (rem->len != 0) {
-            ret = BF_ST_INEXACT;
-        } else {
-            ret = 0;
-        }
-    done:
-        if (!rem1)
-            bf_delete(rem);
-    }
-    return ret;
-}
-
-int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = a->ctx;
-    int ret;
-
-    assert(r != a);
-
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-        } else if (a->expn == BF_EXP_INF && a->sign) {
-            goto invalid_op;
-        } else {
-            bf_set(r, a);
-        }
-        ret = 0;
-    } else if (a->sign) {
- invalid_op:
-        bf_set_nan(r);
-        ret = BF_ST_INVALID_OP;
-    } else {
-        limb_t *a1;
-        slimb_t n, n1;
-        limb_t res;
-        
-        /* convert the mantissa to an integer with at least 2 *
-           prec + 4 bits */
-        n = (2 * (prec + 2) + 2 * LIMB_BITS - 1) / (2 * LIMB_BITS);
-        if (bf_resize(r, n))
-            goto fail;
-        a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
-        if (!a1)
-            goto fail;
-        n1 = bf_min(2 * n, a->len);
-        memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
-        memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
-        if (a->expn & 1) {
-            res = mp_shr(a1, a1, 2 * n, 1, 0);
-        } else {
-            res = 0;
-        }
-        if (mp_sqrtrem(s, r->tab, a1, n)) {
-            bf_free(s, a1);
-            goto fail;
-        }
-        if (!res) {
-            res = mp_scan_nz(a1, n + 1);
-        }
-        bf_free(s, a1);
-        if (!res) {
-            res = mp_scan_nz(a->tab, a->len - n1);
-        }
-        if (res != 0)
-            r->tab[0] |= 1;
-        r->sign = 0;
-        r->expn = (a->expn + 1) >> 1;
-        ret = bf_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bf_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-                            bf_flags_t flags, bf_op2_func_t *func)
-{
-    bf_t tmp;
-    int ret;
-    
-    if (r == a || r == b) {
-        bf_init(r->ctx, &tmp);
-        ret = func(&tmp, a, b, prec, flags);
-        bf_move(r, &tmp);
-    } else {
-        ret = func(r, a, b, prec, flags);
-    }
-    return ret;
-}
-
-int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-            bf_flags_t flags)
-{
-    return bf_op2(r, a, b, prec, flags, __bf_add);
-}
-
-int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-            bf_flags_t flags)
-{
-    return bf_op2(r, a, b, prec, flags, __bf_sub);
-}
-
-int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-           bf_flags_t flags)
-{
-    return bf_op2(r, a, b, prec, flags, __bf_div);
-}
-
-int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec,
-               bf_flags_t flags)
-{
-    bf_t b;
-    int ret;
-    bf_init(r->ctx, &b);
-    ret = bf_set_ui(&b, b1);
-    ret |= bf_mul(r, a, &b, prec, flags);
-    bf_delete(&b);
-    return ret;
-}
-
-int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
-               bf_flags_t flags)
-{
-    bf_t b;
-    int ret;
-    bf_init(r->ctx, &b);
-    ret = bf_set_si(&b, b1);
-    ret |= bf_mul(r, a, &b, prec, flags);
-    bf_delete(&b);
-    return ret;
-}
-
-int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
-              bf_flags_t flags)
-{
-    bf_t b;
-    int ret;
-    
-    bf_init(r->ctx, &b);
-    ret = bf_set_si(&b, b1);
-    ret |= bf_add(r, a, &b, prec, flags);
-    bf_delete(&b);
-    return ret;
-}
-
-static int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
-                     bf_flags_t flags)
-{
-    int ret, n_bits, i;
-    
-    assert(r != a);
-    if (b == 0)
-        return bf_set_ui(r, 1);
-    ret = bf_set(r, a);
-    n_bits = LIMB_BITS - clz(b);
-    for(i = n_bits - 2; i >= 0; i--) {
-        ret |= bf_mul(r, r, r, prec, flags);
-        if ((b >> i) & 1)
-            ret |= bf_mul(r, r, a, prec, flags);
-    }
-    return ret;
-}
-
-static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
-                        limb_t prec, bf_flags_t flags)
-{
-    bf_t a;
-    int ret;
-    
-#ifdef USE_BF_DEC
-    if (a1 == 10 && b <= LIMB_DIGITS) {
-        /* use precomputed powers. We do not round at this point
-           because we expect the caller to do it */
-        ret = bf_set_ui(r, mp_pow_dec[b]);
-    } else
-#endif        
-    {
-        bf_init(r->ctx, &a);
-        ret = bf_set_ui(&a, a1);
-        ret |= bf_pow_ui(r, &a, b, prec, flags);
-        bf_delete(&a);
-    }
-    return ret;
-}
-
-/* convert to integer (infinite precision) */
-int bf_rint(bf_t *r, int rnd_mode)
-{
-    return bf_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
-}
-
-/* logical operations */
-#define BF_LOGIC_OR  0
-#define BF_LOGIC_XOR 1
-#define BF_LOGIC_AND 2
-
-static inline limb_t bf_logic_op1(limb_t a, limb_t b, int op)
-{
-    switch(op) {
-    case BF_LOGIC_OR:
-        return a | b;
-    case BF_LOGIC_XOR:
-        return a ^ b;
-    default:
-    case BF_LOGIC_AND:
-        return a & b;
-    }
-}
-
-static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
-{
-    bf_t b1_s, a1_s, *a, *b;
-    limb_t a_sign, b_sign, r_sign;
-    slimb_t l, i, a_bit_offset, b_bit_offset;
-    limb_t v1, v2, v1_mask, v2_mask, r_mask;
-    int ret;
-    
-    assert(r != a1 && r != b1);
-
-    if (a1->expn <= 0)
-        a_sign = 0; /* minus zero is considered as positive */
-    else
-        a_sign = a1->sign;
-
-    if (b1->expn <= 0)
-        b_sign = 0; /* minus zero is considered as positive */
-    else
-        b_sign = b1->sign;
-    
-    if (a_sign) {
-        a = &a1_s;
-        bf_init(r->ctx, a);
-        if (bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ)) {
-            b = NULL;
-            goto fail;
-        }
-    } else {
-        a = (bf_t *)a1;
-    }
-
-    if (b_sign) {
-        b = &b1_s;
-        bf_init(r->ctx, b);
-        if (bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ))
-            goto fail;
-    } else {
-        b = (bf_t *)b1;
-    }
-    
-    r_sign = bf_logic_op1(a_sign, b_sign, op);
-    if (op == BF_LOGIC_AND && r_sign == 0) {
-        /* no need to compute extra zeros for and */
-        if (a_sign == 0 && b_sign == 0)
-            l = bf_min(a->expn, b->expn);
-        else if (a_sign == 0)
-            l = a->expn;
-        else
-            l = b->expn;
-    } else {
-        l = bf_max(a->expn, b->expn);
-    }
-    /* Note: a or b can be zero */
-    l = (bf_max(l, 1) + LIMB_BITS - 1) / LIMB_BITS;
-    if (bf_resize(r, l))
-        goto fail;
-    a_bit_offset = a->len * LIMB_BITS - a->expn;
-    b_bit_offset = b->len * LIMB_BITS - b->expn;
-    v1_mask = -a_sign;
-    v2_mask = -b_sign;
-    r_mask = -r_sign;
-    for(i = 0; i < l; i++) {
-        v1 = get_bits(a->tab, a->len, a_bit_offset + i * LIMB_BITS) ^ v1_mask;
-        v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS) ^ v2_mask;
-        r->tab[i] = bf_logic_op1(v1, v2, op) ^ r_mask;
-    }
-    r->expn = l * LIMB_BITS;
-    r->sign = r_sign;
-    bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ); /* cannot fail */
-    if (r_sign) {
-        if (bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ))
-            goto fail;
-    }
-    ret = 0;
- done:
-    if (a == &a1_s)
-        bf_delete(a);
-    if (b == &b1_s)
-        bf_delete(b);
-    return ret;
- fail:
-    bf_set_nan(r);
-    ret = BF_ST_MEM_ERROR;
-    goto done;
-}
-
-/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
-int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b)
-{
-    return bf_logic_op(r, a, b, BF_LOGIC_OR);
-}
-
-/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
-int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b)
-{
-    return bf_logic_op(r, a, b, BF_LOGIC_XOR);
-}
-
-/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
-int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b)
-{
-    return bf_logic_op(r, a, b, BF_LOGIC_AND);
-}
-
-/* conversion between fixed size types */
-
-typedef union {
-    double d;
-    uint64_t u;
-} Float64Union;
-
-int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode)
-{
-    Float64Union u;
-    int e, ret;
-    uint64_t m;
-    
-    ret = 0;
-    if (a->expn == BF_EXP_NAN) {
-        u.u = 0x7ff8000000000000; /* quiet nan */
-    } else {
-        bf_t b_s, *b = &b_s;
-        
-        bf_init(a->ctx, b);
-        bf_set(b, a);
-        if (bf_is_finite(b)) {
-            ret = bf_round(b, 53, rnd_mode | BF_FLAG_SUBNORMAL | bf_set_exp_bits(11));
-        }
-        if (b->expn == BF_EXP_INF) {
-            e = (1 << 11) - 1;
-            m = 0;
-        } else if (b->expn == BF_EXP_ZERO) {
-            e = 0;
-            m = 0;
-        } else {
-            e = b->expn + 1023 - 1;
-#if LIMB_BITS == 32
-            if (b->len == 2) {
-                m = ((uint64_t)b->tab[1] << 32) | b->tab[0];
-            } else {
-                m = ((uint64_t)b->tab[0] << 32);
-            }
-#else
-            m = b->tab[0];
-#endif
-            if (e <= 0) {
-                /* subnormal */
-                m = m >> (12 - e);
-                e = 0;
-            } else {
-                m = (m << 1) >> 12;
-            }
-        }
-        u.u = m | ((uint64_t)e << 52) | ((uint64_t)b->sign << 63);
-        bf_delete(b);
-    }
-    *pres = u.d;
-    return ret;
-}
-
-int bf_set_float64(bf_t *a, double d)
-{
-    Float64Union u;
-    uint64_t m;
-    int shift, e, sgn;
-    
-    u.d = d;
-    sgn = u.u >> 63;
-    e = (u.u >> 52) & ((1 << 11) - 1);
-    m = u.u & (((uint64_t)1 << 52) - 1);
-    if (e == ((1 << 11) - 1)) {
-        if (m != 0) {
-            bf_set_nan(a);
-        } else {
-            bf_set_inf(a, sgn);
-        }
-    } else if (e == 0) {
-        if (m == 0) {
-            bf_set_zero(a, sgn);
-        } else {
-            /* subnormal number */
-            m <<= 12;
-            shift = clz64(m);
-            m <<= shift;
-            e = -shift;
-            goto norm;
-        }
-    } else {
-        m = (m << 11) | ((uint64_t)1 << 63);
-    norm:
-        a->expn = e - 1023 + 1;
-#if LIMB_BITS == 32
-        if (bf_resize(a, 2))
-            goto fail;
-        a->tab[0] = m;
-        a->tab[1] = m >> 32;
-#else
-        if (bf_resize(a, 1))
-            goto fail;
-        a->tab[0] = m;
-#endif
-        a->sign = sgn;
-    }
-    return 0;
-fail:
-    bf_set_nan(a);
-    return BF_ST_MEM_ERROR;
-}
-
-/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
-   is an overflow and 0 otherwise. */
-int bf_get_int32(int *pres, const bf_t *a, int flags)
-{
-    uint32_t v;
-    int ret;
-    if (a->expn >= BF_EXP_INF) {
-        ret = BF_ST_INVALID_OP;
-        if (flags & BF_GET_INT_MOD) {
-            v = 0;
-        } else if (a->expn == BF_EXP_INF) {
-            v = (uint32_t)INT32_MAX + a->sign;
-        } else {
-            v = INT32_MAX;
-        }
-    } else if (a->expn <= 0) {
-        v = 0;
-        ret = 0;
-    } else if (a->expn <= 31) {
-        v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
-        if (a->sign)
-            v = -v;
-        ret = 0;
-    } else if (!(flags & BF_GET_INT_MOD)) {
-        ret = BF_ST_INVALID_OP;
-        if (a->sign) {
-            v = (uint32_t)INT32_MAX + 1;
-            if (a->expn == 32 && 
-                (a->tab[a->len - 1] >> (LIMB_BITS - 32)) == v) {
-                ret = 0;
-            }
-        } else {
-            v = INT32_MAX;
-        }
-    } else {
-        v = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn); 
-        if (a->sign)
-            v = -v;
-        ret = 0;
-    }
-    *pres = v;
-    return ret;
-}
-
-/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
-   is an overflow and 0 otherwise. */
-int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
-{
-    uint64_t v;
-    int ret;
-    if (a->expn >= BF_EXP_INF) {
-        ret = BF_ST_INVALID_OP;
-        if (flags & BF_GET_INT_MOD) {
-            v = 0;
-        } else if (a->expn == BF_EXP_INF) {
-            v = (uint64_t)INT64_MAX + a->sign;
-        } else {
-            v = INT64_MAX;
-        }
-    } else if (a->expn <= 0) {
-        v = 0;
-        ret = 0;
-    } else if (a->expn <= 63) {
-#if LIMB_BITS == 32
-        if (a->expn <= 32)
-            v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
-        else
-            v = (((uint64_t)a->tab[a->len - 1] << 32) |
-                 get_limbz(a, a->len - 2)) >> (64 - a->expn);
-#else
-        v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
-#endif
-        if (a->sign)
-            v = -v;
-        ret = 0;
-    } else if (!(flags & BF_GET_INT_MOD)) {
-        ret = BF_ST_INVALID_OP;
-        if (a->sign) {
-            uint64_t v1;
-            v = (uint64_t)INT64_MAX + 1;
-            if (a->expn == 64) {
-                v1 = a->tab[a->len - 1];
-#if LIMB_BITS == 32
-                v1 = (v1 << 32) | get_limbz(a, a->len - 2);
-#endif
-                if (v1 == v)
-                    ret = 0;
-            }
-        } else {
-            v = INT64_MAX;
-        }
-    } else {
-        slimb_t bit_pos = a->len * LIMB_BITS - a->expn;
-        v = get_bits(a->tab, a->len, bit_pos); 
-#if LIMB_BITS == 32
-        v |= (uint64_t)get_bits(a->tab, a->len, bit_pos + 32) << 32;
-#endif
-        if (a->sign)
-            v = -v;
-        ret = 0;
-    }
-    *pres = v;
-    return ret;
-}
-
-/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
-   is an overflow and 0 otherwise. */
-int bf_get_uint64(uint64_t *pres, const bf_t *a)
-{
-    uint64_t v;
-    int ret;
-    if (a->expn == BF_EXP_NAN) {
-        goto overflow;
-    } else if (a->expn <= 0) {
-        v = 0;
-        ret = 0;
-    } else if (a->sign) {
-        v = 0;
-        ret = BF_ST_INVALID_OP;
-    } else if (a->expn <= 64) {
-#if LIMB_BITS == 32
-        if (a->expn <= 32)
-            v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
-        else
-            v = (((uint64_t)a->tab[a->len - 1] << 32) |
-                 get_limbz(a, a->len - 2)) >> (64 - a->expn);
-#else
-        v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
-#endif
-        ret = 0;
-    } else {
-    overflow:
-        v = UINT64_MAX;
-        ret = BF_ST_INVALID_OP;
-    }
-    *pres = v;
-    return ret;
-}
-
-/* base conversion from radix */
-
-static const uint8_t digits_per_limb_table[BF_RADIX_MAX - 1] = {
-#if LIMB_BITS == 32
-32,20,16,13,12,11,10,10, 9, 9, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-#else
-64,40,32,27,24,22,21,20,19,18,17,17,16,16,16,15,15,15,14,14,14,14,13,13,13,13,13,13,13,12,12,12,12,12,12,
-#endif
-};
-
-static limb_t get_limb_radix(int radix)
-{
-    int i, k;
-    limb_t radixl;
-    
-    k = digits_per_limb_table[radix - 2];
-    radixl = radix;
-    for(i = 1; i < k; i++)
-        radixl *= radix;
-    return radixl;
-}
-
-/* return != 0 if error */
-static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
-                                     limb_t n, int level, limb_t n0,
-                                     limb_t radix, bf_t *pow_tab)
-{
-    int ret;
-    if (n == 1) {
-        ret = bf_set_ui(r, tab[0]);
-    } else {
-        bf_t T_s, *T = &T_s, *B;
-        limb_t n1, n2;
-        
-        n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
-        n1 = n - n2;
-        //        printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
-        B = &pow_tab[level];
-        if (B->len == 0) {
-            ret = bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
-            if (ret)
-                return ret;
-        }
-        ret = bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
-                                        radix, pow_tab);
-        if (ret)
-            return ret;
-        ret = bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
-        if (ret)
-            return ret;
-        bf_init(r->ctx, T);
-        ret = bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
-                                        radix, pow_tab);
-        if (!ret)
-            ret = bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
-        bf_delete(T);
-    }
-    return ret;
-    //    bf_print_str("  r=", r);
-}
-
-/* return 0 if OK != 0 if memory error */
-static int bf_integer_from_radix(bf_t *r, const limb_t *tab,
-                                 limb_t n, limb_t radix)
-{
-    bf_context_t *s = r->ctx;
-    int pow_tab_len, i, ret;
-    limb_t radixl;
-    bf_t *pow_tab;
-    
-    radixl = get_limb_radix(radix);
-    pow_tab_len = ceil_log2(n) + 2; /* XXX: check */
-    pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
-    if (!pow_tab)
-        return -1;
-    for(i = 0; i < pow_tab_len; i++)
-        bf_init(r->ctx, &pow_tab[i]);
-    ret = bf_integer_from_radix_rec(r, tab, n, 0, n, radixl, pow_tab);
-    for(i = 0; i < pow_tab_len; i++) {
-        bf_delete(&pow_tab[i]);
-    }
-    bf_free(s, pow_tab);
-    return ret;
-}
-
-/* compute and round T * radix^expn. */
-int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
-                     slimb_t expn, limb_t prec, bf_flags_t flags)
-{
-    int ret, expn_sign, overflow;
-    slimb_t e, extra_bits, prec1, ziv_extra_bits;
-    bf_t B_s, *B = &B_s;
-
-    if (T->len == 0) {
-        return bf_set(r, T);
-    } else if (expn == 0) {
-        ret = bf_set(r, T);
-        ret |= bf_round(r, prec, flags);
-        return ret;
-    }
-
-    e = expn;
-    expn_sign = 0;
-    if (e < 0) {
-        e = -e;
-        expn_sign = 1;
-    }
-    bf_init(r->ctx, B);
-    if (prec == BF_PREC_INF) {
-        /* infinite precision: only used if the result is known to be exact */
-        ret = bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
-        if (expn_sign) {
-            ret |= bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
-        } else {
-            ret |= bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
-        }
-    } else {
-        ziv_extra_bits = 16;
-        for(;;) {
-            prec1 = prec + ziv_extra_bits;
-            /* XXX: correct overflow/underflow handling */
-            /* XXX: rigorous error analysis needed */
-            extra_bits = ceil_log2(e) * 2 + 1;
-            ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
-            overflow = !bf_is_finite(B);
-            /* XXX: if bf_pow_ui_ui returns an exact result, can stop
-               after the next operation */
-            if (expn_sign)
-                ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
-            else
-                ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
-            if (ret & BF_ST_MEM_ERROR)
-                break;
-            if ((ret & BF_ST_INEXACT) &&
-                !bf_can_round(r, prec, flags & BF_RND_MASK, prec1) &&
-                !overflow) {
-                /* and more precision and retry */
-                ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
-            } else {
-                /* XXX: need to use __bf_round() to pass the inexact
-                   flag for the subnormal case */
-                ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
-                break;
-            }
-        }
-    }
-    bf_delete(B);
-    return ret;
-}
-
-static inline int to_digit(int c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    else if (c >= 'A' && c <= 'Z')
-        return c - 'A' + 10;
-    else if (c >= 'a' && c <= 'z')
-        return c - 'a' + 10;
-    else
-        return 36;
-}
-
-/* add a limb at 'pos' and decrement pos. new space is created if
-   needed. Return 0 if OK, -1 if memory error */
-static int bf_add_limb(bf_t *a, slimb_t *ppos, limb_t v)
-{
-    slimb_t pos;
-    pos = *ppos;
-    if (unlikely(pos < 0)) {
-        limb_t new_size, d, *new_tab;
-        new_size = bf_max(a->len + 1, a->len * 3 / 2);
-        new_tab = bf_realloc(a->ctx, a->tab, sizeof(limb_t) * new_size);
-        if (!new_tab)
-            return -1;
-        a->tab = new_tab;
-        d = new_size - a->len;
-        memmove(a->tab + d, a->tab, a->len * sizeof(limb_t));
-        a->len = new_size;
-        pos += d;
-    }
-    a->tab[pos--] = v;
-    *ppos = pos;
-    return 0;
-}
-
-static int bf_tolower(int c)
-{
-    if (c >= 'A' && c <= 'Z')
-        c = c - 'A' + 'a';
-    return c;
-}
-
-static int strcasestart(const char *str, const char *val, const char **ptr)
-{
-    const char *p, *q;
-    p = str;
-    q = val;
-    while (*q != '\0') {
-        if (bf_tolower(*p) != *q)
-            return 0;
-        p++;
-        q++;
-    }
-    if (ptr)
-        *ptr = p;
-    return 1;
-}
-
-static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
-                            const char *str, const char **pnext, int radix,
-                            limb_t prec, bf_flags_t flags, BOOL is_dec)
-{
-    const char *p, *p_start;
-    int is_neg, radix_bits, exp_is_neg, ret, digits_per_limb, shift;
-    limb_t cur_limb;
-    slimb_t pos, expn, int_len, digit_count;
-    BOOL has_decpt, is_bin_exp;
-    bf_t a_s, *a;
-    
-    *pexponent = 0;
-    p = str;
-    if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
-        strcasestart(p, "nan", &p)) {
-        bf_set_nan(r);
-        ret = 0;
-        goto done;
-    }
-    is_neg = 0;
-    
-    if (p[0] == '+') {
-        p++;
-        p_start = p;
-    } else if (p[0] == '-') {
-        is_neg = 1;
-        p++;
-        p_start = p;
-    } else {
-        p_start = p;
-    }
-    if (p[0] == '0') {
-        if ((p[1] == 'x' || p[1] == 'X') &&
-            (radix == 0 || radix == 16) &&
-            !(flags & BF_ATOF_NO_HEX)) {
-            radix = 16;
-            p += 2;
-        } else if ((p[1] == 'o' || p[1] == 'O') &&
-                   radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
-            p += 2;
-            radix = 8;
-        } else if ((p[1] == 'b' || p[1] == 'B') &&
-                   radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
-            p += 2;
-            radix = 2;
-        } else {
-            goto no_prefix;
-        }
-        /* there must be a digit after the prefix */
-        if (to_digit((uint8_t)*p) >= radix) {
-            bf_set_nan(r);
-            ret = 0;
-            goto done;
-        }
-    no_prefix: ;
-    } else {
-        if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
-            strcasestart(p, "inf", &p)) {
-            bf_set_inf(r, is_neg);
-            ret = 0;
-            goto done;
-        }
-    }
-    
-    if (radix == 0)
-        radix = 10;
-    if (is_dec) {
-        assert(radix == 10);
-        radix_bits = 0;
-        a = r;
-    } else if ((radix & (radix - 1)) != 0) {
-        radix_bits = 0; /* base is not a power of two */
-        a = &a_s;
-        bf_init(r->ctx, a);
-    } else {
-        radix_bits = ceil_log2(radix);
-        a = r;
-    }
-
-    /* skip leading zeros */
-    /* XXX: could also skip zeros after the decimal point */
-    while (*p == '0')
-        p++;
-
-    if (radix_bits) {
-        shift = digits_per_limb = LIMB_BITS;
-    } else {
-        radix_bits = 0;
-        shift = digits_per_limb = digits_per_limb_table[radix - 2];
-    }
-    cur_limb = 0;
-    bf_resize(a, 1);
-    pos = 0;
-    has_decpt = FALSE;
-    int_len = digit_count = 0;
-    for(;;) {
-        limb_t c;
-        if (*p == '.' && (p > p_start || to_digit(p[1]) < radix)) {
-            if (has_decpt)
-                break;
-            has_decpt = TRUE;
-            int_len = digit_count;
-            p++;
-        }
-        c = to_digit(*p);
-        if (c >= radix)
-            break;
-        digit_count++;
-        p++;
-        if (radix_bits) {
-            shift -= radix_bits;
-            if (shift <= 0) {
-                cur_limb |= c >> (-shift);
-                if (bf_add_limb(a, &pos, cur_limb))
-                    goto mem_error;
-                if (shift < 0)
-                    cur_limb = c << (LIMB_BITS + shift);
-                else
-                    cur_limb = 0;
-                shift += LIMB_BITS;
-            } else {
-                cur_limb |= c << shift;
-            }
-        } else {
-            cur_limb = cur_limb * radix + c;
-            shift--;
-            if (shift == 0) {
-                if (bf_add_limb(a, &pos, cur_limb))
-                    goto mem_error;
-                shift = digits_per_limb;
-                cur_limb = 0;
-            }
-        }
-    }
-    if (!has_decpt)
-        int_len = digit_count;
-
-    /* add the last limb and pad with zeros */
-    if (shift != digits_per_limb) {
-        if (radix_bits == 0) {
-            while (shift != 0) {
-                cur_limb *= radix;
-                shift--;
-            }
-        }
-        if (bf_add_limb(a, &pos, cur_limb)) {
-        mem_error:
-            ret = BF_ST_MEM_ERROR;
-            if (!radix_bits)
-                bf_delete(a);
-            bf_set_nan(r);
-            goto done;
-        }
-    }
-            
-    /* reset the next limbs to zero (we prefer to reallocate in the
-       renormalization) */
-    memset(a->tab, 0, (pos + 1) * sizeof(limb_t));
-
-    if (p == p_start) {
-        ret = 0;
-        if (!radix_bits)
-            bf_delete(a);
-        bf_set_nan(r);
-        goto done;
-    }
-
-    /* parse the exponent, if any */
-    expn = 0;
-    is_bin_exp = FALSE;
-    if (((radix == 10 && (*p == 'e' || *p == 'E')) ||
-         (radix != 10 && (*p == '@' ||
-                          (radix_bits && (*p == 'p' || *p == 'P'))))) &&
-        p > p_start) {
-        is_bin_exp = (*p == 'p' || *p == 'P');
-        p++;
-        exp_is_neg = 0;
-        if (*p == '+') {
-            p++;
-        } else if (*p == '-') {
-            exp_is_neg = 1;
-            p++;
-        }
-        for(;;) {
-            int c;
-            c = to_digit(*p);
-            if (c >= 10)
-                break;
-            if (unlikely(expn > ((BF_RAW_EXP_MAX - 2 - 9) / 10))) {
-                /* exponent overflow */
-                if (exp_is_neg) {
-                    bf_set_zero(r, is_neg);
-                    ret = BF_ST_UNDERFLOW | BF_ST_INEXACT;
-                } else {
-                    bf_set_inf(r, is_neg);
-                    ret = BF_ST_OVERFLOW | BF_ST_INEXACT;
-                }
-                goto done;
-            }
-            p++;
-            expn = expn * 10 + c;
-        }
-        if (exp_is_neg)
-            expn = -expn;
-    }
-    if (is_dec) {
-        a->expn = expn + int_len;
-        a->sign = is_neg;
-        ret = bfdec_normalize_and_round((bfdec_t *)a, prec, flags);
-    } else if (radix_bits) {
-        /* XXX: may overflow */
-        if (!is_bin_exp)
-            expn *= radix_bits; 
-        a->expn = expn + (int_len * radix_bits);
-        a->sign = is_neg;
-        ret = bf_normalize_and_round(a, prec, flags);
-    } else {
-        limb_t l;
-        pos++;
-        l = a->len - pos; /* number of limbs */
-        if (l == 0) {
-            bf_set_zero(r, is_neg);
-            ret = 0;
-        } else {
-            bf_t T_s, *T = &T_s;
-
-            expn -= l * digits_per_limb - int_len;
-            bf_init(r->ctx, T);
-            if (bf_integer_from_radix(T, a->tab + pos, l, radix)) {
-                bf_set_nan(r);
-                ret = BF_ST_MEM_ERROR;
-            } else {
-                T->sign = is_neg;
-                if (flags & BF_ATOF_EXPONENT) {
-                    /* return the exponent */
-                    *pexponent = expn;
-                    ret = bf_set(r, T);
-                } else {
-                    ret = bf_mul_pow_radix(r, T, radix, expn, prec, flags);
-                }
-            }
-            bf_delete(T);
-        }
-        bf_delete(a);
-    }
- done:
-    if (pnext)
-        *pnext = p;
-    return ret;
-}
-
-/* 
-   Return (status, n, exp). 'status' is the floating point status. 'n'
-   is the parsed number. 
-
-   If (flags & BF_ATOF_EXPONENT) and if the radix is not a power of
-   two, the parsed number is equal to r *
-   (*pexponent)^radix. Otherwise *pexponent = 0.
-*/
-int bf_atof2(bf_t *r, slimb_t *pexponent,
-             const char *str, const char **pnext, int radix,
-             limb_t prec, bf_flags_t flags)
-{
-    return bf_atof_internal(r, pexponent, str, pnext, radix, prec, flags,
-                            FALSE);
-}
-
-int bf_atof(bf_t *r, const char *str, const char **pnext, int radix,
-            limb_t prec, bf_flags_t flags)
-{
-    slimb_t dummy_exp;
-    return bf_atof_internal(r, &dummy_exp, str, pnext, radix, prec, flags, FALSE);
-}
-
-/* base conversion to radix */
-
-#if LIMB_BITS == 64
-#define RADIXL_10 UINT64_C(10000000000000000000)
-#else
-#define RADIXL_10 UINT64_C(1000000000)
-#endif
-
-static const uint32_t inv_log2_radix[BF_RADIX_MAX - 1][LIMB_BITS / 32 + 1] = {
-#if LIMB_BITS == 32
-{ 0x80000000, 0x00000000,},
-{ 0x50c24e60, 0xd4d4f4a7,},
-{ 0x40000000, 0x00000000,},
-{ 0x372068d2, 0x0a1ee5ca,},
-{ 0x3184648d, 0xb8153e7a,},
-{ 0x2d983275, 0x9d5369c4,},
-{ 0x2aaaaaaa, 0xaaaaaaab,},
-{ 0x28612730, 0x6a6a7a54,},
-{ 0x268826a1, 0x3ef3fde6,},
-{ 0x25001383, 0xbac8a744,},
-{ 0x23b46706, 0x82c0c709,},
-{ 0x229729f1, 0xb2c83ded,},
-{ 0x219e7ffd, 0xa5ad572b,},
-{ 0x20c33b88, 0xda7c29ab,},
-{ 0x20000000, 0x00000000,},
-{ 0x1f50b57e, 0xac5884b3,},
-{ 0x1eb22cc6, 0x8aa6e26f,},
-{ 0x1e21e118, 0x0c5daab2,},
-{ 0x1d9dcd21, 0x439834e4,},
-{ 0x1d244c78, 0x367a0d65,},
-{ 0x1cb40589, 0xac173e0c,},
-{ 0x1c4bd95b, 0xa8d72b0d,},
-{ 0x1bead768, 0x98f8ce4c,},
-{ 0x1b903469, 0x050f72e5,},
-{ 0x1b3b433f, 0x2eb06f15,},
-{ 0x1aeb6f75, 0x9c46fc38,},
-{ 0x1aa038eb, 0x0e3bfd17,},
-{ 0x1a593062, 0xb38d8c56,},
-{ 0x1a15f4c3, 0x2b95a2e6,},
-{ 0x19d630dc, 0xcc7ddef9,},
-{ 0x19999999, 0x9999999a,},
-{ 0x195fec80, 0x8a609431,},
-{ 0x1928ee7b, 0x0b4f22f9,},
-{ 0x18f46acf, 0x8c06e318,},
-{ 0x18c23246, 0xdc0a9f3d,},
-#else
-{ 0x80000000, 0x00000000, 0x00000000,},
-{ 0x50c24e60, 0xd4d4f4a7, 0x021f57bc,},
-{ 0x40000000, 0x00000000, 0x00000000,},
-{ 0x372068d2, 0x0a1ee5ca, 0x19ea911b,},
-{ 0x3184648d, 0xb8153e7a, 0x7fc2d2e1,},
-{ 0x2d983275, 0x9d5369c4, 0x4dec1661,},
-{ 0x2aaaaaaa, 0xaaaaaaaa, 0xaaaaaaab,},
-{ 0x28612730, 0x6a6a7a53, 0x810fabde,},
-{ 0x268826a1, 0x3ef3fde6, 0x23e2566b,},
-{ 0x25001383, 0xbac8a744, 0x385a3349,},
-{ 0x23b46706, 0x82c0c709, 0x3f891718,},
-{ 0x229729f1, 0xb2c83ded, 0x15fba800,},
-{ 0x219e7ffd, 0xa5ad572a, 0xe169744b,},
-{ 0x20c33b88, 0xda7c29aa, 0x9bddee52,},
-{ 0x20000000, 0x00000000, 0x00000000,},
-{ 0x1f50b57e, 0xac5884b3, 0x70e28eee,},
-{ 0x1eb22cc6, 0x8aa6e26f, 0x06d1a2a2,},
-{ 0x1e21e118, 0x0c5daab1, 0x81b4f4bf,},
-{ 0x1d9dcd21, 0x439834e3, 0x81667575,},
-{ 0x1d244c78, 0x367a0d64, 0xc8204d6d,},
-{ 0x1cb40589, 0xac173e0c, 0x3b7b16ba,},
-{ 0x1c4bd95b, 0xa8d72b0d, 0x5879f25a,},
-{ 0x1bead768, 0x98f8ce4c, 0x66cc2858,},
-{ 0x1b903469, 0x050f72e5, 0x0cf5488e,},
-{ 0x1b3b433f, 0x2eb06f14, 0x8c89719c,},
-{ 0x1aeb6f75, 0x9c46fc37, 0xab5fc7e9,},
-{ 0x1aa038eb, 0x0e3bfd17, 0x1bd62080,},
-{ 0x1a593062, 0xb38d8c56, 0x7998ab45,},
-{ 0x1a15f4c3, 0x2b95a2e6, 0x46aed6a0,},
-{ 0x19d630dc, 0xcc7ddef9, 0x5aadd61b,},
-{ 0x19999999, 0x99999999, 0x9999999a,},
-{ 0x195fec80, 0x8a609430, 0xe1106014,},
-{ 0x1928ee7b, 0x0b4f22f9, 0x5f69791d,},
-{ 0x18f46acf, 0x8c06e318, 0x4d2aeb2c,},
-{ 0x18c23246, 0xdc0a9f3d, 0x3fe16970,},
-#endif
-};
-
-static const limb_t log2_radix[BF_RADIX_MAX - 1] = {
-#if LIMB_BITS == 32
-0x20000000,
-0x32b80347,
-0x40000000,
-0x4a4d3c26,
-0x52b80347,
-0x59d5d9fd,
-0x60000000,
-0x6570068e,
-0x6a4d3c26,
-0x6eb3a9f0,
-0x72b80347,
-0x766a008e,
-0x79d5d9fd,
-0x7d053f6d,
-0x80000000,
-0x82cc7edf,
-0x8570068e,
-0x87ef05ae,
-0x8a4d3c26,
-0x8c8ddd45,
-0x8eb3a9f0,
-0x90c10501,
-0x92b80347,
-0x949a784c,
-0x966a008e,
-0x982809d6,
-0x99d5d9fd,
-0x9b74948f,
-0x9d053f6d,
-0x9e88c6b3,
-0xa0000000,
-0xa16bad37,
-0xa2cc7edf,
-0xa4231623,
-0xa570068e,
-#else
-0x2000000000000000,
-0x32b803473f7ad0f4,
-0x4000000000000000,
-0x4a4d3c25e68dc57f,
-0x52b803473f7ad0f4,
-0x59d5d9fd5010b366,
-0x6000000000000000,
-0x6570068e7ef5a1e8,
-0x6a4d3c25e68dc57f,
-0x6eb3a9f01975077f,
-0x72b803473f7ad0f4,
-0x766a008e4788cbcd,
-0x79d5d9fd5010b366,
-0x7d053f6d26089673,
-0x8000000000000000,
-0x82cc7edf592262d0,
-0x8570068e7ef5a1e8,
-0x87ef05ae409a0289,
-0x8a4d3c25e68dc57f,
-0x8c8ddd448f8b845a,
-0x8eb3a9f01975077f,
-0x90c10500d63aa659,
-0x92b803473f7ad0f4,
-0x949a784bcd1b8afe,
-0x966a008e4788cbcd,
-0x982809d5be7072dc,
-0x99d5d9fd5010b366,
-0x9b74948f5532da4b,
-0x9d053f6d26089673,
-0x9e88c6b3626a72aa,
-0xa000000000000000,
-0xa16bad3758efd873,
-0xa2cc7edf592262d0,
-0xa4231623369e78e6,
-0xa570068e7ef5a1e8,
-#endif
-};
-
-/* compute floor(a*b) or ceil(a*b) with b = log2(radix) or
-   b=1/log2(radix). For is_inv = 0, strict accuracy is not guaranteed
-   when radix is not a power of two. */
-slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
-                          int is_ceil1)
-{
-    int is_neg;
-    limb_t a;
-    BOOL is_ceil;
-
-    is_ceil = is_ceil1;
-    a = a1;
-    if (a1 < 0) {
-        a = -a;
-        is_neg = 1;
-    } else {
-        is_neg = 0;
-    }
-    is_ceil ^= is_neg;
-    if ((radix & (radix - 1)) == 0) {
-        int radix_bits;
-        /* radix is a power of two */
-        radix_bits = ceil_log2(radix);
-        if (is_inv) {
-            if (is_ceil)
-                a += radix_bits - 1;
-            a = a / radix_bits;
-        } else {
-            a = a * radix_bits;
-        }
-    } else {
-        const uint32_t *tab;
-        limb_t b0, b1;
-        dlimb_t t;
-        
-        if (is_inv) {
-            tab = inv_log2_radix[radix - 2];
-#if LIMB_BITS == 32
-            b1 = tab[0];
-            b0 = tab[1];
-#else
-            b1 = ((limb_t)tab[0] << 32) | tab[1];
-            b0 = (limb_t)tab[2] << 32;
-#endif
-            t = (dlimb_t)b0 * (dlimb_t)a;
-            t = (dlimb_t)b1 * (dlimb_t)a + (t >> LIMB_BITS);
-            a = t >> (LIMB_BITS - 1);
-        } else {
-            b0 = log2_radix[radix - 2];
-            t = (dlimb_t)b0 * (dlimb_t)a;
-            a = t >> (LIMB_BITS - 3);
-        }
-        /* a = floor(result) and 'result' cannot be an integer */
-        a += is_ceil;
-    }
-    if (is_neg)
-        a = -a;
-    return a;
-}
-
-/* 'n' is the number of output limbs */
-static int bf_integer_to_radix_rec(bf_t *pow_tab,
-                                   limb_t *out, const bf_t *a, limb_t n,
-                                   int level, limb_t n0, limb_t radixl,
-                                   unsigned int radixl_bits)
-{
-    limb_t n1, n2, q_prec;
-    int ret;
-    
-    assert(n >= 1);
-    if (n == 1) {
-        out[0] = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
-    } else if (n == 2) {
-        dlimb_t t;
-        slimb_t pos;
-        pos = a->len * LIMB_BITS - a->expn;
-        t = ((dlimb_t)get_bits(a->tab, a->len, pos + LIMB_BITS) << LIMB_BITS) |
-            get_bits(a->tab, a->len, pos);
-        if (likely(radixl == RADIXL_10)) {
-            /* use division by a constant when possible */
-            out[0] = t % RADIXL_10;
-            out[1] = t / RADIXL_10;
-        } else {
-            out[0] = t % radixl;
-            out[1] = t / radixl;
-        }
-    } else {
-        bf_t Q, R, *B, *B_inv;
-        int q_add;
-        bf_init(a->ctx, &Q);
-        bf_init(a->ctx, &R);
-        n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
-        n1 = n - n2;
-        B = &pow_tab[2 * level];
-        B_inv = &pow_tab[2 * level + 1];
-        ret = 0;
-        if (B->len == 0) {
-            /* compute BASE^n2 */
-            ret |= bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
-            /* we use enough bits for the maximum possible 'n1' value,
-               i.e. n2 + 1 */
-            ret |= bf_set_ui(&R, 1);
-            ret |= bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
-        }
-        //        printf("%d: n1=% " PRId64 " n2=%" PRId64 "\n", level, n1, n2);
-        q_prec = n1 * radixl_bits;
-        ret |= bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
-        ret |= bf_rint(&Q, BF_RNDZ);
-        
-        ret |= bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
-        ret |= bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
-
-        if (ret & BF_ST_MEM_ERROR)
-            goto fail;
-        /* adjust if necessary */
-        q_add = 0;
-        while (R.sign && R.len != 0) {
-            if (bf_add(&R, &R, B, BF_PREC_INF, BF_RNDZ))
-                goto fail;
-            q_add--;
-        }
-        while (bf_cmpu(&R, B) >= 0) {
-            if (bf_sub(&R, &R, B, BF_PREC_INF, BF_RNDZ))
-                goto fail;
-            q_add++;
-        }
-        if (q_add != 0) {
-            if (bf_add_si(&Q, &Q, q_add, BF_PREC_INF, BF_RNDZ))
-                goto fail;
-        }
-        if (bf_integer_to_radix_rec(pow_tab, out + n2, &Q, n1, level + 1, n0,
-                                    radixl, radixl_bits))
-            goto fail;
-        if (bf_integer_to_radix_rec(pow_tab, out, &R, n2, level + 1, n0,
-                                    radixl, radixl_bits)) {
-        fail:
-            bf_delete(&Q);
-            bf_delete(&R);
-            return -1;
-        }
-        bf_delete(&Q);
-        bf_delete(&R);
-    }
-    return 0;
-}
-
-/* return 0 if OK != 0 if memory error */
-static int bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
-{
-    bf_context_t *s = r->ctx;
-    limb_t r_len;
-    bf_t *pow_tab;
-    int i, pow_tab_len, ret;
-    
-    r_len = r->len;
-    pow_tab_len = (ceil_log2(r_len) + 2) * 2; /* XXX: check */
-    pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
-    if (!pow_tab)
-        return -1;
-    for(i = 0; i < pow_tab_len; i++)
-        bf_init(r->ctx, &pow_tab[i]);
-
-    ret = bf_integer_to_radix_rec(pow_tab, r->tab, a, r_len, 0, r_len, radixl,
-                                  ceil_log2(radixl));
-
-    for(i = 0; i < pow_tab_len; i++) {
-        bf_delete(&pow_tab[i]);
-    }
-    bf_free(s, pow_tab);
-    return ret;
-}
-
-/* a must be >= 0. 'P' is the wanted number of digits in radix
-   'radix'. 'r' is the mantissa represented as an integer. *pE
-   contains the exponent. Return != 0 if memory error. */
-static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
-                               const bf_t *a, int radix,
-                               limb_t P, bf_rnd_t rnd_mode,
-                               BOOL is_fixed_exponent)
-{
-    slimb_t E, e, prec, extra_bits, ziv_extra_bits, prec0;
-    bf_t B_s, *B = &B_s;
-    int e_sign, ret, res;
-    
-    if (a->len == 0) {
-        /* zero case */
-        *pE = 0;
-        return bf_set(r, a);
-    }
-
-    if (is_fixed_exponent) {
-        E = *pE;
-    } else {
-        /* compute the new exponent */
-        E = 1 + bf_mul_log2_radix(a->expn - 1, radix, TRUE, FALSE);
-    }
-    //    bf_print_str("a", a);
-    //    printf("E=%ld P=%ld radix=%d\n", E, P, radix);
-    
-    for(;;) {
-        e = P - E;
-        e_sign = 0;
-        if (e < 0) {
-            e = -e;
-            e_sign = 1;
-        }
-        /* Note: precision for log2(radix) is not critical here */
-        prec0 = bf_mul_log2_radix(P, radix, FALSE, TRUE);
-        ziv_extra_bits = 16;
-        for(;;) {
-            prec = prec0 + ziv_extra_bits;
-            /* XXX: rigorous error analysis needed */
-            extra_bits = ceil_log2(e) * 2 + 1;
-            ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits,
-                               BF_RNDN | BF_FLAG_EXT_EXP);
-            if (!e_sign)
-                ret |= bf_mul(r, r, a, prec + extra_bits,
-                              BF_RNDN | BF_FLAG_EXT_EXP);
-            else
-                ret |= bf_div(r, a, r, prec + extra_bits,
-                              BF_RNDN | BF_FLAG_EXT_EXP);
-            if (ret & BF_ST_MEM_ERROR)
-                return BF_ST_MEM_ERROR;
-            /* if the result is not exact, check that it can be safely
-               rounded to an integer */
-            if ((ret & BF_ST_INEXACT) &&
-                !bf_can_round(r, r->expn, rnd_mode, prec)) {
-                /* and more precision and retry */
-                ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
-                continue;
-            } else {
-                ret = bf_rint(r, rnd_mode);
-                if (ret & BF_ST_MEM_ERROR)
-                    return BF_ST_MEM_ERROR;
-                break;
-            }
-        }
-        if (is_fixed_exponent)
-            break;
-        /* check that the result is < B^P */
-        /* XXX: do a fast approximate test first ? */
-        bf_init(r->ctx, B);
-        ret = bf_pow_ui_ui(B, radix, P, BF_PREC_INF, BF_RNDZ);
-        if (ret) {
-            bf_delete(B);
-            return ret;
-        }
-        res = bf_cmpu(r, B);
-        bf_delete(B);
-        if (res < 0)
-            break;
-        /* try a larger exponent */
-        E++;
-    }
-    *pE = E;
-    return 0;
-}
-
-static void limb_to_a(char *buf, limb_t n, unsigned int radix, int len)
-{
-    int digit, i;
-
-    if (radix == 10) {
-        /* specific case with constant divisor */
-        for(i = len - 1; i >= 0; i--) {
-            digit = (limb_t)n % 10;
-            n = (limb_t)n / 10;
-            buf[i] = digit + '0';
-        }
-    } else {
-        for(i = len - 1; i >= 0; i--) {
-            digit = (limb_t)n % radix;
-            n = (limb_t)n / radix;
-            if (digit < 10)
-                digit += '0';
-            else
-                digit += 'a' - 10;
-            buf[i] = digit;
-        }
-    }
-}
-
-/* for power of 2 radixes */
-static void limb_to_a2(char *buf, limb_t n, unsigned int radix_bits, int len)
-{
-    int digit, i;
-    unsigned int mask;
-
-    mask = (1 << radix_bits) - 1;
-    for(i = len - 1; i >= 0; i--) {
-        digit = n & mask;
-        n >>= radix_bits;
-        if (digit < 10)
-            digit += '0';
-        else
-            digit += 'a' - 10;
-        buf[i] = digit;
-    }
-}
-
-/* 'a' must be an integer if the is_dec = FALSE or if the radix is not
-   a power of two. A dot is added before the 'dot_pos' digit. dot_pos
-   = n_digits does not display the dot. 0 <= dot_pos <=
-   n_digits. n_digits >= 1. */
-static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
-                          limb_t dot_pos, BOOL is_dec)
-{
-    limb_t i, v, l;
-    slimb_t pos, pos_incr;
-    int digits_per_limb, buf_pos, radix_bits, first_buf_pos;
-    char buf[65];
-    bf_t a_s, *a;
-
-    if (is_dec) {
-        digits_per_limb = LIMB_DIGITS;
-        a = (bf_t *)a1;
-        radix_bits = 0;
-        pos = a->len;
-        pos_incr = 1;
-        first_buf_pos = 0;
-    } else if ((radix & (radix - 1)) == 0) {
-        a = (bf_t *)a1;
-        radix_bits = ceil_log2(radix);
-        digits_per_limb = LIMB_BITS / radix_bits;
-        pos_incr = digits_per_limb * radix_bits;
-        /* digits are aligned relative to the radix point */
-        pos = a->len * LIMB_BITS + smod(-a->expn, radix_bits);
-        first_buf_pos = 0;
-    } else {
-        limb_t n, radixl;
-
-        digits_per_limb = digits_per_limb_table[radix - 2];
-        radixl = get_limb_radix(radix);
-        a = &a_s;
-        bf_init(a1->ctx, a);
-        n = (n_digits + digits_per_limb - 1) / digits_per_limb;
-        if (bf_resize(a, n)) {
-            dbuf_set_error(s);
-            goto done;
-        }
-        if (bf_integer_to_radix(a, a1, radixl)) {
-            dbuf_set_error(s);
-            goto done;
-        }
-        radix_bits = 0;
-        pos = n;
-        pos_incr = 1;
-        first_buf_pos = pos * digits_per_limb - n_digits;
-    }
-    buf_pos = digits_per_limb;
-    i = 0;
-    while (i < n_digits) {
-        if (buf_pos == digits_per_limb) {
-            pos -= pos_incr;
-            if (radix_bits == 0) {
-                v = get_limbz(a, pos);
-                limb_to_a(buf, v, radix, digits_per_limb);
-            } else {
-                v = get_bits(a->tab, a->len, pos);
-                limb_to_a2(buf, v, radix_bits, digits_per_limb);
-            }
-            buf_pos = first_buf_pos;
-            first_buf_pos = 0;
-        }
-        if (i < dot_pos) {
-            l = dot_pos;
-        } else {
-            if (i == dot_pos)
-                dbuf_putc(s, '.');
-            l = n_digits;
-        }
-        l = bf_min(digits_per_limb - buf_pos, l - i);
-        dbuf_put(s, (uint8_t *)(buf + buf_pos), l);
-        buf_pos += l;
-        i += l;
-    }
- done:
-    if (a != a1)
-        bf_delete(a);
-}
-
-static void *bf_dbuf_realloc(void *opaque, void *ptr, size_t size)
-{
-    bf_context_t *s = opaque;
-    return bf_realloc(s, ptr, size);
-}
-
-/* return the length in bytes. A trailing '\0' is added */
-static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
-                              limb_t prec, bf_flags_t flags, BOOL is_dec)
-{
-    bf_context_t *ctx = a2->ctx;
-    DynBuf s_s, *s = &s_s;
-    int radix_bits;
-    
-    //    bf_print_str("ftoa", a2);
-    //    printf("radix=%d\n", radix);
-    dbuf_init2(s, ctx, bf_dbuf_realloc);
-    if (a2->expn == BF_EXP_NAN) {
-        dbuf_putstr(s, "NaN");
-    } else {
-        if (a2->sign)
-            dbuf_putc(s, '-');
-        if (a2->expn == BF_EXP_INF) {
-            if (flags & BF_FTOA_JS_QUIRKS)
-                dbuf_putstr(s, "Infinity");
-            else
-                dbuf_putstr(s, "Inf");
-        } else {
-            int fmt, ret;
-            slimb_t n_digits, n, i, n_max, n1;
-            bf_t a1_s, *a1 = &a1_s;
-
-            if ((radix & (radix - 1)) != 0)
-                radix_bits = 0;
-            else
-                radix_bits = ceil_log2(radix);
-
-            fmt = flags & BF_FTOA_FORMAT_MASK;
-            bf_init(ctx, a1);
-            if (fmt == BF_FTOA_FORMAT_FRAC) {
-                if (is_dec || radix_bits != 0) {
-                    if (bf_set(a1, a2))
-                        goto fail1;
-#ifdef USE_BF_DEC
-                    if (is_dec) {
-                        if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
-                            goto fail1;
-                        n = a1->expn;
-                    } else
-#endif
-                    {
-                        if (bf_round(a1, prec * radix_bits, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
-                            goto fail1;
-                        n = ceil_div(a1->expn, radix_bits);
-                    }
-                    if (flags & BF_FTOA_ADD_PREFIX) {
-                        if (radix == 16)
-                            dbuf_putstr(s, "0x");
-                        else if (radix == 8)
-                            dbuf_putstr(s, "0o");
-                        else if (radix == 2)
-                            dbuf_putstr(s, "0b");
-                    }
-                    if (a1->expn == BF_EXP_ZERO) {
-                        dbuf_putstr(s, "0");
-                        if (prec > 0) {
-                            dbuf_putstr(s, ".");
-                            for(i = 0; i < prec; i++) {
-                                dbuf_putc(s, '0');
-                            }
-                        }
-                    } else {
-                        n_digits = prec + n;
-                        if (n <= 0) {
-                            /* 0.x */
-                            dbuf_putstr(s, "0.");
-                            for(i = 0; i < -n; i++) {
-                                dbuf_putc(s, '0');
-                            }
-                            if (n_digits > 0) {
-                                output_digits(s, a1, radix, n_digits, n_digits, is_dec);
-                            }
-                        } else {
-                            output_digits(s, a1, radix, n_digits, n, is_dec);
-                        }
-                    }
-                } else {
-                    size_t pos, start;
-                    bf_t a_s, *a = &a_s;
-
-                    /* make a positive number */
-                    a->tab = a2->tab;
-                    a->len = a2->len;
-                    a->expn = a2->expn;
-                    a->sign = 0;
-                    
-                    /* one more digit for the rounding */
-                    n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
-                    n_digits = n + prec;
-                    n1 = n;
-                    if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
-                                            flags & BF_RND_MASK, TRUE))
-                        goto fail1;
-                    start = s->size;
-                    output_digits(s, a1, radix, n_digits, n, is_dec);
-                    /* remove leading zeros because we allocated one more digit */
-                    pos = start;
-                    while ((pos + 1) < s->size && s->buf[pos] == '0' &&
-                           s->buf[pos + 1] != '.')
-                        pos++;
-                    if (pos > start) {
-                        memmove(s->buf + start, s->buf + pos, s->size - pos);
-                        s->size -= (pos - start);
-                    }
-                }
-            } else {
-#ifdef USE_BF_DEC
-                if (is_dec) {
-                    if (bf_set(a1, a2))
-                        goto fail1;
-                    if (fmt == BF_FTOA_FORMAT_FIXED) {
-                        n_digits = prec;
-                        n_max = n_digits;
-                        if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
-                            goto fail1;
-                    } else {
-                        /* prec is ignored */
-                        prec = n_digits = a1->len * LIMB_DIGITS;
-                        /* remove the trailing zero digits */
-                        while (n_digits > 1 &&
-                               get_digit(a1->tab, a1->len, prec - n_digits) == 0) {
-                            n_digits--;
-                        }
-                        n_max = n_digits + 4;
-                    }
-                    n = a1->expn;
-                } else
-#endif
-                if (radix_bits != 0) {
-                    if (bf_set(a1, a2))
-                        goto fail1;
-                    if (fmt == BF_FTOA_FORMAT_FIXED) {
-                        slimb_t prec_bits;
-                        n_digits = prec;
-                        n_max = n_digits;
-                        /* align to the radix point */
-                        prec_bits = prec * radix_bits -
-                            smod(-a1->expn, radix_bits);
-                        if (bf_round(a1, prec_bits,
-                                     (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
-                            goto fail1;
-                    } else {
-                        limb_t digit_mask;
-                        slimb_t pos;
-                        /* position of the digit before the most
-                           significant digit in bits */
-                        pos = a1->len * LIMB_BITS +
-                            smod(-a1->expn, radix_bits);
-                        n_digits = ceil_div(pos, radix_bits);
-                        /* remove the trailing zero digits */
-                        digit_mask = ((limb_t)1 << radix_bits) - 1;
-                        while (n_digits > 1 &&
-                               (get_bits(a1->tab, a1->len, pos - n_digits * radix_bits) & digit_mask) == 0) {
-                            n_digits--;
-                        }
-                        n_max = n_digits + 4;
-                    }
-                    n = ceil_div(a1->expn, radix_bits);
-                } else {
-                    bf_t a_s, *a = &a_s;
-                    
-                    /* make a positive number */
-                    a->tab = a2->tab;
-                    a->len = a2->len;
-                    a->expn = a2->expn;
-                    a->sign = 0;
-                    
-                    if (fmt == BF_FTOA_FORMAT_FIXED) {
-                        n_digits = prec;
-                        n_max = n_digits;
-                    } else {
-                        slimb_t n_digits_max, n_digits_min;
-                        
-                        assert(prec != BF_PREC_INF);
-                        n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
-                        /* max number of digits for non exponential
-                           notation. The rational is to have the same rule
-                           as JS i.e. n_max = 21 for 64 bit float in base 10. */
-                        n_max = n_digits + 4;
-                        if (fmt == BF_FTOA_FORMAT_FREE_MIN) {
-                            bf_t b_s, *b = &b_s;
-                            
-                            /* find the minimum number of digits by
-                               dichotomy. */
-                            /* XXX: inefficient */
-                            n_digits_max = n_digits;
-                            n_digits_min = 1;
-                            bf_init(ctx, b);
-                            while (n_digits_min < n_digits_max) {
-                                n_digits = (n_digits_min + n_digits_max) / 2;
-                                if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
-                                                        flags & BF_RND_MASK, FALSE)) {
-                                    bf_delete(b);
-                                    goto fail1;
-                                }
-                                /* convert back to a number and compare */
-                                ret = bf_mul_pow_radix(b, a1, radix, n - n_digits,
-                                                       prec,
-                                                       (flags & ~BF_RND_MASK) |
-                                                       BF_RNDN);
-                                if (ret & BF_ST_MEM_ERROR) {
-                                    bf_delete(b);
-                                    goto fail1;
-                                }
-                                if (bf_cmpu(b, a) == 0) {
-                                    n_digits_max = n_digits;
-                                } else {
-                                    n_digits_min = n_digits + 1;
-                                }
-                            }
-                            bf_delete(b);
-                            n_digits = n_digits_max;
-                        }
-                    }
-                    if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
-                                            flags & BF_RND_MASK, FALSE)) {
-                    fail1:
-                        bf_delete(a1);
-                        goto fail;
-                    }
-                }
-                if (a1->expn == BF_EXP_ZERO &&
-                    fmt != BF_FTOA_FORMAT_FIXED &&
-                    !(flags & BF_FTOA_FORCE_EXP)) {
-                    /* just output zero */
-                    dbuf_putstr(s, "0");
-                } else {
-                    if (flags & BF_FTOA_ADD_PREFIX) {
-                        if (radix == 16)
-                            dbuf_putstr(s, "0x");
-                        else if (radix == 8)
-                            dbuf_putstr(s, "0o");
-                        else if (radix == 2)
-                            dbuf_putstr(s, "0b");
-                    }
-                    if (a1->expn == BF_EXP_ZERO)
-                        n = 1;
-                    if ((flags & BF_FTOA_FORCE_EXP) ||
-                        n <= -6 || n > n_max) {
-                        const char *fmt;
-                        /* exponential notation */
-                        output_digits(s, a1, radix, n_digits, 1, is_dec);
-                        if (radix_bits != 0 && radix <= 16) {
-                            if (flags & BF_FTOA_JS_QUIRKS)
-                                fmt = "p%+" PRId_LIMB;
-                            else
-                                fmt = "p%" PRId_LIMB;
-                            dbuf_printf(s, fmt, (n - 1) * radix_bits);
-                        } else {
-                            if (flags & BF_FTOA_JS_QUIRKS)
-                                fmt = "%c%+" PRId_LIMB;
-                            else
-                                fmt = "%c%" PRId_LIMB;
-                            dbuf_printf(s, fmt,
-                                        radix <= 10 ? 'e' : '@', n - 1);
-                        }
-                    } else if (n <= 0) {
-                        /* 0.x */
-                        dbuf_putstr(s, "0.");
-                        for(i = 0; i < -n; i++) {
-                            dbuf_putc(s, '0');
-                        }
-                        output_digits(s, a1, radix, n_digits, n_digits, is_dec);
-                    } else {
-                        if (n_digits <= n) {
-                            /* no dot */
-                            output_digits(s, a1, radix, n_digits, n_digits, is_dec);
-                            for(i = 0; i < (n - n_digits); i++)
-                                dbuf_putc(s, '0');
-                        } else {
-                            output_digits(s, a1, radix, n_digits, n, is_dec);
-                        }
-                    }
-                }
-            }
-            bf_delete(a1);
-        }
-    }
-    dbuf_putc(s, '\0');
-    if (dbuf_error(s))
-        goto fail;
-    if (plen)
-        *plen = s->size - 1;
-    return (char *)s->buf;
- fail:
-    bf_free(ctx, s->buf);
-    if (plen)
-        *plen = 0;
-    return NULL;
-}
-
-char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
-              bf_flags_t flags)
-{
-    return bf_ftoa_internal(plen, a, radix, prec, flags, FALSE);
-}
-
-/***************************************************************/
-/* transcendental functions */
-
-/* Note: the algorithm is from MPFR */
-static void bf_const_log2_rec(bf_t *T, bf_t *P, bf_t *Q, limb_t n1,
-                              limb_t n2, BOOL need_P)
-{
-    bf_context_t *s = T->ctx;
-    if ((n2 - n1) == 1) {
-        if (n1 == 0) {
-            bf_set_ui(P, 3);
-        } else {
-            bf_set_ui(P, n1);
-            P->sign = 1;
-        }
-        bf_set_ui(Q, 2 * n1 + 1);
-        Q->expn += 2;
-        bf_set(T, P);
-    } else {
-        limb_t m;
-        bf_t T1_s, *T1 = &T1_s;
-        bf_t P1_s, *P1 = &P1_s;
-        bf_t Q1_s, *Q1 = &Q1_s;
-        
-        m = n1 + ((n2 - n1) >> 1);
-        bf_const_log2_rec(T, P, Q, n1, m, TRUE);
-        bf_init(s, T1);
-        bf_init(s, P1);
-        bf_init(s, Q1);
-        bf_const_log2_rec(T1, P1, Q1, m, n2, need_P);
-        bf_mul(T, T, Q1, BF_PREC_INF, BF_RNDZ);
-        bf_mul(T1, T1, P, BF_PREC_INF, BF_RNDZ);
-        bf_add(T, T, T1, BF_PREC_INF, BF_RNDZ);
-        if (need_P)
-            bf_mul(P, P, P1, BF_PREC_INF, BF_RNDZ);
-        bf_mul(Q, Q, Q1, BF_PREC_INF, BF_RNDZ);
-        bf_delete(T1);
-        bf_delete(P1);
-        bf_delete(Q1);
-    }
-}
-
-/* compute log(2) with faithful rounding at precision 'prec' */
-static void bf_const_log2_internal(bf_t *T, limb_t prec)
-{
-    limb_t w, N;
-    bf_t P_s, *P = &P_s;
-    bf_t Q_s, *Q = &Q_s;
-
-    w = prec + 15;
-    N = w / 3 + 1;
-    bf_init(T->ctx, P);
-    bf_init(T->ctx, Q);
-    bf_const_log2_rec(T, P, Q, 0, N, FALSE);
-    bf_div(T, T, Q, prec, BF_RNDN);
-    bf_delete(P);
-    bf_delete(Q);
-}
-
-/* PI constant */
-
-#define CHUD_A 13591409
-#define CHUD_B 545140134
-#define CHUD_C 640320
-#define CHUD_BITS_PER_TERM 47
-
-static void chud_bs(bf_t *P, bf_t *Q, bf_t *G, int64_t a, int64_t b, int need_g,
-                    limb_t prec)
-{
-    bf_context_t *s = P->ctx;
-    int64_t c;
-
-    if (a == (b - 1)) {
-        bf_t T0, T1;
-        
-        bf_init(s, &T0);
-        bf_init(s, &T1);
-        bf_set_ui(G, 2 * b - 1);
-        bf_mul_ui(G, G, 6 * b - 1, prec, BF_RNDN);
-        bf_mul_ui(G, G, 6 * b - 5, prec, BF_RNDN);
-        bf_set_ui(&T0, CHUD_B);
-        bf_mul_ui(&T0, &T0, b, prec, BF_RNDN);
-        bf_set_ui(&T1, CHUD_A);
-        bf_add(&T0, &T0, &T1, prec, BF_RNDN);
-        bf_mul(P, G, &T0, prec, BF_RNDN);
-        P->sign = b & 1;
-
-        bf_set_ui(Q, b);
-        bf_mul_ui(Q, Q, b, prec, BF_RNDN);
-        bf_mul_ui(Q, Q, b, prec, BF_RNDN);
-        bf_mul_ui(Q, Q, (uint64_t)CHUD_C * CHUD_C * CHUD_C / 24, prec, BF_RNDN);
-        bf_delete(&T0);
-        bf_delete(&T1);
-    } else {
-        bf_t P2, Q2, G2;
-        
-        bf_init(s, &P2);
-        bf_init(s, &Q2);
-        bf_init(s, &G2);
-
-        c = (a + b) / 2;
-        chud_bs(P, Q, G, a, c, 1, prec);
-        chud_bs(&P2, &Q2, &G2, c, b, need_g, prec);
-        
-        /* Q = Q1 * Q2 */
-        /* G = G1 * G2 */
-        /* P = P1 * Q2 + P2 * G1 */
-        bf_mul(&P2, &P2, G, prec, BF_RNDN);
-        if (!need_g)
-            bf_set_ui(G, 0);
-        bf_mul(P, P, &Q2, prec, BF_RNDN);
-        bf_add(P, P, &P2, prec, BF_RNDN);
-        bf_delete(&P2);
-
-        bf_mul(Q, Q, &Q2, prec, BF_RNDN);
-        bf_delete(&Q2);
-        if (need_g)
-            bf_mul(G, G, &G2, prec, BF_RNDN);
-        bf_delete(&G2);
-    }
-}
-
-/* compute Pi with faithful rounding at precision 'prec' using the
-   Chudnovsky formula */
-static void bf_const_pi_internal(bf_t *Q, limb_t prec)
-{
-    bf_context_t *s = Q->ctx;
-    int64_t n, prec1;
-    bf_t P, G;
-
-    /* number of serie terms */
-    n = prec / CHUD_BITS_PER_TERM + 1;
-    /* XXX: precision analysis */
-    prec1 = prec + 32;
-
-    bf_init(s, &P);
-    bf_init(s, &G);
-
-    chud_bs(&P, Q, &G, 0, n, 0, BF_PREC_INF);
-    
-    bf_mul_ui(&G, Q, CHUD_A, prec1, BF_RNDN);
-    bf_add(&P, &G, &P, prec1, BF_RNDN);
-    bf_div(Q, Q, &P, prec1, BF_RNDF);
- 
-    bf_set_ui(&P, CHUD_C);
-    bf_sqrt(&G, &P, prec1, BF_RNDF);
-    bf_mul_ui(&G, &G, (uint64_t)CHUD_C / 12, prec1, BF_RNDF);
-    bf_mul(Q, Q, &G, prec, BF_RNDN);
-    bf_delete(&P);
-    bf_delete(&G);
-}
-
-static int bf_const_get(bf_t *T, limb_t prec, bf_flags_t flags,
-                        BFConstCache *c,
-                        void (*func)(bf_t *res, limb_t prec), int sign)
-{
-    limb_t ziv_extra_bits, prec1;
-
-    ziv_extra_bits = 32;
-    for(;;) {
-        prec1 = prec + ziv_extra_bits;
-        if (c->prec < prec1) {
-            if (c->val.len == 0)
-                bf_init(T->ctx, &c->val);
-            func(&c->val, prec1);
-            c->prec = prec1;
-        } else {
-            prec1 = c->prec;
-        }
-        bf_set(T, &c->val);
-        T->sign = sign;
-        if (!bf_can_round(T, prec, flags & BF_RND_MASK, prec1)) {
-            /* and more precision and retry */
-            ziv_extra_bits = ziv_extra_bits  + (ziv_extra_bits / 2);
-        } else {
-            break;
-        }
-    }
-    return bf_round(T, prec, flags);
-}
-
-static void bf_const_free(BFConstCache *c)
-{
-    bf_delete(&c->val);
-    memset(c, 0, sizeof(*c));
-}
-
-int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = T->ctx;
-    return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal, 0);
-}
-
-/* return rounded pi * (1 - 2 * sign) */
-static int bf_const_pi_signed(bf_t *T, int sign, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = T->ctx;
-    return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal,
-                        sign);
-}
-
-int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
-{
-    return bf_const_pi_signed(T, 0, prec, flags);
-}
-
-void bf_clear_cache(bf_context_t *s)
-{
-#ifdef USE_FFT_MUL
-    fft_clear_cache(s);
-#endif
-    bf_const_free(&s->log2_cache);
-    bf_const_free(&s->pi_cache);
-}
-
-/* ZivFunc should compute the result 'r' with faithful rounding at
-   precision 'prec'. For efficiency purposes, the final bf_round()
-   does not need to be done in the function. */
-typedef int ZivFunc(bf_t *r, const bf_t *a, limb_t prec, void *opaque);
-
-static int bf_ziv_rounding(bf_t *r, const bf_t *a,
-                           limb_t prec, bf_flags_t flags,
-                           ZivFunc *f, void *opaque)
-{
-    int rnd_mode, ret;
-    slimb_t prec1, ziv_extra_bits;
-    
-    rnd_mode = flags & BF_RND_MASK;
-    if (rnd_mode == BF_RNDF) {
-        /* no need to iterate */
-        f(r, a, prec, opaque);
-        ret = 0;
-    } else {
-        ziv_extra_bits = 32;
-        for(;;) {
-            prec1 = prec + ziv_extra_bits;
-            ret = f(r, a, prec1, opaque);
-            if (ret & (BF_ST_OVERFLOW | BF_ST_UNDERFLOW | BF_ST_MEM_ERROR)) {
-                /* overflow or underflow should never happen because
-                   it indicates the rounding cannot be done correctly,
-                   but we do not catch all the cases */
-                return ret;
-            }
-            /* if the result is exact, we can stop */
-            if (!(ret & BF_ST_INEXACT)) {
-                ret = 0;
-                break;
-            }
-            if (bf_can_round(r, prec, rnd_mode, prec1)) {
-                ret = BF_ST_INEXACT;
-                break;
-            }
-            ziv_extra_bits = ziv_extra_bits * 2;
-            //            printf("ziv_extra_bits=%" PRId64 "\n", (int64_t)ziv_extra_bits);
-        }
-    }
-    if (r->len == 0)
-        return ret;
-    else
-        return __bf_round(r, prec, flags, r->len, ret);
-}
-
-/* add (1 - 2*e_sign) * 2^e */
-static int bf_add_epsilon(bf_t *r, const bf_t *a, slimb_t e, int e_sign,
-                          limb_t prec, int flags)
-{
-    bf_t T_s, *T = &T_s;
-    int ret;
-    /* small argument case: result = 1 + epsilon * sign(x) */
-    bf_init(a->ctx, T);
-    bf_set_ui(T, 1);
-    T->sign = e_sign;
-    T->expn += e;
-    ret = bf_add(r, r, T, prec, flags);
-    bf_delete(T);
-    return ret;
-}
-
-/* Compute the exponential using faithful rounding at precision 'prec'.
-   Note: the algorithm is from MPFR */
-static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    slimb_t n, K, l, i, prec1;
-    
-    assert(r != a);
-
-    /* argument reduction:
-       T = a - n*log(2) with 0 <= T < log(2) and n integer.
-    */
-    bf_init(s, T);
-    if (a->expn <= -1) {
-        /* 0 <= abs(a) <= 0.5 */
-        if (a->sign)
-            n = -1;
-        else
-            n = 0;
-    } else {
-        bf_const_log2(T, LIMB_BITS, BF_RNDZ);
-        bf_div(T, a, T, LIMB_BITS, BF_RNDD);
-        bf_get_limb(&n, T, 0);
-    }
-
-    K = bf_isqrt((prec + 1) / 2);
-    l = (prec - 1) / K + 1;
-    /* XXX: precision analysis ? */
-    prec1 = prec + (K + 2 * l + 18) + K + 8;
-    if (a->expn > 0)
-        prec1 += a->expn;
-    //    printf("n=%ld K=%ld prec1=%ld\n", n, K, prec1);
-
-    bf_const_log2(T, prec1, BF_RNDF);
-    bf_mul_si(T, T, n, prec1, BF_RNDN);
-    bf_sub(T, a, T, prec1, BF_RNDN);
-
-    /* reduce the range of T */
-    bf_mul_2exp(T, -K, BF_PREC_INF, BF_RNDZ);
-    
-    /* Taylor expansion around zero :
-     1 + x + x^2/2 + ... + x^n/n! 
-     = (1 + x * (1 + x/2 * (1 + ... (x/n))))
-    */
-    {
-        bf_t U_s, *U = &U_s;
-        
-        bf_init(s, U);
-        bf_set_ui(r, 1);
-        for(i = l ; i >= 1; i--) {
-            bf_set_ui(U, i);
-            bf_div(U, T, U, prec1, BF_RNDN);
-            bf_mul(r, r, U, prec1, BF_RNDN);
-            bf_add_si(r, r, 1, prec1, BF_RNDN);
-        }
-        bf_delete(U);
-    }
-    bf_delete(T);
-    
-    /* undo the range reduction */
-    for(i = 0; i < K; i++) {
-        bf_mul(r, r, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
-    }
-
-    /* undo the argument reduction */
-    bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ | BF_FLAG_EXT_EXP);
-
-    return BF_ST_INEXACT;
-}
-
-/* crude overflow and underflow tests for exp(a). a_low <= a <= a_high */
-static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
-                                        const bf_t *a_low, const bf_t *a_high,
-                                        limb_t prec, bf_flags_t flags)
-{
-    bf_t T_s, *T = &T_s;
-    bf_t log2_s, *log2 = &log2_s;
-    slimb_t e_min, e_max;
-    
-    if (a_high->expn <= 0)
-        return 0;
-
-    e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
-    e_min = -e_max + 3;
-    if (flags & BF_FLAG_SUBNORMAL)
-        e_min -= (prec - 1);
-    
-    bf_init(s, T);
-    bf_init(s, log2);
-    bf_const_log2(log2, LIMB_BITS, BF_RNDU);
-    bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
-    /* a_low > e_max * log(2) implies exp(a) > e_max */
-    if (bf_cmp_lt(T, a_low) > 0) {
-        /* overflow */
-        bf_delete(T);
-        bf_delete(log2);
-        return bf_set_overflow(r, 0, prec, flags);
-    }
-    /* a_high < (e_min - 2) * log(2) implies exp(a) < (e_min - 2) */
-    bf_const_log2(log2, LIMB_BITS, BF_RNDD);
-    bf_mul_si(T, log2, e_min - 2, LIMB_BITS, BF_RNDD);
-    if (bf_cmp_lt(a_high, T)) {
-        int rnd_mode = flags & BF_RND_MASK;
-        
-        /* underflow */
-        bf_delete(T);
-        bf_delete(log2);
-        if (rnd_mode == BF_RNDU) {
-            /* set the smallest value */
-            bf_set_ui(r, 1);
-            r->expn = e_min;
-        } else {
-            bf_set_zero(r, 0);
-        }
-        return BF_ST_UNDERFLOW | BF_ST_INEXACT;
-    }
-    bf_delete(log2);
-    bf_delete(T);
-    return 0;
-}
-
-int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    int ret;
-    assert(r != a);
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-        } else if (a->expn == BF_EXP_INF) {
-            if (a->sign)
-                bf_set_zero(r, 0);
-            else
-                bf_set_inf(r, 0);
-        } else {
-            bf_set_ui(r, 1);
-        }
-        return 0;
-    }
-
-    ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
-    if (ret)
-        return ret;
-    if (a->expn < 0 && (-a->expn) >= (prec + 2)) { 
-        /* small argument case: result = 1 + epsilon * sign(x) */
-        bf_set_ui(r, 1);
-        return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
-    }
-                         
-    return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
-}
-
-static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    bf_t U_s, *U = &U_s;
-    bf_t V_s, *V = &V_s;
-    slimb_t n, prec1, l, i, K;
-    
-    assert(r != a);
-
-    bf_init(s, T);
-    /* argument reduction 1 */
-    /* T=a*2^n with 2/3 <= T <= 4/3 */
-    {
-        bf_t U_s, *U = &U_s;
-        bf_set(T, a);
-        n = T->expn;
-        T->expn = 0;
-        /* U= ~ 2/3 */
-        bf_init(s, U);
-        bf_set_ui(U, 0xaaaaaaaa); 
-        U->expn = 0;
-        if (bf_cmp_lt(T, U)) {
-            T->expn++;
-            n--;
-        }
-        bf_delete(U);
-    }
-    //    printf("n=%ld\n", n);
-    //    bf_print_str("T", T);
-
-    /* XXX: precision analysis */
-    /* number of iterations for argument reduction 2 */
-    K = bf_isqrt((prec + 1) / 2); 
-    /* order of Taylor expansion */
-    l = prec / (2 * K) + 1; 
-    /* precision of the intermediate computations */
-    prec1 = prec + K + 2 * l + 32;
-
-    bf_init(s, U);
-    bf_init(s, V);
-    
-    /* Note: cancellation occurs here, so we use more precision (XXX:
-       reduce the precision by computing the exact cancellation) */
-    bf_add_si(T, T, -1, BF_PREC_INF, BF_RNDN); 
-
-    /* argument reduction 2 */
-    for(i = 0; i < K; i++) {
-        /* T = T / (1 + sqrt(1 + T)) */
-        bf_add_si(U, T, 1, prec1, BF_RNDN);
-        bf_sqrt(V, U, prec1, BF_RNDF);
-        bf_add_si(U, V, 1, prec1, BF_RNDN);
-        bf_div(T, T, U, prec1, BF_RNDN);
-    }
-
-    {
-        bf_t Y_s, *Y = &Y_s;
-        bf_t Y2_s, *Y2 = &Y2_s;
-        bf_init(s, Y);
-        bf_init(s, Y2);
-
-        /* compute ln(1+x) = ln((1+y)/(1-y)) with y=x/(2+x)
-           = y + y^3/3 + ... + y^(2*l + 1) / (2*l+1) 
-           with Y=Y^2
-           = y*(1+Y/3+Y^2/5+...) = y*(1+Y*(1/3+Y*(1/5 + ...)))
-        */
-        bf_add_si(Y, T, 2, prec1, BF_RNDN);
-        bf_div(Y, T, Y, prec1, BF_RNDN);
-
-        bf_mul(Y2, Y, Y, prec1, BF_RNDN);
-        bf_set_ui(r, 0);
-        for(i = l; i >= 1; i--) {
-            bf_set_ui(U, 1);
-            bf_set_ui(V, 2 * i + 1);
-            bf_div(U, U, V, prec1, BF_RNDN);
-            bf_add(r, r, U, prec1, BF_RNDN);
-            bf_mul(r, r, Y2, prec1, BF_RNDN);
-        }
-        bf_add_si(r, r, 1, prec1, BF_RNDN);
-        bf_mul(r, r, Y, prec1, BF_RNDN);
-        bf_delete(Y);
-        bf_delete(Y2);
-    }
-    bf_delete(V);
-    bf_delete(U);
-
-    /* multiplication by 2 for the Taylor expansion and undo the
-       argument reduction 2*/
-    bf_mul_2exp(r, K + 1, BF_PREC_INF, BF_RNDZ);
-    
-    /* undo the argument reduction 1 */
-    bf_const_log2(T, prec1, BF_RNDF);
-    bf_mul_si(T, T, n, prec1, BF_RNDN);
-    bf_add(r, r, T, prec1, BF_RNDN);
-    
-    bf_delete(T);
-    return BF_ST_INEXACT;
-}
-
-int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    
-    assert(r != a);
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            if (a->sign) {
-                bf_set_nan(r);
-                return BF_ST_INVALID_OP;
-            } else {
-                bf_set_inf(r, 0);
-                return 0;
-            }
-        } else {
-            bf_set_inf(r, 1);
-            return 0;
-        }
-    }
-    if (a->sign) {
-        bf_set_nan(r);
-        return BF_ST_INVALID_OP;
-    }
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    if (bf_cmp_eq(a, T)) {
-        bf_set_zero(r, 0);
-        bf_delete(T);
-        return 0;
-    }
-    bf_delete(T);
-
-    return bf_ziv_rounding(r, a, prec, flags, bf_log_internal, NULL);
-}
-
-/* x and y finite and x > 0 */
-static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    const bf_t *y = opaque;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1;
-
-    bf_init(s, T);
-    /* XXX: proof for the added precision */
-    prec1 = prec + 32;
-    bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
-    bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
-    if (bf_is_nan(T))
-        bf_set_nan(r);
-    else
-        bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
-    bf_delete(T);
-    return BF_ST_INEXACT;
-}
-
-/* x and y finite, x > 0, y integer and y fits on one limb */
-static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    const bf_t *y = opaque;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1;
-    int ret;
-    slimb_t y1;
-    
-    bf_get_limb(&y1, y, 0);
-    if (y1 < 0)
-        y1 = -y1;
-    /* XXX: proof for the added precision */
-    prec1 = prec + ceil_log2(y1) * 2 + 8;
-    ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
-    if (y->sign) {
-        bf_init(s, T);
-        bf_set_ui(T, 1);
-        ret |= bf_div(r, T, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
-        bf_delete(T);
-    }
-    return ret;
-}
-
-/* x must be a finite non zero float. Return TRUE if there is a
-   floating point number r such as x=r^(2^n) and return this floating
-   point number 'r'. Otherwise return FALSE and r is undefined. */
-static BOOL check_exact_power2n(bf_t *r, const bf_t *x, slimb_t n)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    slimb_t e, i, er;
-    limb_t v;
-    
-    /* x = m*2^e with m odd integer */
-    e = bf_get_exp_min(x);
-    /* fast check on the exponent */
-    if (n > (LIMB_BITS - 1)) {
-        if (e != 0)
-            return FALSE;
-        er = 0;
-    } else {
-        if ((e & (((limb_t)1 << n) - 1)) != 0)
-            return FALSE;
-        er = e >> n;
-    }
-    /* every perfect odd square = 1 modulo 8 */
-    v = get_bits(x->tab, x->len, x->len * LIMB_BITS - x->expn + e);
-    if ((v & 7) != 1)
-        return FALSE;
-
-    bf_init(s, T);
-    bf_set(T, x);
-    T->expn -= e;
-    for(i = 0; i < n; i++) {
-        if (i != 0)
-            bf_set(T, r);
-        if (bf_sqrtrem(r, NULL, T) != 0)
-            return FALSE;
-    }
-    r->expn += er;
-    return TRUE;
-}
-
-/* prec = BF_PREC_INF is accepted for x and y integers and y >= 0 */
-int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    bf_t ytmp_s;
-    BOOL y_is_int, y_is_odd;
-    int r_sign, ret, rnd_mode;
-    slimb_t y_emin;
-    
-    if (x->len == 0 || y->len == 0) {
-        if (y->expn == BF_EXP_ZERO) {
-            /* pow(x, 0) = 1 */
-            bf_set_ui(r, 1);
-        } else if (x->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-        } else {
-            int cmp_x_abs_1;
-            bf_set_ui(r, 1);
-            cmp_x_abs_1 = bf_cmpu(x, r);
-            if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUIRKS) &&
-                (y->expn >= BF_EXP_INF)) {
-                bf_set_nan(r);
-            } else if (cmp_x_abs_1 == 0 &&
-                       (!x->sign || y->expn != BF_EXP_NAN)) {
-                /* pow(1, y) = 1 even if y = NaN */
-                /* pow(-1, +/-inf) = 1 */
-            } else if (y->expn == BF_EXP_NAN) {
-                bf_set_nan(r);
-            } else if (y->expn == BF_EXP_INF) {
-                if (y->sign == (cmp_x_abs_1 > 0)) {
-                    bf_set_zero(r, 0);
-                } else {
-                    bf_set_inf(r, 0);
-                }
-            } else {
-                y_emin = bf_get_exp_min(y);
-                y_is_odd = (y_emin == 0);
-                if (y->sign == (x->expn == BF_EXP_ZERO)) {
-                    bf_set_inf(r, y_is_odd & x->sign);
-                    if (y->sign) {
-                        /* pow(0, y) with y < 0 */
-                        return BF_ST_DIVIDE_ZERO;
-                    }
-                } else {
-                    bf_set_zero(r, y_is_odd & x->sign);
-                }
-            }
-        }
-        return 0;
-    }
-    bf_init(s, T);
-    bf_set(T, x);
-    y_emin = bf_get_exp_min(y);
-    y_is_int = (y_emin >= 0);
-    rnd_mode = flags & BF_RND_MASK;
-    if (x->sign) {
-        if (!y_is_int) {
-            bf_set_nan(r);
-            bf_delete(T);
-            return BF_ST_INVALID_OP;
-        }
-        y_is_odd = (y_emin == 0);
-        r_sign = y_is_odd;
-        /* change the directed rounding mode if the sign of the result
-           is changed */
-        if (r_sign && (rnd_mode == BF_RNDD || rnd_mode == BF_RNDU))
-            flags ^= 1;
-        bf_neg(T);
-    } else {
-        r_sign = 0;
-    }
-
-    bf_set_ui(r, 1);
-    if (bf_cmp_eq(T, r)) {
-        /* abs(x) = 1: nothing more to do */
-        ret = 0;
-    } else {
-        /* check the overflow/underflow cases */
-        {
-            bf_t al_s, *al = &al_s;
-            bf_t ah_s, *ah = &ah_s;
-            limb_t precl = LIMB_BITS;
-            
-            bf_init(s, al);
-            bf_init(s, ah);
-            /* compute bounds of log(abs(x)) * y with a low precision */
-            /* XXX: compute bf_log() once */
-            /* XXX: add a fast test before this slow test */
-            bf_log(al, T, precl, BF_RNDD);
-            bf_log(ah, T, precl, BF_RNDU);
-            bf_mul(al, al, y, precl, BF_RNDD ^ y->sign);
-            bf_mul(ah, ah, y, precl, BF_RNDU ^ y->sign);
-            ret = check_exp_underflow_overflow(s, r, al, ah, prec, flags);
-            bf_delete(al);
-            bf_delete(ah);
-            if (ret)
-                goto done;
-        }
-        
-        if (y_is_int) {
-            slimb_t T_bits, e;
-        int_pow:
-            T_bits = T->expn - bf_get_exp_min(T);
-            if (T_bits == 1) {
-                /* pow(2^b, y) = 2^(b*y) */
-                bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
-                bf_get_limb(&e, T, 0);
-                bf_set_ui(r, 1);
-                ret = bf_mul_2exp(r, e, prec, flags);
-            } else if (prec == BF_PREC_INF) {
-                slimb_t y1;
-                /* specific case for infinite precision (integer case) */
-                bf_get_limb(&y1, y, 0);
-                assert(!y->sign);
-                /* x must be an integer, so abs(x) >= 2 */
-                if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
-                    bf_delete(T);
-                    return bf_set_overflow(r, 0, BF_PREC_INF, flags);
-                }
-                ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
-            } else {
-                if (y->expn <= 31) {
-                    /* small enough power: use exponentiation in all cases */
-                } else if (y->sign) {
-                    /* cannot be exact */
-                    goto general_case;
-                } else {
-                    if (rnd_mode == BF_RNDF)
-                        goto general_case; /* no need to track exact results */
-                    /* see if the result has a chance to be exact:
-                       if x=a*2^b (a odd), x^y=a^y*2^(b*y)
-                       x^y needs a precision of at least floor_log2(a)*y bits
-                    */
-                    bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
-                    bf_get_limb(&e, r, 0);
-                    if (prec < e)
-                        goto general_case;
-                }
-                ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
-            }
-        } else {
-            if (rnd_mode != BF_RNDF) {
-                bf_t *y1;
-                if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
-                    /* the problem is reduced to a power to an integer */
-#if 0
-                    printf("\nn=%" PRId64 "\n", -(int64_t)y_emin);
-                    bf_print_str("T", T);
-                    bf_print_str("r", r);
-#endif
-                    bf_set(T, r);
-                    y1 = &ytmp_s;
-                    y1->tab = y->tab;
-                    y1->len = y->len;
-                    y1->sign = y->sign;
-                    y1->expn = y->expn - y_emin;
-                    y = y1;
-                    goto int_pow;
-                }
-            }
-        general_case:
-            ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
-        }
-    }
- done:
-    bf_delete(T);
-    r->sign = r_sign;
-    return ret;
-}
-
-/* compute sqrt(-2*x-x^2) to get |sin(x)| from cos(x) - 1. */
-static void bf_sqrt_sin(bf_t *r, const bf_t *x, limb_t prec1)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    bf_init(s, T);
-    bf_set(T, x);
-    bf_mul(r, T, T, prec1, BF_RNDN);
-    bf_mul_2exp(T, 1, BF_PREC_INF, BF_RNDZ);
-    bf_add(T, T, r, prec1, BF_RNDN);
-    bf_neg(T);
-    bf_sqrt(r, T, prec1, BF_RNDF);
-    bf_delete(T);
-}
-
-static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
-{
-    bf_context_t *s1 = a->ctx;
-    bf_t T_s, *T = &T_s;
-    bf_t U_s, *U = &U_s;
-    bf_t r_s, *r = &r_s;
-    slimb_t K, prec1, i, l, mod, prec2;
-    int is_neg;
-    
-    assert(c != a && s != a);
-
-    bf_init(s1, T);
-    bf_init(s1, U);
-    bf_init(s1, r);
-    
-    /* XXX: precision analysis */
-    K = bf_isqrt(prec / 2);
-    l = prec / (2 * K) + 1;
-    prec1 = prec + 2 * K + l + 8;
-    
-    /* after the modulo reduction, -pi/4 <= T <= pi/4 */
-    if (a->expn <= -1) {
-        /* abs(a) <= 0.25: no modulo reduction needed */
-        bf_set(T, a);
-        mod = 0;
-    } else {
-        slimb_t cancel;
-        cancel = 0;
-        for(;;) {
-            prec2 = prec1 + a->expn + cancel;
-            bf_const_pi(U, prec2, BF_RNDF);
-            bf_mul_2exp(U, -1, BF_PREC_INF, BF_RNDZ);
-            bf_remquo(&mod, T, a, U, prec2, BF_RNDN, BF_RNDN);
-            //            printf("T.expn=%ld prec2=%ld\n", T->expn, prec2);
-            if (mod == 0 || (T->expn != BF_EXP_ZERO &&
-                             (T->expn + prec2) >= (prec1 - 1)))
-                break;
-            /* increase the number of bits until the precision is good enough */
-            cancel = bf_max(-T->expn, (cancel + 1) * 3 / 2);
-        }
-        mod &= 3;
-    }
-    
-    is_neg = T->sign;
-        
-    /* compute cosm1(x) = cos(x) - 1 */
-    bf_mul(T, T, T, prec1, BF_RNDN);
-    bf_mul_2exp(T, -2 * K, BF_PREC_INF, BF_RNDZ);
-    
-    /* Taylor expansion:
-       -x^2/2 + x^4/4! - x^6/6! + ...
-    */
-    bf_set_ui(r, 1);
-    for(i = l ; i >= 1; i--) {
-        bf_set_ui(U, 2 * i - 1);
-        bf_mul_ui(U, U, 2 * i, BF_PREC_INF, BF_RNDZ);
-        bf_div(U, T, U, prec1, BF_RNDN);
-        bf_mul(r, r, U, prec1, BF_RNDN);
-        bf_neg(r);
-        if (i != 1)
-            bf_add_si(r, r, 1, prec1, BF_RNDN);
-    }
-    bf_delete(U);
-
-    /* undo argument reduction:
-       cosm1(2*x)= 2*(2*cosm1(x)+cosm1(x)^2)
-    */
-    for(i = 0; i < K; i++) {
-        bf_mul(T, r, r, prec1, BF_RNDN);
-        bf_mul_2exp(r, 1, BF_PREC_INF, BF_RNDZ);
-        bf_add(r, r, T, prec1, BF_RNDN);
-        bf_mul_2exp(r, 1, BF_PREC_INF, BF_RNDZ);
-    }
-    bf_delete(T);
-
-    if (c) {
-        if ((mod & 1) == 0) {
-            bf_add_si(c, r, 1, prec1, BF_RNDN);
-        } else {
-            bf_sqrt_sin(c, r, prec1);
-            c->sign = is_neg ^ 1;
-        }
-        c->sign ^= mod >> 1;
-    }
-    if (s) {
-        if ((mod & 1) == 0) {
-            bf_sqrt_sin(s, r, prec1);
-            s->sign = is_neg;
-        } else {
-            bf_add_si(s, r, 1, prec1, BF_RNDN);
-        }
-        s->sign ^= mod >> 1;
-    }
-    bf_delete(r);
-    return BF_ST_INEXACT;
-}
-
-static int bf_cos_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    return bf_sincos(NULL, r, a, prec);
-}
-
-int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set_ui(r, 1);
-            return 0;
-        }
-    }
-
-    /* small argument case: result = 1+r(x) with r(x) = -x^2/2 +
-       O(X^4). We assume r(x) < 2^(2*EXP(x) - 1). */
-    if (a->expn < 0) {
-        slimb_t e;
-        e = 2 * a->expn - 1;
-        if (e < -(prec + 2)) {
-            bf_set_ui(r, 1);
-            return bf_add_epsilon(r, r, e, 1, prec, flags);
-        }
-    }
-    
-    return bf_ziv_rounding(r, a, prec, flags, bf_cos_internal, NULL);
-}
-
-static int bf_sin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    return bf_sincos(r, NULL, a, prec);
-}
-
-int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set_zero(r, a->sign);
-            return 0;
-        }
-    }
-
-    /* small argument case: result = x+r(x) with r(x) = -x^3/6 +
-       O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
-    if (a->expn < 0) {
-        slimb_t e;
-        e = sat_add(2 * a->expn, a->expn - 2);
-        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
-            bf_set(r, a);
-            return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
-        }
-    }
-
-    return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
-}
-
-static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1;
-    
-    /* XXX: precision analysis */
-    prec1 = prec + 8;
-    bf_init(s, T);
-    bf_sincos(r, T, a, prec1);
-    bf_div(r, r, T, prec1, BF_RNDF);
-    bf_delete(T);
-    return BF_ST_INEXACT;
-}
-
-int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    assert(r != a);
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set_zero(r, a->sign);
-            return 0;
-        }
-    }
-
-    /* small argument case: result = x+r(x) with r(x) = x^3/3 +
-       O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
-    if (a->expn < 0) {
-        slimb_t e;
-        e = sat_add(2 * a->expn, a->expn - 1);
-        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
-            bf_set(r, a);
-            return bf_add_epsilon(r, r, e, a->sign, prec, flags);
-        }
-    }
-            
-    return bf_ziv_rounding(r, a, prec, flags, bf_tan_internal, NULL);
-}
-
-/* if add_pi2 is true, add pi/2 to the result (used for acos(x) to
-   avoid cancellation) */
-static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
-                            void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    BOOL add_pi2 = (BOOL)(intptr_t)opaque;
-    bf_t T_s, *T = &T_s;
-    bf_t U_s, *U = &U_s;
-    bf_t V_s, *V = &V_s;
-    bf_t X2_s, *X2 = &X2_s;
-    int cmp_1;
-    slimb_t prec1, i, K, l;
-    
-    /* XXX: precision analysis */
-    K = bf_isqrt((prec + 1) / 2);
-    l = prec / (2 * K) + 1;
-    prec1 = prec + K + 2 * l + 32;
-    //    printf("prec=%d K=%d l=%d prec1=%d\n", (int)prec, (int)K, (int)l, (int)prec1);
-    
-    bf_init(s, T);
-    cmp_1 = (a->expn >= 1); /* a >= 1 */
-    if (cmp_1) {
-        bf_set_ui(T, 1);
-        bf_div(T, T, a, prec1, BF_RNDN);
-    } else {
-        bf_set(T, a);
-    }
-
-    /* abs(T) <= 1 */
-
-    /* argument reduction */
-
-    bf_init(s, U);
-    bf_init(s, V);
-    bf_init(s, X2);
-    for(i = 0; i < K; i++) {
-        /* T = T / (1 + sqrt(1 + T^2)) */
-        bf_mul(U, T, T, prec1, BF_RNDN);
-        bf_add_si(U, U, 1, prec1, BF_RNDN);
-        bf_sqrt(V, U, prec1, BF_RNDN);
-        bf_add_si(V, V, 1, prec1, BF_RNDN);
-        bf_div(T, T, V, prec1, BF_RNDN);
-    }
-
-    /* Taylor series: 
-       x - x^3/3 + ... + (-1)^ l * y^(2*l + 1) / (2*l+1) 
-    */
-    bf_mul(X2, T, T, prec1, BF_RNDN);
-    bf_set_ui(r, 0);
-    for(i = l; i >= 1; i--) {
-        bf_set_si(U, 1);
-        bf_set_ui(V, 2 * i + 1);
-        bf_div(U, U, V, prec1, BF_RNDN);
-        bf_neg(r);
-        bf_add(r, r, U, prec1, BF_RNDN);
-        bf_mul(r, r, X2, prec1, BF_RNDN);
-    }
-    bf_neg(r);
-    bf_add_si(r, r, 1, prec1, BF_RNDN);
-    bf_mul(r, r, T, prec1, BF_RNDN);
-
-    /* undo the argument reduction */
-    bf_mul_2exp(r, K, BF_PREC_INF, BF_RNDZ);
-    
-    bf_delete(U);
-    bf_delete(V);
-    bf_delete(X2);
-
-    i = add_pi2;
-    if (cmp_1 > 0) {
-        /* undo the inversion : r = sign(a)*PI/2 - r */
-        bf_neg(r);
-        i += 1 - 2 * a->sign;
-    }
-    /* add i*(pi/2) with -1 <= i <= 2 */
-    if (i != 0) {
-        bf_const_pi(T, prec1, BF_RNDF);
-        if (i != 2)
-            bf_mul_2exp(T, -1, BF_PREC_INF, BF_RNDZ);
-        T->sign = (i < 0);
-        bf_add(r, T, r, prec1, BF_RNDN);
-    }
-    
-    bf_delete(T);
-    return BF_ST_INEXACT;
-}
-
-int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    int res;
-    
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF)  {
-            /* -PI/2 or PI/2 */
-            bf_const_pi_signed(r, a->sign, prec, flags);
-            bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
-            return BF_ST_INEXACT;
-        } else {
-            bf_set_zero(r, a->sign);
-            return 0;
-        }
-    }
-    
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    res = bf_cmpu(a, T);
-    bf_delete(T);
-    if (res == 0) {
-        /* short cut: abs(a) == 1 -> +/-pi/4 */
-        bf_const_pi_signed(r, a->sign, prec, flags);
-        bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
-        return BF_ST_INEXACT;
-    }
-
-    /* small argument case: result = x+r(x) with r(x) = -x^3/3 +
-       O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
-    if (a->expn < 0) {
-        slimb_t e;
-        e = sat_add(2 * a->expn, a->expn - 1);
-        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
-            bf_set(r, a);
-            return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
-        }
-    }
-    
-    return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
-}
-
-static int bf_atan2_internal(bf_t *r, const bf_t *y, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    const bf_t *x = opaque;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1;
-    int ret;
-    
-    if (y->expn == BF_EXP_NAN || x->expn == BF_EXP_NAN) {
-        bf_set_nan(r);
-        return 0;
-    }
-
-    /* compute atan(y/x) assumming inf/inf = 1 and 0/0 = 0 */
-    bf_init(s, T);
-    prec1 = prec + 32;
-    if (y->expn == BF_EXP_INF && x->expn == BF_EXP_INF) {
-        bf_set_ui(T, 1);
-        T->sign = y->sign ^ x->sign;
-    } else if (y->expn == BF_EXP_ZERO && x->expn == BF_EXP_ZERO) {
-        bf_set_zero(T, y->sign ^ x->sign);
-    } else {
-        bf_div(T, y, x, prec1, BF_RNDF);
-    }
-    ret = bf_atan(r, T, prec1, BF_RNDF);
-
-    if (x->sign) {
-        /* if x < 0 (it includes -0), return sign(y)*pi + atan(y/x) */
-        bf_const_pi(T, prec1, BF_RNDF);
-        T->sign = y->sign;
-        bf_add(r, r, T, prec1, BF_RNDN);
-        ret |= BF_ST_INEXACT;
-    }
-
-    bf_delete(T);
-    return ret;
-}
-
-int bf_atan2(bf_t *r, const bf_t *y, const bf_t *x,
-             limb_t prec, bf_flags_t flags)
-{
-    return bf_ziv_rounding(r, y, prec, flags, bf_atan2_internal, (void *)x);
-}
-
-static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
-{
-    bf_context_t *s = r->ctx;
-    BOOL is_acos = (BOOL)(intptr_t)opaque;
-    bf_t T_s, *T = &T_s;
-    limb_t prec1, prec2;
-    
-    /* asin(x) = atan(x/sqrt(1-x^2)) 
-       acos(x) = pi/2 - asin(x) */
-    prec1 = prec + 8;
-    /* increase the precision in x^2 to compensate the cancellation in
-       (1-x^2) if x is close to 1 */
-    /* XXX: use less precision when possible */
-    if (a->expn >= 0)
-        prec2 = BF_PREC_INF;
-    else
-        prec2 = prec1;
-    bf_init(s, T);
-    bf_mul(T, a, a, prec2, BF_RNDN);
-    bf_neg(T);
-    bf_add_si(T, T, 1, prec2, BF_RNDN);
-
-    bf_sqrt(r, T, prec1, BF_RNDN);
-    bf_div(T, a, r, prec1, BF_RNDN);
-    if (is_acos)
-        bf_neg(T);
-    bf_atan_internal(r, T, prec1, (void *)(intptr_t)is_acos);
-    bf_delete(T);
-    return BF_ST_INEXACT;
-}
-
-int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    int res;
-
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_set_zero(r, a->sign);
-            return 0;
-        }
-    }
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    res = bf_cmpu(a, T);
-    bf_delete(T);
-    if (res > 0) {
-        bf_set_nan(r);
-        return BF_ST_INVALID_OP;
-    }
-    
-    /* small argument case: result = x+r(x) with r(x) = x^3/6 +
-       O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
-    if (a->expn < 0) {
-        slimb_t e;
-        e = sat_add(2 * a->expn, a->expn - 2);
-        if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
-            bf_set(r, a);
-            return bf_add_epsilon(r, r, e, a->sign, prec, flags);
-        }
-    }
-
-    return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)FALSE);
-}
-
-int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = r->ctx;
-    bf_t T_s, *T = &T_s;
-    int res;
-
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bf_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF) {
-            bf_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bf_const_pi(r, prec, flags);
-            bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
-            return BF_ST_INEXACT;
-        }
-    }
-    bf_init(s, T);
-    bf_set_ui(T, 1);
-    res = bf_cmpu(a, T);
-    bf_delete(T);
-    if (res > 0) {
-        bf_set_nan(r);
-        return BF_ST_INVALID_OP;
-    } else if (res == 0 && a->sign == 0) {
-        bf_set_zero(r, 0);
-        return 0;
-    }
-    
-    return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
-}
-
-/***************************************************************/
-/* decimal floating point numbers */
-
-#ifdef USE_BF_DEC
-
-#define adddq(r1, r0, a1, a0)                   \
-    do {                                        \
-        limb_t __t = r0;                        \
-        r0 += (a0);                             \
-        r1 += (a1) + (r0 < __t);                \
-    } while (0)
-
-#define subdq(r1, r0, a1, a0)                   \
-    do {                                        \
-        limb_t __t = r0;                        \
-        r0 -= (a0);                             \
-        r1 -= (a1) + (r0 > __t);                \
-    } while (0)
-
-#if LIMB_BITS == 64
-
-/* Note: we assume __int128 is available */
-#define muldq(r1, r0, a, b)                     \
-    do {                                        \
-        unsigned __int128 __t;                          \
-        __t = (unsigned __int128)(a) * (unsigned __int128)(b);  \
-        r0 = __t;                               \
-        r1 = __t >> 64;                         \
-    } while (0)
-
-#define divdq(q, r, a1, a0, b)                  \
-    do {                                        \
-        unsigned __int128 __t;                  \
-        limb_t __b = (b);                       \
-        __t = ((unsigned __int128)(a1) << 64) | (a0);   \
-        q = __t / __b;                                  \
-        r = __t % __b;                                  \
-    } while (0)
-
-#else
-
-#define muldq(r1, r0, a, b)                     \
-    do {                                        \
-        uint64_t __t;                          \
-        __t = (uint64_t)(a) * (uint64_t)(b);  \
-        r0 = __t;                               \
-        r1 = __t >> 32;                         \
-    } while (0)
-
-#define divdq(q, r, a1, a0, b)                  \
-    do {                                        \
-        uint64_t __t;                  \
-        limb_t __b = (b);                       \
-        __t = ((uint64_t)(a1) << 32) | (a0);   \
-        q = __t / __b;                                  \
-        r = __t % __b;                                  \
-    } while (0)
-
-#endif /* LIMB_BITS != 64 */
-
-#if LIMB_DIGITS == 19
-
-/* WARNING: hardcoded for b = 1e19. It is assumed that:
-   0 <= a1 < 2^63 */
-#define divdq_base(q, r, a1, a0)\
-do {\
-    uint64_t __a0, __a1, __t0, __t1, __b = BF_DEC_BASE; \
-    __a0 = a0;\
-    __a1 = a1;\
-    __t0 = __a1;\
-    __t0 = shld(__t0, __a0, 1);\
-    muldq(q, __t1, __t0, UINT64_C(17014118346046923173)); \
-    muldq(__t1, __t0, q, __b);\
-    subdq(__a1, __a0, __t1, __t0);\
-    subdq(__a1, __a0, 1, __b * 2);    \
-    __t0 = (slimb_t)__a1 >> 1; \
-    q += 2 + __t0;\
-    adddq(__a1, __a0, 0, __b & __t0);\
-    q += __a1;                  \
-    __a0 += __b & __a1;           \
-    r = __a0;\
-} while(0)
-
-#elif LIMB_DIGITS == 9
-
-/* WARNING: hardcoded for b = 1e9. It is assumed that:
-   0 <= a1 < 2^29 */
-#define divdq_base(q, r, a1, a0)\
-do {\
-    uint32_t __t0, __t1, __b = BF_DEC_BASE; \
-    __t0 = a1;\
-    __t1 = a0;\
-    __t0 = (__t0 << 3) | (__t1 >> (32 - 3));    \
-    muldq(q, __t1, __t0, 2305843009U);\
-    r = a0 - q * __b;\
-    __t1 = (r >= __b);\
-    q += __t1;\
-    if (__t1)\
-        r -= __b;\
-} while(0)
-
-#endif
-
-/* fast integer division by a fixed constant */
-
-typedef struct FastDivData {
-    limb_t m1; /* multiplier */
-    int8_t shift1;
-    int8_t shift2;
-} FastDivData;
-
-/* From "Division by Invariant Integers using Multiplication" by
-   Torborn Granlund and Peter L. Montgomery */
-/* d must be != 0 */
-static inline __maybe_unused void fast_udiv_init(FastDivData *s, limb_t d)
-{
-    int l;
-    limb_t q, r, m1;
-    if (d == 1)
-        l = 0;
-    else
-        l = 64 - clz64(d - 1);
-    divdq(q, r, ((limb_t)1 << l) - d, 0, d);
-    (void)r;
-    m1 = q + 1;
-    //    printf("d=%lu l=%d m1=0x%016lx\n", d, l, m1);
-    s->m1 = m1;
-    s->shift1 = l;
-    if (s->shift1 > 1)
-        s->shift1 = 1;
-    s->shift2 = l - 1;
-    if (s->shift2 < 0)
-        s->shift2 = 0;
-}
-
-static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
-{
-    limb_t t0, t1;
-    muldq(t1, t0, s->m1, a);
-    t0 = (a - t1) >> s->shift1;
-    return (t1 + t0) >> s->shift2;
-}
-
-/* contains 10^i */
-const limb_t mp_pow_dec[LIMB_DIGITS + 1] = {
-    1U,
-    10U,
-    100U,
-    1000U,
-    10000U,
-    100000U,
-    1000000U,
-    10000000U,
-    100000000U,
-    1000000000U,
-#if LIMB_BITS == 64
-    10000000000U,
-    100000000000U,
-    1000000000000U,
-    10000000000000U,
-    100000000000000U,
-    1000000000000000U,
-    10000000000000000U,
-    100000000000000000U,
-    1000000000000000000U,
-    10000000000000000000U,
-#endif
-};
-
-/* precomputed from fast_udiv_init(10^i) */
-static const FastDivData mp_pow_div[LIMB_DIGITS + 1] = {
-#if LIMB_BITS == 32
-    { 0x00000001, 0, 0 },
-    { 0x9999999a, 1, 3 },
-    { 0x47ae147b, 1, 6 },
-    { 0x0624dd30, 1, 9 },
-    { 0xa36e2eb2, 1, 13 },
-    { 0x4f8b588f, 1, 16 },
-    { 0x0c6f7a0c, 1, 19 },
-    { 0xad7f29ac, 1, 23 },
-    { 0x5798ee24, 1, 26 },
-    { 0x12e0be83, 1, 29 },
-#else
-    { 0x0000000000000001, 0, 0 },
-    { 0x999999999999999a, 1, 3 },
-    { 0x47ae147ae147ae15, 1, 6 },
-    { 0x0624dd2f1a9fbe77, 1, 9 },
-    { 0xa36e2eb1c432ca58, 1, 13 },
-    { 0x4f8b588e368f0847, 1, 16 },
-    { 0x0c6f7a0b5ed8d36c, 1, 19 },
-    { 0xad7f29abcaf48579, 1, 23 },
-    { 0x5798ee2308c39dfa, 1, 26 },
-    { 0x12e0be826d694b2f, 1, 29 },
-    { 0xb7cdfd9d7bdbab7e, 1, 33 },
-    { 0x5fd7fe17964955fe, 1, 36 },
-    { 0x19799812dea11198, 1, 39 },
-    { 0xc25c268497681c27, 1, 43 },
-    { 0x6849b86a12b9b01f, 1, 46 },
-    { 0x203af9ee756159b3, 1, 49 },
-    { 0xcd2b297d889bc2b7, 1, 53 },
-    { 0x70ef54646d496893, 1, 56 },
-    { 0x2725dd1d243aba0f, 1, 59 },
-    { 0xd83c94fb6d2ac34d, 1, 63 },
-#endif
-};
-
-/* divide by 10^shift with 0 <= shift <= LIMB_DIGITS */
-static inline limb_t fast_shr_dec(limb_t a, int shift)
-{
-    return fast_udiv(a, &mp_pow_div[shift]);
-}
-
-/* division and remainder by 10^shift */
-#define fast_shr_rem_dec(q, r, a, shift) q = fast_shr_dec(a, shift), r = a - q * mp_pow_dec[shift]
-    
-limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
-                  mp_size_t n, limb_t carry)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t k, a, v;
-
-    k=carry;
-    for(i=0;i<n;i++) {
-        /* XXX: reuse the trick in add_mod */
-        v = op1[i];
-        a = v + op2[i] + k - base;
-        k = a <= v;
-        if (!k) 
-            a += base;
-        res[i]=a;
-    }
-    return k;
-}
-
-limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t k, a, v;
-
-    k=b;
-    for(i=0;i<n;i++) {
-        v = tab[i];
-        a = v + k - base;
-        k = a <= v;
-        if (!k) 
-            a += base;
-        tab[i] = a;
-        if (k == 0)
-            break;
-    }
-    return k;
-}
-
-limb_t mp_sub_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
-                  mp_size_t n, limb_t carry)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t k, v, a;
-
-    k=carry;
-    for(i=0;i<n;i++) {
-        v = op1[i];
-        a = v - op2[i] - k;
-        k = a > v;
-        if (k)
-            a += base;
-        res[i] = a;
-    }
-    return k;
-}
-
-limb_t mp_sub_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t k, v, a;
-    
-    k=b;
-    for(i=0;i<n;i++) {
-        v = tab[i];
-        a = v - k;
-        k = a > v;
-        if (k)
-            a += base;
-        tab[i]=a;
-        if (k == 0)
-            break;
-    }
-    return k;
-}
-
-/* taba[] = taba[] * b + l. 0 <= b, l <= base - 1. Return the high carry */
-limb_t mp_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n, 
-                   limb_t b, limb_t l)
-{
-    mp_size_t i;
-    limb_t t0, t1, r;
-
-    for(i = 0; i < n; i++) {
-        muldq(t1, t0, taba[i], b);
-        adddq(t1, t0, 0, l);
-        divdq_base(l, r, t1, t0);
-        tabr[i] = r;
-    }
-    return l;
-}
-
-/* tabr[] += taba[] * b. 0 <= b <= base - 1. Return the value to add
-   to the high word */
-limb_t mp_add_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
-                       limb_t b)
-{
-    mp_size_t i;
-    limb_t l, t0, t1, r;
-
-    l = 0;
-    for(i = 0; i < n; i++) {
-        muldq(t1, t0, taba[i], b);
-        adddq(t1, t0, 0, l);
-        adddq(t1, t0, 0, tabr[i]);
-        divdq_base(l, r, t1, t0);
-        tabr[i] = r;
-    }
-    return l;
-}
-
-/* tabr[] -= taba[] * b. 0 <= b <= base - 1. Return the value to
-   substract to the high word. */
-limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
-                       limb_t b)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t l, t0, t1, r, a, v, c;
-
-    /* XXX: optimize */
-    l = 0;
-    for(i = 0; i < n; i++) {
-        muldq(t1, t0, taba[i], b);
-        adddq(t1, t0, 0, l);
-        divdq_base(l, r, t1, t0);
-        v = tabr[i];
-        a = v - r;
-        c = a > v;
-        if (c)
-            a += base;
-        /* never bigger than base because r = 0 when l = base - 1 */
-        l += c;
-        tabr[i] = a;
-    }
-    return l;
-}
-
-/* size of the result : op1_size + op2_size. */
-void mp_mul_basecase_dec(limb_t *result, 
-                         const limb_t *op1, mp_size_t op1_size, 
-                         const limb_t *op2, mp_size_t op2_size) 
-{
-    mp_size_t i;
-    limb_t r;
-    
-    result[op1_size] = mp_mul1_dec(result, op1, op1_size, op2[0], 0);
-
-    for(i=1;i<op2_size;i++) {
-        r = mp_add_mul1_dec(result + i, op1, op1_size, op2[i]);
-        result[i + op1_size] = r;
-    }
-}
-
-/* taba[] = (taba[] + r*base^na) / b. 0 <= b < base. 0 <= r <
-   b. Return the remainder. */
-limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na, 
-                   limb_t b, limb_t r)
-{
-    limb_t base = BF_DEC_BASE;
-    mp_size_t i;
-    limb_t t0, t1, q;
-    int shift;
-
-#if (BF_DEC_BASE % 2) == 0
-    if (b == 2) {
-        limb_t base_div2;
-        /* Note: only works if base is even */
-        base_div2 = base >> 1;
-        if (r)
-            r = base_div2;
-        for(i = na - 1; i >= 0; i--) {
-            t0 = taba[i];
-            tabr[i] = (t0 >> 1) + r;
-            r = 0;
-            if (t0 & 1)
-                r = base_div2;
-        }
-        if (r)
-            r = 1;
-    } else 
-#endif
-    if (na >= UDIV1NORM_THRESHOLD) {
-        shift = clz(b);
-        if (shift == 0) {
-            /* normalized case: b >= 2^(LIMB_BITS-1) */
-            limb_t b_inv;
-            b_inv = udiv1norm_init(b);
-            for(i = na - 1; i >= 0; i--) {
-                muldq(t1, t0, r, base);
-                adddq(t1, t0, 0, taba[i]);
-                q = udiv1norm(&r, t1, t0, b, b_inv);
-                tabr[i] = q;
-            }
-        } else {
-            limb_t b_inv;
-            b <<= shift;
-            b_inv = udiv1norm_init(b);
-            for(i = na - 1; i >= 0; i--) {
-                muldq(t1, t0, r, base);
-                adddq(t1, t0, 0, taba[i]);
-                t1 = (t1 << shift) | (t0 >> (LIMB_BITS - shift));
-                t0 <<= shift;
-                q = udiv1norm(&r, t1, t0, b, b_inv);
-                r >>= shift;
-                tabr[i] = q;
-            }
-        }
-    } else {
-        for(i = na - 1; i >= 0; i--) {
-            muldq(t1, t0, r, base);
-            adddq(t1, t0, 0, taba[i]);
-            divdq(q, r, t1, t0, b);
-            tabr[i] = q;
-        }
-    }
-    return r;
-}
-
-static __maybe_unused void mp_print_str_dec(const char *str,
-                                       const limb_t *tab, slimb_t n)
-{
-    slimb_t i;
-    printf("%s=", str);
-    for(i = n - 1; i >= 0; i--) {
-        if (i != n - 1)
-            printf("_");
-        printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
-    }
-    printf("\n");
-}
-
-static __maybe_unused void mp_print_str_h_dec(const char *str,
-                                              const limb_t *tab, slimb_t n,
-                                              limb_t high)
-{
-    slimb_t i;
-    printf("%s=", str);
-    printf("%0*" PRIu_LIMB, LIMB_DIGITS, high);
-    for(i = n - 1; i >= 0; i--) {
-        printf("_");
-        printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
-    }
-    printf("\n");
-}
-
-//#define DEBUG_DIV_SLOW
-
-#define DIV_STATIC_ALLOC_LEN 16
-
-/* return q = a / b and r = a % b. 
-
-   taba[na] must be allocated if tabb1[nb - 1] < B / 2.  tabb1[nb - 1]
-   must be != zero. na must be >= nb. 's' can be NULL if tabb1[nb - 1]
-   >= B / 2.
-
-   The remainder is is returned in taba and contains nb libms. tabq
-   contains na - nb + 1 limbs. No overlap is permitted.
-
-   Running time of the standard method: (na - nb + 1) * nb
-   Return 0 if OK, -1 if memory alloc error
-*/
-/* XXX: optimize */
-static int mp_div_dec(bf_context_t *s, limb_t *tabq,
-                      limb_t *taba, mp_size_t na, 
-                      const limb_t *tabb1, mp_size_t nb)
-{
-    limb_t base = BF_DEC_BASE;
-    limb_t r, mult, t0, t1, a, c, q, v, *tabb;
-    mp_size_t i, j;
-    limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
-    
-#ifdef DEBUG_DIV_SLOW
-    mp_print_str_dec("a", taba, na);
-    mp_print_str_dec("b", tabb1, nb);
-#endif
-
-    /* normalize tabb */
-    r = tabb1[nb - 1];
-    assert(r != 0);
-    i = na - nb;
-    if (r >= BF_DEC_BASE / 2) {
-        mult = 1;
-        tabb = (limb_t *)tabb1;
-        q = 1;
-        for(j = nb - 1; j >= 0; j--) {
-            if (taba[i + j] != tabb[j]) {
-                if (taba[i + j] < tabb[j])
-                    q = 0;
-                break;
-            }
-        }
-        tabq[i] = q;
-        if (q) {
-            mp_sub_dec(taba + i, taba + i, tabb, nb, 0);
-        }
-        i--;
-    } else {
-        mult = base / (r + 1);
-        if (likely(nb <= DIV_STATIC_ALLOC_LEN)) {
-            tabb = static_tabb;
-        } else {
-            tabb = bf_malloc(s, sizeof(limb_t) * nb);
-            if (!tabb)
-                return -1;
-        }
-        mp_mul1_dec(tabb, tabb1, nb, mult, 0);
-        taba[na] = mp_mul1_dec(taba, taba, na, mult, 0);
-    }
-
-#ifdef DEBUG_DIV_SLOW
-    printf("mult=" FMT_LIMB "\n", mult);
-    mp_print_str_dec("a_norm", taba, na + 1);
-    mp_print_str_dec("b_norm", tabb, nb);
-#endif
-
-    for(; i >= 0; i--) {
-        if (unlikely(taba[i + nb] >= tabb[nb - 1])) {
-            /* XXX: check if it is really possible */
-            q = base - 1;
-        } else {
-            muldq(t1, t0, taba[i + nb], base);
-            adddq(t1, t0, 0, taba[i + nb - 1]);
-            divdq(q, r, t1, t0, tabb[nb - 1]);
-        }
-        //        printf("i=%d q1=%ld\n", i, q);
-
-        r = mp_sub_mul1_dec(taba + i, tabb, nb, q);
-        //        mp_dump("r1", taba + i, nb, bd);
-        //        printf("r2=%ld\n", r);
-
-        v = taba[i + nb];
-        a = v - r;
-        c = a > v;
-        if (c)
-            a += base;
-        taba[i + nb] = a;
-
-        if (c != 0) {
-            /* negative result */
-            for(;;) {
-                q--;
-                c = mp_add_dec(taba + i, taba + i, tabb, nb, 0);
-                /* propagate carry and test if positive result */
-                if (c != 0) {
-                    if (++taba[i + nb] == base) {
-                        break;
-                    }
-                }
-            }
-        }
-        tabq[i] = q;
-    }
-
-#ifdef DEBUG_DIV_SLOW
-    mp_print_str_dec("q", tabq, na - nb + 1);
-    mp_print_str_dec("r", taba, nb);
-#endif
-
-    /* remove the normalization */
-    if (mult != 1) {
-        mp_div1_dec(taba, taba, nb, mult, 0);
-        if (unlikely(tabb != static_tabb))
-            bf_free(s, tabb);
-    }
-    return 0;
-}
-
-/* divide by 10^shift */
-static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
-                         limb_t shift, limb_t high)
-{
-    mp_size_t i;
-    limb_t l, a, q, r;
-
-    assert(shift >= 1 && shift < LIMB_DIGITS);
-    l = high;
-    for(i = n - 1; i >= 0; i--) {
-        a = tab[i];
-        fast_shr_rem_dec(q, r, a, shift);
-        tab_r[i] = q + l * mp_pow_dec[LIMB_DIGITS - shift];
-        l = r;
-    }
-    return l;
-}
-
-/* multiply by 10^shift */
-static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
-                         limb_t shift, limb_t low)
-{
-    mp_size_t i;
-    limb_t l, a, q, r;
-
-    assert(shift >= 1 && shift < LIMB_DIGITS);
-    l = low;
-    for(i = 0; i < n; i++) {
-        a = tab[i];
-        fast_shr_rem_dec(q, r, a, LIMB_DIGITS - shift);
-        tab_r[i] = r * mp_pow_dec[shift] + l;
-        l = q;
-    }
-    return l;
-}
-
-static limb_t mp_sqrtrem2_dec(limb_t *tabs, limb_t *taba)
-{
-    int k;
-    dlimb_t a, b, r;
-    limb_t taba1[2], s, r0, r1;
-
-    /* convert to binary and normalize */
-    a = (dlimb_t)taba[1] * BF_DEC_BASE + taba[0];
-    k = clz(a >> LIMB_BITS) & ~1;
-    b = a << k;
-    taba1[0] = b;
-    taba1[1] = b >> LIMB_BITS;
-    mp_sqrtrem2(&s, taba1);
-    s >>= (k >> 1);
-    /* convert the remainder back to decimal */
-    r = a - (dlimb_t)s * (dlimb_t)s;
-    divdq_base(r1, r0, r >> LIMB_BITS, r);
-    taba[0] = r0;
-    tabs[0] = s;
-    return r1;
-}
-
-//#define DEBUG_SQRTREM_DEC
-
-/* tmp_buf must contain (n / 2 + 1 limbs) */
-static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
-                                 limb_t *tmp_buf)
-{
-    limb_t l, h, rh, ql, qh, c, i;
-    
-    if (n == 1)
-        return mp_sqrtrem2_dec(tabs, taba);
-#ifdef DEBUG_SQRTREM_DEC
-    mp_print_str_dec("a", taba, 2 * n);
-#endif
-    l = n / 2;
-    h = n - l;
-    qh = mp_sqrtrem_rec_dec(tabs + l, taba + 2 * l, h, tmp_buf);
-#ifdef DEBUG_SQRTREM_DEC
-    mp_print_str_dec("s1", tabs + l, h);
-    mp_print_str_h_dec("r1", taba + 2 * l, h, qh);
-    mp_print_str_h_dec("r2", taba + l, n, qh);
-#endif
-    
-    /* the remainder is in taba + 2 * l. Its high bit is in qh */
-    if (qh) {
-        mp_sub_dec(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
-    }
-    /* instead of dividing by 2*s, divide by s (which is normalized)
-       and update q and r */
-    mp_div_dec(NULL, tmp_buf, taba + l, n, tabs + l, h);
-    qh += tmp_buf[l];
-    for(i = 0; i < l; i++)
-        tabs[i] = tmp_buf[i];
-    ql = mp_div1_dec(tabs, tabs, l, 2, qh & 1);
-    qh = qh >> 1; /* 0 or 1 */
-    if (ql)
-        rh = mp_add_dec(taba + l, taba + l, tabs + l, h, 0);
-    else
-        rh = 0;
-#ifdef DEBUG_SQRTREM_DEC
-    mp_print_str_h_dec("q", tabs, l, qh);
-    mp_print_str_h_dec("u", taba + l, h, rh);
-#endif
-    
-    mp_add_ui_dec(tabs + l, qh, h);
-#ifdef DEBUG_SQRTREM_DEC
-    mp_print_str_dec("s2", tabs, n);
-#endif
-    
-    /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
-    /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
-    if (qh) {
-        c = qh;
-    } else {
-        mp_mul_basecase_dec(taba + n, tabs, l, tabs, l);
-        c = mp_sub_dec(taba, taba, taba + n, 2 * l, 0);
-    }
-    rh -= mp_sub_ui_dec(taba + 2 * l, c, n - 2 * l);
-    if ((slimb_t)rh < 0) {
-        mp_sub_ui_dec(tabs, 1, n);
-        rh += mp_add_mul1_dec(taba, tabs, n, 2);
-        rh += mp_add_ui_dec(taba, 1, n);
-    }
-    return rh;
-}
-
-/* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= B/4. Return (s,
-   r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2 * s. tabs has n
-   limbs. r is returned in the lower n limbs of taba. Its r[n] is the
-   returned value of the function. */
-int mp_sqrtrem_dec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
-{
-    limb_t tmp_buf1[8];
-    limb_t *tmp_buf;
-    mp_size_t n2;
-    n2 = n / 2 + 1;
-    if (n2 <= countof(tmp_buf1)) {
-        tmp_buf = tmp_buf1;
-    } else {
-        tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
-        if (!tmp_buf)
-            return -1;
-    }
-    taba[n] = mp_sqrtrem_rec_dec(tabs, taba, n, tmp_buf);
-    if (tmp_buf != tmp_buf1)
-        bf_free(s, tmp_buf);
-    return 0;
-}
-
-/* return the number of leading zero digits, from 0 to LIMB_DIGITS */
-static int clz_dec(limb_t a)
-{
-    if (a == 0)
-        return LIMB_DIGITS;
-    switch(LIMB_BITS - 1 - clz(a)) {
-    case 0: /* 1-1 */
-        return LIMB_DIGITS - 1;
-    case 1: /* 2-3 */
-        return LIMB_DIGITS - 1;
-    case 2: /* 4-7 */
-        return LIMB_DIGITS - 1;
-    case 3: /* 8-15 */
-        if (a < 10)
-            return LIMB_DIGITS - 1;
-        else
-            return LIMB_DIGITS - 2;
-    case 4: /* 16-31 */
-        return LIMB_DIGITS - 2;
-    case 5: /* 32-63 */
-        return LIMB_DIGITS - 2;
-    case 6: /* 64-127 */
-        if (a < 100)
-            return LIMB_DIGITS - 2;
-        else
-            return LIMB_DIGITS - 3;
-    case 7: /* 128-255 */
-        return LIMB_DIGITS - 3;
-    case 8: /* 256-511 */
-        return LIMB_DIGITS - 3;
-    case 9: /* 512-1023 */
-        if (a < 1000)
-            return LIMB_DIGITS - 3;
-        else
-            return LIMB_DIGITS - 4;
-    case 10: /* 1024-2047 */
-        return LIMB_DIGITS - 4;
-    case 11: /* 2048-4095 */
-        return LIMB_DIGITS - 4;
-    case 12: /* 4096-8191 */
-        return LIMB_DIGITS - 4;
-    case 13: /* 8192-16383 */
-        if (a < 10000)
-            return LIMB_DIGITS - 4;
-        else
-            return LIMB_DIGITS - 5;
-    case 14: /* 16384-32767 */
-        return LIMB_DIGITS - 5;
-    case 15: /* 32768-65535 */
-        return LIMB_DIGITS - 5;
-    case 16: /* 65536-131071 */
-        if (a < 100000)
-            return LIMB_DIGITS - 5;
-        else
-            return LIMB_DIGITS - 6;
-    case 17: /* 131072-262143 */
-        return LIMB_DIGITS - 6;
-    case 18: /* 262144-524287 */
-        return LIMB_DIGITS - 6;
-    case 19: /* 524288-1048575 */
-        if (a < 1000000)
-            return LIMB_DIGITS - 6;
-        else
-            return LIMB_DIGITS - 7;
-    case 20: /* 1048576-2097151 */
-        return LIMB_DIGITS - 7;
-    case 21: /* 2097152-4194303 */
-        return LIMB_DIGITS - 7;
-    case 22: /* 4194304-8388607 */
-        return LIMB_DIGITS - 7;
-    case 23: /* 8388608-16777215 */
-        if (a < 10000000)
-            return LIMB_DIGITS - 7;
-        else
-            return LIMB_DIGITS - 8;
-    case 24: /* 16777216-33554431 */
-        return LIMB_DIGITS - 8;
-    case 25: /* 33554432-67108863 */
-        return LIMB_DIGITS - 8;
-    case 26: /* 67108864-134217727 */
-        if (a < 100000000)
-            return LIMB_DIGITS - 8;
-        else
-            return LIMB_DIGITS - 9;
-#if LIMB_BITS == 64
-    case 27: /* 134217728-268435455 */
-        return LIMB_DIGITS - 9;
-    case 28: /* 268435456-536870911 */
-        return LIMB_DIGITS - 9;
-    case 29: /* 536870912-1073741823 */
-        if (a < 1000000000)
-            return LIMB_DIGITS - 9;
-        else
-            return LIMB_DIGITS - 10;
-    case 30: /* 1073741824-2147483647 */
-        return LIMB_DIGITS - 10;
-    case 31: /* 2147483648-4294967295 */
-        return LIMB_DIGITS - 10;
-    case 32: /* 4294967296-8589934591 */
-        return LIMB_DIGITS - 10;
-    case 33: /* 8589934592-17179869183 */
-        if (a < 10000000000)
-            return LIMB_DIGITS - 10;
-        else
-            return LIMB_DIGITS - 11;
-    case 34: /* 17179869184-34359738367 */
-        return LIMB_DIGITS - 11;
-    case 35: /* 34359738368-68719476735 */
-        return LIMB_DIGITS - 11;
-    case 36: /* 68719476736-137438953471 */
-        if (a < 100000000000)
-            return LIMB_DIGITS - 11;
-        else
-            return LIMB_DIGITS - 12;
-    case 37: /* 137438953472-274877906943 */
-        return LIMB_DIGITS - 12;
-    case 38: /* 274877906944-549755813887 */
-        return LIMB_DIGITS - 12;
-    case 39: /* 549755813888-1099511627775 */
-        if (a < 1000000000000)
-            return LIMB_DIGITS - 12;
-        else
-            return LIMB_DIGITS - 13;
-    case 40: /* 1099511627776-2199023255551 */
-        return LIMB_DIGITS - 13;
-    case 41: /* 2199023255552-4398046511103 */
-        return LIMB_DIGITS - 13;
-    case 42: /* 4398046511104-8796093022207 */
-        return LIMB_DIGITS - 13;
-    case 43: /* 8796093022208-17592186044415 */
-        if (a < 10000000000000)
-            return LIMB_DIGITS - 13;
-        else
-            return LIMB_DIGITS - 14;
-    case 44: /* 17592186044416-35184372088831 */
-        return LIMB_DIGITS - 14;
-    case 45: /* 35184372088832-70368744177663 */
-        return LIMB_DIGITS - 14;
-    case 46: /* 70368744177664-140737488355327 */
-        if (a < 100000000000000)
-            return LIMB_DIGITS - 14;
-        else
-            return LIMB_DIGITS - 15;
-    case 47: /* 140737488355328-281474976710655 */
-        return LIMB_DIGITS - 15;
-    case 48: /* 281474976710656-562949953421311 */
-        return LIMB_DIGITS - 15;
-    case 49: /* 562949953421312-1125899906842623 */
-        if (a < 1000000000000000)
-            return LIMB_DIGITS - 15;
-        else
-            return LIMB_DIGITS - 16;
-    case 50: /* 1125899906842624-2251799813685247 */
-        return LIMB_DIGITS - 16;
-    case 51: /* 2251799813685248-4503599627370495 */
-        return LIMB_DIGITS - 16;
-    case 52: /* 4503599627370496-9007199254740991 */
-        return LIMB_DIGITS - 16;
-    case 53: /* 9007199254740992-18014398509481983 */
-        if (a < 10000000000000000)
-            return LIMB_DIGITS - 16;
-        else
-            return LIMB_DIGITS - 17;
-    case 54: /* 18014398509481984-36028797018963967 */
-        return LIMB_DIGITS - 17;
-    case 55: /* 36028797018963968-72057594037927935 */
-        return LIMB_DIGITS - 17;
-    case 56: /* 72057594037927936-144115188075855871 */
-        if (a < 100000000000000000)
-            return LIMB_DIGITS - 17;
-        else
-            return LIMB_DIGITS - 18;
-    case 57: /* 144115188075855872-288230376151711743 */
-        return LIMB_DIGITS - 18;
-    case 58: /* 288230376151711744-576460752303423487 */
-        return LIMB_DIGITS - 18;
-    case 59: /* 576460752303423488-1152921504606846975 */
-        if (a < 1000000000000000000)
-            return LIMB_DIGITS - 18;
-        else
-            return LIMB_DIGITS - 19;
-#endif
-    default:
-        return 0;
-    }
-}
-
-/* for debugging */
-void bfdec_print_str(const char *str, const bfdec_t *a)
-{
-    slimb_t i;
-    printf("%s=", str);
-
-    if (a->expn == BF_EXP_NAN) {
-        printf("NaN");
-    } else {
-        if (a->sign)
-            putchar('-');
-        if (a->expn == BF_EXP_ZERO) {
-            putchar('0');
-        } else if (a->expn == BF_EXP_INF) {
-            printf("Inf");
-        } else {
-            printf("0.");
-            for(i = a->len - 1; i >= 0; i--)
-                printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
-            printf("e%" PRId_LIMB, a->expn);
-        }
-    }
-    printf("\n");
-}
-
-/* return != 0 if one digit between 0 and bit_pos inclusive is not zero. */
-static inline limb_t scan_digit_nz(const bfdec_t *r, slimb_t bit_pos)
-{
-    slimb_t pos;
-    limb_t v, q;
-    int shift;
-
-    if (bit_pos < 0)
-        return 0;
-    pos = (limb_t)bit_pos / LIMB_DIGITS;
-    shift = (limb_t)bit_pos % LIMB_DIGITS;
-    fast_shr_rem_dec(q, v, r->tab[pos], shift + 1);
-    (void)q;
-    if (v != 0)
-        return 1;
-    pos--;
-    while (pos >= 0) {
-        if (r->tab[pos] != 0)
-            return 1;
-        pos--;
-    }
-    return 0;
-}
-
-static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos)
-{
-    slimb_t i;
-    int shift;
-    i = floor_div(pos, LIMB_DIGITS);
-    if (i < 0 || i >= len)
-        return 0;
-    shift = pos - i * LIMB_DIGITS;
-    return fast_shr_dec(tab[i], shift) % 10;
-}
-
-#if 0
-static limb_t get_digits(const limb_t *tab, limb_t len, slimb_t pos)
-{
-    limb_t a0, a1;
-    int shift;
-    slimb_t i;
-    
-    i = floor_div(pos, LIMB_DIGITS);
-    shift = pos - i * LIMB_DIGITS;
-    if (i >= 0 && i < len)
-        a0 = tab[i];
-    else
-        a0 = 0;
-    if (shift == 0) {
-        return a0;
-    } else {
-        i++;
-        if (i >= 0 && i < len)
-            a1 = tab[i];
-        else
-            a1 = 0;
-        return fast_shr_dec(a0, shift) +
-            fast_urem(a1, &mp_pow_div[LIMB_DIGITS - shift]) *
-            mp_pow_dec[shift];
-    }
-}
-#endif
-
-/* return the addend for rounding. Note that prec can be <= 0 for bf_rint() */
-static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
-                             slimb_t prec, int rnd_mode)
-{
-    int add_one, inexact;
-    limb_t digit1, digit0;
-    
-    //    bfdec_print_str("get_rnd_add", r);
-    if (rnd_mode == BF_RNDF) {
-        digit0 = 1; /* faithful rounding does not honor the INEXACT flag */
-    } else {
-        /* starting limb for bit 'prec + 1' */
-        digit0 = scan_digit_nz(r, l * LIMB_DIGITS - 1 - bf_max(0, prec + 1));
-    }
-
-    /* get the digit at 'prec' */
-    digit1 = get_digit(r->tab, l, l * LIMB_DIGITS - 1 - prec);
-    inexact = (digit1 | digit0) != 0;
-    
-    add_one = 0;
-    switch(rnd_mode) {
-    case BF_RNDZ:
-        break;
-    case BF_RNDN:
-        if (digit1 == 5) {
-            if (digit0) {
-                add_one = 1;
-            } else {
-                /* round to even */
-                add_one =
-                    get_digit(r->tab, l, l * LIMB_DIGITS - 1 - (prec - 1)) & 1;
-            }
-        } else if (digit1 > 5) {
-            add_one = 1;
-        }
-        break;
-    case BF_RNDD:
-    case BF_RNDU:
-        if (r->sign == (rnd_mode == BF_RNDD))
-            add_one = inexact;
-        break;
-    case BF_RNDNA:
-    case BF_RNDF:
-        add_one = (digit1 >= 5);
-        break;
-    case BF_RNDA:
-        add_one = inexact;
-        break;
-    default:
-        abort();
-    }
-    
-    if (inexact)
-        *pret |= BF_ST_INEXACT;
-    return add_one;
-}
-
-/* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
-   assumed to have length 'l' (1 <= l <= r->len). prec1 can be
-   BF_PREC_INF. BF_FLAG_SUBNORMAL is not supported. Cannot fail with
-   BF_ST_MEM_ERROR.
- */
-static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
-{
-    int shift, add_one, rnd_mode, ret;
-    slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
-
-    /* XXX: align to IEEE 754 2008 for decimal numbers ? */
-    e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
-    e_min = -e_range + 3;
-    e_max = e_range;
-    
-    if (flags & BF_FLAG_RADPNT_PREC) {
-        /* 'prec' is the precision after the decimal point */
-        if (prec1 != BF_PREC_INF)
-            prec = r->expn + prec1;
-        else
-            prec = prec1;
-    } else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
-        /* restrict the precision in case of potentially subnormal
-           result */
-        assert(prec1 != BF_PREC_INF);
-        prec = prec1 - (e_min - r->expn);
-    } else {
-        prec = prec1;
-    }
-    
-    /* round to prec bits */
-    rnd_mode = flags & BF_RND_MASK;
-    ret = 0;
-    add_one = bfdec_get_rnd_add(&ret, r, l, prec, rnd_mode);
-    
-    if (prec <= 0) {
-        if (add_one) {
-            bfdec_resize(r, 1); /* cannot fail because r is non zero */
-            r->tab[0] = BF_DEC_BASE / 10;
-            r->expn += 1 - prec;
-            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
-            return ret;
-        } else {
-            goto underflow;
-        }
-    } else if (add_one) {
-        limb_t carry;
-        
-        /* add one starting at digit 'prec - 1' */
-        bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
-        pos = bit_pos / LIMB_DIGITS;
-        carry = mp_pow_dec[bit_pos % LIMB_DIGITS];
-        carry = mp_add_ui_dec(r->tab + pos, carry, l - pos);
-        if (carry) {
-            /* shift right by one digit */
-            mp_shr_dec(r->tab + pos, r->tab + pos, l - pos, 1, 1);
-            r->expn++;
-        }
-    }
-    
-    /* check underflow */
-    if (unlikely(r->expn < e_min)) {
-        if (flags & BF_FLAG_SUBNORMAL) {
-            /* if inexact, also set the underflow flag */
-            if (ret & BF_ST_INEXACT)
-                ret |= BF_ST_UNDERFLOW;
-        } else {
-        underflow:
-            bfdec_set_zero(r, r->sign);
-            ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
-            return ret;
-        }
-    }
-    
-    /* check overflow */
-    if (unlikely(r->expn > e_max)) {
-        bfdec_set_inf(r, r->sign);
-        ret |= BF_ST_OVERFLOW | BF_ST_INEXACT;
-        return ret;
-    }
-    
-    /* keep the bits starting at 'prec - 1' */
-    bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
-    i = floor_div(bit_pos, LIMB_DIGITS);
-    if (i >= 0) {
-        shift = smod(bit_pos, LIMB_DIGITS);
-        if (shift != 0) {
-            r->tab[i] = fast_shr_dec(r->tab[i], shift) *
-                mp_pow_dec[shift];
-        }
-    } else {
-        i = 0;
-    }
-    /* remove trailing zeros */
-    while (r->tab[i] == 0)
-        i++;
-    if (i > 0) {
-        l -= i;
-        memmove(r->tab, r->tab + i, l * sizeof(limb_t));
-    }
-    bfdec_resize(r, l); /* cannot fail */
-    return ret;
-}
-
-/* Cannot fail with BF_ST_MEM_ERROR. */
-int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags)
-{
-    if (r->len == 0)
-        return 0;
-    return __bfdec_round(r, prec, flags, r->len);
-}
-
-/* 'r' must be a finite number. Cannot fail with BF_ST_MEM_ERROR.  */
-int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags)
-{
-    limb_t l, v;
-    int shift, ret;
-    
-    //    bfdec_print_str("bf_renorm", r);
-    l = r->len;
-    while (l > 0 && r->tab[l - 1] == 0)
-        l--;
-    if (l == 0) {
-        /* zero */
-        r->expn = BF_EXP_ZERO;
-        bfdec_resize(r, 0); /* cannot fail */
-        ret = 0;
-    } else {
-        r->expn -= (r->len - l) * LIMB_DIGITS;
-        /* shift to have the MSB set to '1' */
-        v = r->tab[l - 1];
-        shift = clz_dec(v);
-        if (shift != 0) {
-            mp_shl_dec(r->tab, r->tab, l, shift, 0);
-            r->expn -= shift;
-        }
-        ret = __bfdec_round(r, prec1, flags, l);
-    }
-    //    bf_print_str("r_final", r);
-    return ret;
-}
-
-int bfdec_set_ui(bfdec_t *r, uint64_t v)
-{
-#if LIMB_BITS == 32
-    if (v >= BF_DEC_BASE * BF_DEC_BASE) {
-        if (bfdec_resize(r, 3))
-            goto fail;
-        r->tab[0] = v % BF_DEC_BASE;
-        v /= BF_DEC_BASE;
-        r->tab[1] = v % BF_DEC_BASE;
-        r->tab[2] = v / BF_DEC_BASE;
-        r->expn = 3 * LIMB_DIGITS;
-    } else
-#endif
-    if (v >= BF_DEC_BASE) {
-        if (bfdec_resize(r, 2))
-            goto fail;
-        r->tab[0] = v % BF_DEC_BASE;
-        r->tab[1] = v / BF_DEC_BASE;
-        r->expn = 2 * LIMB_DIGITS;
-    } else {
-        if (bfdec_resize(r, 1))
-            goto fail;
-        r->tab[0] = v;
-        r->expn = LIMB_DIGITS;
-    }
-    r->sign = 0;
-    return bfdec_normalize_and_round(r, BF_PREC_INF, 0);
- fail:
-    bfdec_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-int bfdec_set_si(bfdec_t *r, int64_t v)
-{
-    int ret;
-    if (v < 0) {
-        ret = bfdec_set_ui(r, -v);
-        r->sign = 1;
-    } else {
-        ret = bfdec_set_ui(r, v);
-    }
-    return ret;
-}
-
-static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec, bf_flags_t flags, int b_neg)
-{
-    bf_context_t *s = r->ctx;
-    int is_sub, cmp_res, a_sign, b_sign, ret;
-
-    a_sign = a->sign;
-    b_sign = b->sign ^ b_neg;
-    is_sub = a_sign ^ b_sign;
-    cmp_res = bfdec_cmpu(a, b);
-    if (cmp_res < 0) {
-        const bfdec_t *tmp;
-        tmp = a;
-        a = b;
-        b = tmp;
-        a_sign = b_sign; /* b_sign is never used later */
-    }
-    /* abs(a) >= abs(b) */
-    if (cmp_res == 0 && is_sub && a->expn < BF_EXP_INF) {
-        /* zero result */
-        bfdec_set_zero(r, (flags & BF_RND_MASK) == BF_RNDD);
-        ret = 0;
-    } else if (a->len == 0 || b->len == 0) {
-        ret = 0;
-        if (a->expn >= BF_EXP_INF) {
-            if (a->expn == BF_EXP_NAN) {
-                /* at least one operand is NaN */
-                bfdec_set_nan(r);
-                ret = 0;
-            } else if (b->expn == BF_EXP_INF && is_sub) {
-                /* infinities with different signs */
-                bfdec_set_nan(r);
-                ret = BF_ST_INVALID_OP;
-            } else {
-                bfdec_set_inf(r, a_sign);
-            }
-        } else {
-            /* at least one zero and not subtract */
-            if (bfdec_set(r, a))
-                return BF_ST_MEM_ERROR;
-            r->sign = a_sign;
-            goto renorm;
-        }
-    } else {
-        slimb_t d, a_offset, b_offset, i, r_len;
-        limb_t carry;
-        limb_t *b1_tab;
-        int b_shift;
-        mp_size_t b1_len;
-        
-        d = a->expn - b->expn;
-
-        /* XXX: not efficient in time and memory if the precision is
-           not infinite */
-        r_len = bf_max(a->len, b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
-        if (bfdec_resize(r, r_len))
-            goto fail;
-        r->sign = a_sign;
-        r->expn = a->expn;
-
-        a_offset = r_len - a->len;
-        for(i = 0; i < a_offset; i++)
-            r->tab[i] = 0;
-        for(i = 0; i < a->len; i++)
-            r->tab[a_offset + i] = a->tab[i];
-        
-        b_shift = d % LIMB_DIGITS;
-        if (b_shift == 0) {
-            b1_len = b->len;
-            b1_tab = (limb_t *)b->tab;
-        } else {
-            b1_len = b->len + 1;
-            b1_tab = bf_malloc(s, sizeof(limb_t) * b1_len);
-            if (!b1_tab)
-                goto fail;
-            b1_tab[0] = mp_shr_dec(b1_tab + 1, b->tab, b->len, b_shift, 0) *
-                mp_pow_dec[LIMB_DIGITS - b_shift];
-        }
-        b_offset = r_len - (b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
-        
-        if (is_sub) {
-            carry = mp_sub_dec(r->tab + b_offset, r->tab + b_offset,
-                               b1_tab, b1_len, 0);
-            if (carry != 0) {
-                carry = mp_sub_ui_dec(r->tab + b_offset + b1_len, carry,
-                                      r_len - (b_offset + b1_len));
-                assert(carry == 0);
-            }
-        } else {
-            carry = mp_add_dec(r->tab + b_offset, r->tab + b_offset,
-                               b1_tab, b1_len, 0);
-            if (carry != 0) {
-                carry = mp_add_ui_dec(r->tab + b_offset + b1_len, carry,
-                                      r_len - (b_offset + b1_len));
-            }
-            if (carry != 0) {
-                if (bfdec_resize(r, r_len + 1)) {
-                    if (b_shift != 0)
-                        bf_free(s, b1_tab);
-                    goto fail;
-                }
-                r->tab[r_len] = 1;
-                r->expn += LIMB_DIGITS;
-            }
-        }
-        if (b_shift != 0)
-            bf_free(s, b1_tab);
-    renorm:
-        ret = bfdec_normalize_and_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bfdec_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-static int __bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-                     bf_flags_t flags)
-{
-    return bfdec_add_internal(r, a, b, prec, flags, 0);
-}
-
-static int __bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-                     bf_flags_t flags)
-{
-    return bfdec_add_internal(r, a, b, prec, flags, 1);
-}
-
-int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags)
-{
-    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
-                  (bf_op2_func_t *)__bfdec_add);
-}
-
-int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags)
-{
-    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
-                  (bf_op2_func_t *)__bfdec_sub);
-}
-
-int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags)
-{
-    int ret, r_sign;
-
-    if (a->len < b->len) {
-        const bfdec_t *tmp = a;
-        a = b;
-        b = tmp;
-    }
-    r_sign = a->sign ^ b->sign;
-    /* here b->len <= a->len */
-    if (b->len == 0) {
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bfdec_set_nan(r);
-            ret = 0;
-        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_INF) {
-            if ((a->expn == BF_EXP_INF && b->expn == BF_EXP_ZERO) ||
-                (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_INF)) {
-                bfdec_set_nan(r);
-                ret = BF_ST_INVALID_OP;
-            } else {
-                bfdec_set_inf(r, r_sign);
-                ret = 0;
-            }
-        } else {
-            bfdec_set_zero(r, r_sign);
-            ret = 0;
-        }
-    } else {
-        bfdec_t tmp, *r1 = NULL;
-        limb_t a_len, b_len;
-        limb_t *a_tab, *b_tab;
-            
-        a_len = a->len;
-        b_len = b->len;
-        a_tab = a->tab;
-        b_tab = b->tab;
-        
-        if (r == a || r == b) {
-            bfdec_init(r->ctx, &tmp);
-            r1 = r;
-            r = &tmp;
-        }
-        if (bfdec_resize(r, a_len + b_len)) {
-            bfdec_set_nan(r);
-            ret = BF_ST_MEM_ERROR;
-            goto done;
-        }
-        mp_mul_basecase_dec(r->tab, a_tab, a_len, b_tab, b_len);
-        r->sign = r_sign;
-        r->expn = a->expn + b->expn;
-        ret = bfdec_normalize_and_round(r, prec, flags);
-    done:
-        if (r == &tmp)
-            bfdec_move(r1, &tmp);
-    }
-    return ret;
-}
-
-int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
-                 bf_flags_t flags)
-{
-    bfdec_t b;
-    int ret;
-    bfdec_init(r->ctx, &b);
-    ret = bfdec_set_si(&b, b1);
-    ret |= bfdec_mul(r, a, &b, prec, flags);
-    bfdec_delete(&b);
-    return ret;
-}
-
-int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
-                 bf_flags_t flags)
-{
-    bfdec_t b;
-    int ret;
-    
-    bfdec_init(r->ctx, &b);
-    ret = bfdec_set_si(&b, b1);
-    ret |= bfdec_add(r, a, &b, prec, flags);
-    bfdec_delete(&b);
-    return ret;
-}
-
-static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
-                       limb_t prec, bf_flags_t flags)
-{
-    int ret, r_sign;
-    limb_t n, nb, precl;
-    
-    r_sign = a->sign ^ b->sign;
-    if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bfdec_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
-            bfdec_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else if (a->expn == BF_EXP_INF) {
-            bfdec_set_inf(r, r_sign);
-            return 0;
-        } else {
-            bfdec_set_zero(r, r_sign);
-            return 0;
-        }
-    } else if (a->expn == BF_EXP_ZERO) {
-        if (b->expn == BF_EXP_ZERO) {
-            bfdec_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bfdec_set_zero(r, r_sign);
-            return 0;
-        }
-    } else if (b->expn == BF_EXP_ZERO) {
-        bfdec_set_inf(r, r_sign);
-        return BF_ST_DIVIDE_ZERO;
-    }
-
-    nb = b->len;
-    if (prec == BF_PREC_INF) {
-        /* infinite precision: return BF_ST_INVALID_OP if not an exact
-           result */
-        /* XXX: check */
-        precl = nb + 1;
-    } else if (flags & BF_FLAG_RADPNT_PREC) {
-        /* number of digits after the decimal point */
-        /* XXX: check (2 extra digits for rounding + 2 digits) */
-        precl = (bf_max(a->expn - b->expn, 0) + 2 +
-                 prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
-    } else {
-        /* number of limbs of the quotient (2 extra digits for rounding) */
-        precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
-    }
-    n = bf_max(a->len, precl);
-    
-    {
-        limb_t *taba, na, i;
-        slimb_t d;
-        
-        na = n + nb;
-        taba = bf_malloc(r->ctx, (na + 1) * sizeof(limb_t));
-        if (!taba)
-            goto fail;
-        d = na - a->len;
-        memset(taba, 0, d * sizeof(limb_t));
-        memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
-        if (bfdec_resize(r, n + 1))
-            goto fail1;
-        if (mp_div_dec(r->ctx, r->tab, taba, na, b->tab, nb)) {
-        fail1:
-            bf_free(r->ctx, taba);
-            goto fail;
-        }
-        /* see if non zero remainder */
-        for(i = 0; i < nb; i++) {
-            if (taba[i] != 0)
-                break;
-        }
-        bf_free(r->ctx, taba);
-        if (i != nb) {
-            if (prec == BF_PREC_INF) {
-                bfdec_set_nan(r);
-                return BF_ST_INVALID_OP;
-            } else {
-                r->tab[0] |= 1;
-            }
-        }
-        r->expn = a->expn - b->expn + LIMB_DIGITS;
-        r->sign = r_sign;
-        ret = bfdec_normalize_and_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bfdec_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags)
-{
-    return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
-                  (bf_op2_func_t *)__bfdec_div);
-}
-
-/* a and b must be finite numbers with a >= 0 and b > 0. 'q' is the
-   integer defined as floor(a/b) and r = a - q * b. */
-static void bfdec_tdivremu(bf_context_t *s, bfdec_t *q, bfdec_t *r,
-                           const bfdec_t *a, const bfdec_t *b)
-{
-    if (bfdec_cmpu(a, b) < 0) {
-        bfdec_set_ui(q, 0);
-        bfdec_set(r, a);
-    } else {
-        bfdec_div(q, a, b, 0, BF_RNDZ | BF_FLAG_RADPNT_PREC);
-        bfdec_mul(r, q, b, BF_PREC_INF, BF_RNDZ);
-        bfdec_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
-    }
-}
-
-/* division and remainder. 
-   
-   rnd_mode is the rounding mode for the quotient. The additional
-   rounding mode BF_RND_EUCLIDIAN is supported.
-
-   'q' is an integer. 'r' is rounded with prec and flags (prec can be
-   BF_PREC_INF).
-*/
-int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
-                 limb_t prec, bf_flags_t flags, int rnd_mode)
-{
-    bf_context_t *s = q->ctx;
-    bfdec_t a1_s, *a1 = &a1_s;
-    bfdec_t b1_s, *b1 = &b1_s;
-    bfdec_t r1_s, *r1 = &r1_s;
-    int q_sign, res;
-    BOOL is_ceil, is_rndn;
-    
-    assert(q != a && q != b);
-    assert(r != a && r != b);
-    assert(q != r);
-    
-    if (a->len == 0 || b->len == 0) {
-        bfdec_set_zero(q, 0);
-        if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
-            bfdec_set_nan(r);
-            return 0;
-        } else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_ZERO) {
-            bfdec_set_nan(r);
-            return BF_ST_INVALID_OP;
-        } else {
-            bfdec_set(r, a);
-            return bfdec_round(r, prec, flags);
-        }
-    }
-
-    q_sign = a->sign ^ b->sign;
-    is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
-    switch(rnd_mode) {
-    default:
-    case BF_RNDZ:
-    case BF_RNDN:
-    case BF_RNDNA:
-        is_ceil = FALSE;
-        break;
-    case BF_RNDD:
-        is_ceil = q_sign;
-        break;
-    case BF_RNDU:
-        is_ceil = q_sign ^ 1;
-        break;
-    case BF_RNDA:
-        is_ceil = TRUE;
-        break;
-    case BF_DIVREM_EUCLIDIAN:
-        is_ceil = a->sign;
-        break;
-    }
-
-    a1->expn = a->expn;
-    a1->tab = a->tab;
-    a1->len = a->len;
-    a1->sign = 0;
-    
-    b1->expn = b->expn;
-    b1->tab = b->tab;
-    b1->len = b->len;
-    b1->sign = 0;
-
-    //    bfdec_print_str("a1", a1);
-    //    bfdec_print_str("b1", b1);
-    /* XXX: could improve to avoid having a large 'q' */
-    bfdec_tdivremu(s, q, r, a1, b1);
-    if (bfdec_is_nan(q) || bfdec_is_nan(r))
-        goto fail;
-    //    bfdec_print_str("q", q);
-    //    bfdec_print_str("r", r);
-    
-    if (r->len != 0) {
-        if (is_rndn) {
-            bfdec_init(s, r1);
-            if (bfdec_set(r1, r))
-                goto fail;
-            if (bfdec_mul_si(r1, r1, 2, BF_PREC_INF, BF_RNDZ)) {
-                bfdec_delete(r1);
-                goto fail;
-            }
-            res = bfdec_cmpu(r1, b);
-            bfdec_delete(r1);
-            if (res > 0 ||
-                (res == 0 &&
-                 (rnd_mode == BF_RNDNA ||
-                  (get_digit(q->tab, q->len, q->len * LIMB_DIGITS - q->expn) & 1) != 0))) {
-                goto do_sub_r;
-            }
-        } else if (is_ceil) {
-        do_sub_r:
-            res = bfdec_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
-            res |= bfdec_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
-            if (res & BF_ST_MEM_ERROR)
-                goto fail;
-        }
-    }
-
-    r->sign ^= a->sign;
-    q->sign = q_sign;
-    return bfdec_round(r, prec, flags);
- fail:
-    bfdec_set_nan(q);
-    bfdec_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags, int rnd_mode)
-{
-    bfdec_t q_s, *q = &q_s;
-    int ret;
-    
-    bfdec_init(r->ctx, q);
-    ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
-    bfdec_delete(q);
-    return ret;
-}
-
-/* convert to integer (infinite precision) */
-int bfdec_rint(bfdec_t *r, int rnd_mode)
-{
-    return bfdec_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
-}
-
-int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags)
-{
-    bf_context_t *s = a->ctx;
-    int ret, k;
-    limb_t *a1, v;
-    slimb_t n, n1, prec1;
-    limb_t res;
-
-    assert(r != a);
-
-    if (a->len == 0) {
-        if (a->expn == BF_EXP_NAN) {
-            bfdec_set_nan(r);
-        } else if (a->expn == BF_EXP_INF && a->sign) {
-            goto invalid_op;
-        } else {
-            bfdec_set(r, a);
-        }
-        ret = 0;
-    } else if (a->sign || prec == BF_PREC_INF) {
- invalid_op:
-        bfdec_set_nan(r);
-        ret = BF_ST_INVALID_OP;
-    } else {
-        if (flags & BF_FLAG_RADPNT_PREC) {
-            prec1 = bf_max(floor_div(a->expn + 1, 2) + prec, 1);
-        } else {
-            prec1 = prec;
-        }
-        /* convert the mantissa to an integer with at least 2 *
-           prec + 4 digits */
-        n = (2 * (prec1 + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
-        if (bfdec_resize(r, n))
-            goto fail;
-        a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
-        if (!a1)
-            goto fail;
-        n1 = bf_min(2 * n, a->len);
-        memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
-        memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
-        if (a->expn & 1) {
-            res = mp_shr_dec(a1, a1, 2 * n, 1, 0);
-        } else {
-            res = 0;
-        }
-        /* normalize so that a1 >= B^(2*n)/4. Not need for n = 1
-           because mp_sqrtrem2_dec already does it */
-        k = 0;
-        if (n > 1) {
-            v = a1[2 * n - 1];
-            while (v < BF_DEC_BASE / 4) {
-                k++;
-                v *= 4;
-            }
-            if (k != 0)
-                mp_mul1_dec(a1, a1, 2 * n, 1 << (2 * k), 0);
-        }
-        if (mp_sqrtrem_dec(s, r->tab, a1, n)) {
-            bf_free(s, a1);
-            goto fail;
-        }
-        if (k != 0)
-            mp_div1_dec(r->tab, r->tab, n, 1 << k, 0);
-        if (!res) {
-            res = mp_scan_nz(a1, n + 1);
-        }
-        bf_free(s, a1);
-        if (!res) {
-            res = mp_scan_nz(a->tab, a->len - n1);
-        }
-        if (res != 0)
-            r->tab[0] |= 1;
-        r->sign = 0;
-        r->expn = (a->expn + 1) >> 1;
-        ret = bfdec_round(r, prec, flags);
-    }
-    return ret;
- fail:
-    bfdec_set_nan(r);
-    return BF_ST_MEM_ERROR;
-}
-
-/* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
-   is an overflow and 0 otherwise. No memory error is possible. */
-int bfdec_get_int32(int *pres, const bfdec_t *a)
-{
-    uint32_t v;
-    int ret;
-    if (a->expn >= BF_EXP_INF) {
-        ret = 0;
-        if (a->expn == BF_EXP_INF) {
-            v = (uint32_t)INT32_MAX + a->sign;
-             /* XXX: return overflow ? */
-        } else {
-            v = INT32_MAX;
-        }
-    } else if (a->expn <= 0) {
-        v = 0;
-        ret = 0;
-    } else if (a->expn <= 9) {
-        v = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
-        if (a->sign)
-            v = -v;
-        ret = 0;
-    } else if (a->expn == 10) {
-        uint64_t v1;
-        uint32_t v_max;
-#if LIMB_BITS == 64
-        v1 = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
-#else
-        v1 = (uint64_t)a->tab[a->len - 1] * 10 +
-            get_digit(a->tab, a->len, (a->len - 1) * LIMB_DIGITS - 1);
-#endif
-        v_max = (uint32_t)INT32_MAX + a->sign;
-        if (v1 > v_max) {
-            v = v_max;
-            ret = BF_ST_OVERFLOW;
-        } else {
-            v = v1;
-            if (a->sign)
-                v = -v;
-            ret = 0;
-        }
-    } else {
-        v = (uint32_t)INT32_MAX + a->sign;
-        ret = BF_ST_OVERFLOW;
-    }
-    *pres = v;
-    return ret;
-}
-
-/* power to an integer with infinite precision */
-int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b)
-{
-    int ret, n_bits, i;
-    
-    assert(r != a);
-    if (b == 0)
-        return bfdec_set_ui(r, 1);
-    ret = bfdec_set(r, a);
-    n_bits = LIMB_BITS - clz(b);
-    for(i = n_bits - 2; i >= 0; i--) {
-        ret |= bfdec_mul(r, r, r, BF_PREC_INF, BF_RNDZ);
-        if ((b >> i) & 1)
-            ret |= bfdec_mul(r, r, a, BF_PREC_INF, BF_RNDZ);
-    }
-    return ret;
-}
-
-char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags)
-{
-    return bf_ftoa_internal(plen, (const bf_t *)a, 10, prec, flags, TRUE);
-}
-
-int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
-               limb_t prec, bf_flags_t flags)
-{
-    slimb_t dummy_exp;
-    return bf_atof_internal((bf_t *)r, &dummy_exp, str, pnext, 10, prec,
-                            flags, TRUE);
-}
-
-#endif /* USE_BF_DEC */
-
-#ifdef USE_FFT_MUL
-/***************************************************************/
-/* Integer multiplication with FFT */
-
-/* or LIMB_BITS at bit position 'pos' in tab */
-static inline void put_bits(limb_t *tab, limb_t len, slimb_t pos, limb_t val)
-{
-    limb_t i;
-    int p;
-
-    i = pos >> LIMB_LOG2_BITS;
-    p = pos & (LIMB_BITS - 1);
-    if (i < len)
-        tab[i] |= val << p;
-    if (p != 0) {
-        i++;
-        if (i < len) {
-            tab[i] |= val >> (LIMB_BITS - p);
-        }
-    }
-}
-
-#if defined(__AVX2__)
-
-typedef double NTTLimb;
-
-/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
-#define NTT_MOD_LOG2_MIN 50
-#define NTT_MOD_LOG2_MAX 51
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 39
-static const int ntt_int_bits[NB_MODS] = { 254, 203, 152, 101, 50, };
-
-static const limb_t ntt_mods[NB_MODS] = { 0x00073a8000000001, 0x0007858000000001, 0x0007a38000000001, 0x0007a68000000001, 0x0007fd8000000001,
-};
-
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x00056198d44332c8, 0x0002eb5d640aad39, 0x00047e31eaa35fd0, 0x0005271ac118a150, 0x00075e0ce8442bd5, },
-    { 0x000461169761bcc5, 0x0002dac3cb2da688, 0x0004abc97751e3bf, 0x000656778fc8c485, 0x0000dc6469c269fa, },
-};
-
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x00020e4da740da8e, 0x0004c3dc09c09c1d, 0x000063bd097b4271, 0x000799d8f18f18fd,
- 0x0005384222222264, 0x000572b07c1f07fe, 0x00035cd08888889a,
- 0x00066015555557e3, 0x000725960b60b623,
- 0x0002fc1fa1d6ce12,
-};
-
-#else
-
-typedef limb_t NTTLimb;
-
-#if LIMB_BITS == 64
-
-#define NTT_MOD_LOG2_MIN 61
-#define NTT_MOD_LOG2_MAX 62
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 51
-static const int ntt_int_bits[NB_MODS] = { 307, 246, 185, 123, 61, };
-
-static const limb_t ntt_mods[NB_MODS] = { 0x28d8000000000001, 0x2a88000000000001, 0x2ed8000000000001, 0x3508000000000001, 0x3aa8000000000001,
-};
-
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x1b8ea61034a2bea7, 0x21a9762de58206fb, 0x02ca782f0756a8ea, 0x278384537a3e50a1, 0x106e13fee74ce0ab, },
-    { 0x233513af133e13b8, 0x1d13140d1c6f75f1, 0x12cde57f97e3eeda, 0x0d6149e23cbe654f, 0x36cd204f522a1379, },
-};
-
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x08a9ed097b425eea, 0x18a44aaaaaaaaab3, 0x2493f57f57f57f5d, 0x126b8d0649a7f8d4,
- 0x09d80ed7303b5ccc, 0x25b8bcf3cf3cf3d5, 0x2ce6ce63398ce638,
- 0x0e31fad40a57eb59, 0x02a3529fd4a7f52f,
- 0x3a5493e93e93e94a,
-};
-
-#elif LIMB_BITS == 32
-
-/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
-#define NTT_MOD_LOG2_MIN 29
-#define NTT_MOD_LOG2_MAX 30
-#define NB_MODS 5
-#define NTT_PROOT_2EXP 20
-static const int ntt_int_bits[NB_MODS] = { 148, 119, 89, 59, 29, };
-
-static const limb_t ntt_mods[NB_MODS] = { 0x0000000032b00001, 0x0000000033700001, 0x0000000036d00001, 0x0000000037300001, 0x000000003e500001,
-};
-
-static const limb_t ntt_proot[2][NB_MODS] = {
-    { 0x0000000032525f31, 0x0000000005eb3b37, 0x00000000246eda9f, 0x0000000035f25901, 0x00000000022f5768, },
-    { 0x00000000051eba1a, 0x00000000107be10e, 0x000000001cd574e0, 0x00000000053806e6, 0x000000002cd6bf98, },
-};
-
-static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
- 0x000000000449559a, 0x000000001eba6ca9, 0x000000002ec18e46, 0x000000000860160b,
- 0x000000000d321307, 0x000000000bf51120, 0x000000000f662938,
- 0x000000000932ab3e, 0x000000002f40eef8,
- 0x000000002e760905,
-};
-
-#endif /* LIMB_BITS */
-
-#endif /* !AVX2 */
-
-#if defined(__AVX2__)
-#define NTT_TRIG_K_MAX 18
-#else
-#define NTT_TRIG_K_MAX 19
-#endif
-
-typedef struct BFNTTState {
-    bf_context_t *ctx;
-    
-    /* used for mul_mod_fast() */
-    limb_t ntt_mods_div[NB_MODS];
-
-    limb_t ntt_proot_pow[NB_MODS][2][NTT_PROOT_2EXP + 1];
-    limb_t ntt_proot_pow_inv[NB_MODS][2][NTT_PROOT_2EXP + 1];
-    NTTLimb *ntt_trig[NB_MODS][2][NTT_TRIG_K_MAX + 1];
-    /* 1/2^n mod m */
-    limb_t ntt_len_inv[NB_MODS][NTT_PROOT_2EXP + 1][2];
-#if defined(__AVX2__)
-    __m256d ntt_mods_cr_vec[NB_MODS * (NB_MODS - 1) / 2];
-    __m256d ntt_mods_vec[NB_MODS];
-    __m256d ntt_mods_inv_vec[NB_MODS];
-#else
-    limb_t ntt_mods_cr_inv[NB_MODS * (NB_MODS - 1) / 2];
-#endif
-} BFNTTState;
-
-static NTTLimb *get_trig(BFNTTState *s, int k, int inverse, int m_idx);
-
-/* add modulo with up to (LIMB_BITS-1) bit modulo */
-static inline limb_t add_mod(limb_t a, limb_t b, limb_t m)
-{
-    limb_t r;
-    r = a + b;
-    if (r >= m)
-        r -= m;
-    return r;
-}
-
-/* sub modulo with up to LIMB_BITS bit modulo */
-static inline limb_t sub_mod(limb_t a, limb_t b, limb_t m)
-{
-    limb_t r;
-    r = a - b;
-    if (r > a)
-        r += m;
-    return r;
-}
-
-/* return (r0+r1*B) mod m 
-   precondition: 0 <= r0+r1*B < 2^(64+NTT_MOD_LOG2_MIN) 
-*/
-static inline limb_t mod_fast(dlimb_t r, 
-                                limb_t m, limb_t m_inv)
-{
-    limb_t a1, q, t0, r1, r0;
-    
-    a1 = r >> NTT_MOD_LOG2_MIN;
-    
-    q = ((dlimb_t)a1 * m_inv) >> LIMB_BITS;
-    r = r - (dlimb_t)q * m - m * 2;
-    r1 = r >> LIMB_BITS;
-    t0 = (slimb_t)r1 >> 1;
-    r += m & t0;
-    r0 = r;
-    r1 = r >> LIMB_BITS;
-    r0 += m & r1;
-    return r0;
-}
-
-/* faster version using precomputed modulo inverse. 
-   precondition: 0 <= a * b < 2^(64+NTT_MOD_LOG2_MIN) */
-static inline limb_t mul_mod_fast(limb_t a, limb_t b, 
-                                    limb_t m, limb_t m_inv)
-{
-    dlimb_t r;
-    r = (dlimb_t)a * (dlimb_t)b;
-    return mod_fast(r, m, m_inv);
-}
-
-static inline limb_t init_mul_mod_fast(limb_t m)
-{
-    dlimb_t t;
-    assert(m < (limb_t)1 << NTT_MOD_LOG2_MAX);
-    assert(m >= (limb_t)1 << NTT_MOD_LOG2_MIN);
-    t = (dlimb_t)1 << (LIMB_BITS + NTT_MOD_LOG2_MIN);
-    return t / m;
-}
-
-/* Faster version used when the multiplier is constant. 0 <= a < 2^64,
-   0 <= b < m. */
-static inline limb_t mul_mod_fast2(limb_t a, limb_t b, 
-                                     limb_t m, limb_t b_inv)
-{
-    limb_t r, q;
-
-    q = ((dlimb_t)a * (dlimb_t)b_inv) >> LIMB_BITS;
-    r = a * b - q * m;
-    if (r >= m)
-        r -= m;
-    return r;
-}
-
-/* Faster version used when the multiplier is constant. 0 <= a < 2^64,
-   0 <= b < m. Let r = a * b mod m. The return value is 'r' or 'r +
-   m'. */
-static inline limb_t mul_mod_fast3(limb_t a, limb_t b, 
-                                     limb_t m, limb_t b_inv)
-{
-    limb_t r, q;
-
-    q = ((dlimb_t)a * (dlimb_t)b_inv) >> LIMB_BITS;
-    r = a * b - q * m;
-    return r;
-}
-
-static inline limb_t init_mul_mod_fast2(limb_t b, limb_t m)
-{
-    return ((dlimb_t)b << LIMB_BITS) / m;
-}
-
-#ifdef __AVX2__
-
-static inline limb_t ntt_limb_to_int(NTTLimb a, limb_t m)
-{
-    slimb_t v;
-    v = a;
-    if (v < 0)
-        v += m;
-    if (v >= m)
-        v -= m;
-    return v;
-}
-
-static inline NTTLimb int_to_ntt_limb(limb_t a, limb_t m)
-{
-    return (slimb_t)a;
-}
-
-static inline NTTLimb int_to_ntt_limb2(limb_t a, limb_t m)
-{
-    if (a >= (m / 2))
-        a -= m;
-    return (slimb_t)a;
-}
-
-/* return r + m if r < 0 otherwise r. */
-static inline __m256d ntt_mod1(__m256d r, __m256d m)
-{
-    return _mm256_blendv_pd(r, r + m, r);
-}
-
-/* input: abs(r) < 2 * m. Output: abs(r) < m */
-static inline __m256d ntt_mod(__m256d r, __m256d mf, __m256d m2f)
-{
-    return _mm256_blendv_pd(r, r + m2f, r) - mf;
-}
-
-/* input: abs(a*b) < 2 * m^2, output: abs(r) < m */
-static inline __m256d ntt_mul_mod(__m256d a, __m256d b, __m256d mf,
-                                  __m256d m_inv)
-{
-    __m256d r, q, ab1, ab0, qm0, qm1;
-    ab1 = a * b;
-    q = _mm256_round_pd(ab1 * m_inv, 0); /* round to nearest */
-    qm1 = q * mf;
-    qm0 = _mm256_fmsub_pd(q, mf, qm1); /* low part */
-    ab0 = _mm256_fmsub_pd(a, b, ab1); /* low part */
-    r = (ab1 - qm1) + (ab0 - qm0);
-    return r;
-}
-
-static void *bf_aligned_malloc(bf_context_t *s, size_t size, size_t align)
-{
-    void *ptr;
-    void **ptr1;
-    ptr = bf_malloc(s, size + sizeof(void *) + align - 1);
-    if (!ptr)
-        return NULL;
-    ptr1 = (void **)(((uintptr_t)ptr + sizeof(void *) + align - 1) &
-                     ~(align - 1));
-    ptr1[-1] = ptr;
-    return ptr1;
-}
-
-static void bf_aligned_free(bf_context_t *s, void *ptr)
-{
-    if (!ptr)
-        return;
-    bf_free(s, ((void **)ptr)[-1]);
-}
-
-static void *ntt_malloc(BFNTTState *s, size_t size)
-{
-    return bf_aligned_malloc(s->ctx, size, 64);
-}
-
-static void ntt_free(BFNTTState *s, void *ptr)
-{
-    bf_aligned_free(s->ctx, ptr);
-}
-
-static no_inline int ntt_fft(BFNTTState *s,
-                             NTTLimb *out_buf, NTTLimb *in_buf,
-                             NTTLimb *tmp_buf, int fft_len_log2,
-                             int inverse, int m_idx)
-{
-    limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j;
-    NTTLimb *tab_in, *tab_out, *tmp, *trig;
-    __m256d m_inv, mf, m2f, c, a0, a1, b0, b1;
-    limb_t m;
-    int l;
-    
-    m = ntt_mods[m_idx];
-    
-    m_inv = _mm256_set1_pd(1.0 / (double)m);
-    mf = _mm256_set1_pd(m);
-    m2f = _mm256_set1_pd(m * 2);
-
-    n = (limb_t)1 << fft_len_log2;
-    assert(n >= 8);
-    stride_in = n / 2;
-
-    tab_in = in_buf;
-    tab_out = tmp_buf;
-    trig = get_trig(s, fft_len_log2, inverse, m_idx);
-    if (!trig)
-        return -1;
-    p = 0;
-    for(k = 0; k < stride_in; k += 4) {
-        a0 = _mm256_load_pd(&tab_in[k]);
-        a1 = _mm256_load_pd(&tab_in[k + stride_in]);
-        c = _mm256_load_pd(trig);
-        trig += 4;
-        b0 = ntt_mod(a0 + a1, mf, m2f);
-        b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
-        a0 = _mm256_permute2f128_pd(b0, b1, 0x20);
-        a1 = _mm256_permute2f128_pd(b0, b1, 0x31);
-        a0 = _mm256_permute4x64_pd(a0, 0xd8);
-        a1 = _mm256_permute4x64_pd(a1, 0xd8);
-        _mm256_store_pd(&tab_out[p], a0);
-        _mm256_store_pd(&tab_out[p + 4], a1);
-        p += 2 * 4;
-    }
-    tmp = tab_in;
-    tab_in = tab_out;
-    tab_out = tmp;
-
-    trig = get_trig(s, fft_len_log2 - 1, inverse, m_idx);
-    if (!trig)
-        return -1;
-    p = 0;
-    for(k = 0; k < stride_in; k += 4) {
-        a0 = _mm256_load_pd(&tab_in[k]);
-        a1 = _mm256_load_pd(&tab_in[k + stride_in]);
-        c = _mm256_setr_pd(trig[0], trig[0], trig[1], trig[1]);
-        trig += 2;
-        b0 = ntt_mod(a0 + a1, mf, m2f);
-        b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
-        a0 = _mm256_permute2f128_pd(b0, b1, 0x20);
-        a1 = _mm256_permute2f128_pd(b0, b1, 0x31);
-        _mm256_store_pd(&tab_out[p], a0);
-        _mm256_store_pd(&tab_out[p + 4], a1);
-        p += 2 * 4;
-    }
-    tmp = tab_in;
-    tab_in = tab_out;
-    tab_out = tmp;
-    
-    nb_blocks = n / 4;
-    fft_per_block = 4;
-
-    l = fft_len_log2 - 2;
-    while (nb_blocks != 2) {
-        nb_blocks >>= 1;
-        p = 0;
-        k = 0;
-        trig = get_trig(s, l, inverse, m_idx);
-        if (!trig)
-            return -1;
-        for(i = 0; i < nb_blocks; i++) {
-            c = _mm256_set1_pd(trig[0]);
-            trig++;
-            for(j = 0; j < fft_per_block; j += 4) {
-                a0 = _mm256_load_pd(&tab_in[k + j]);
-                a1 = _mm256_load_pd(&tab_in[k + j + stride_in]);
-                b0 = ntt_mod(a0 + a1, mf, m2f);
-                b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
-                _mm256_store_pd(&tab_out[p + j], b0);
-                _mm256_store_pd(&tab_out[p + j + fft_per_block], b1);
-            }
-            k += fft_per_block;
-            p += 2 * fft_per_block;
-        }
-        fft_per_block <<= 1;
-        l--;
-        tmp = tab_in;
-        tab_in = tab_out;
-        tab_out = tmp;
-    }
-
-    tab_out = out_buf;
-    for(k = 0; k < stride_in; k += 4) {
-        a0 = _mm256_load_pd(&tab_in[k]);
-        a1 = _mm256_load_pd(&tab_in[k + stride_in]);
-        b0 = ntt_mod(a0 + a1, mf, m2f);
-        b1 = ntt_mod(a0 - a1, mf, m2f);
-        _mm256_store_pd(&tab_out[k], b0);
-        _mm256_store_pd(&tab_out[k + stride_in], b1);
-    }
-    return 0;
-}
-
-static void ntt_vec_mul(BFNTTState *s,
-                        NTTLimb *tab1, NTTLimb *tab2, limb_t fft_len_log2,
-                        int k_tot, int m_idx)
-{
-    limb_t i, c_inv, n, m;
-    __m256d m_inv, mf, a, b, c;
-    
-    m = ntt_mods[m_idx];
-    c_inv = s->ntt_len_inv[m_idx][k_tot][0];
-    m_inv = _mm256_set1_pd(1.0 / (double)m);
-    mf = _mm256_set1_pd(m);
-    c = _mm256_set1_pd(int_to_ntt_limb(c_inv, m));
-    n = (limb_t)1 << fft_len_log2;
-    for(i = 0; i < n; i += 4) {
-        a = _mm256_load_pd(&tab1[i]);
-        b = _mm256_load_pd(&tab2[i]);
-        a = ntt_mul_mod(a, b, mf, m_inv);
-        a = ntt_mul_mod(a, c, mf, m_inv);
-        _mm256_store_pd(&tab1[i], a);
-    }
-}
-
-static no_inline void mul_trig(NTTLimb *buf,
-                               limb_t n, limb_t c1, limb_t m, limb_t m_inv1)
-{
-    limb_t i, c2, c3, c4;
-    __m256d c, c_mul, a0, mf, m_inv;
-    assert(n >= 2);
-    
-    mf = _mm256_set1_pd(m);
-    m_inv = _mm256_set1_pd(1.0 / (double)m);
-
-    c2 = mul_mod_fast(c1, c1, m, m_inv1);
-    c3 = mul_mod_fast(c2, c1, m, m_inv1);
-    c4 = mul_mod_fast(c2, c2, m, m_inv1);
-    c = _mm256_setr_pd(1, int_to_ntt_limb(c1, m),
-                       int_to_ntt_limb(c2, m), int_to_ntt_limb(c3, m));
-    c_mul = _mm256_set1_pd(int_to_ntt_limb(c4, m));
-    for(i = 0; i < n; i += 4) {
-        a0 = _mm256_load_pd(&buf[i]);
-        a0 = ntt_mul_mod(a0, c, mf, m_inv);
-        _mm256_store_pd(&buf[i], a0);
-        c = ntt_mul_mod(c, c_mul, mf, m_inv);
-    }
-}
-
-#else
-
-static void *ntt_malloc(BFNTTState *s, size_t size)
-{
-    return bf_malloc(s->ctx, size);
-}
-
-static void ntt_free(BFNTTState *s, void *ptr)
-{
-    bf_free(s->ctx, ptr);
-}
-
-static inline limb_t ntt_limb_to_int(NTTLimb a, limb_t m)
-{
-    if (a >= m)
-        a -= m;
-    return a;
-}
-
-static inline NTTLimb int_to_ntt_limb(slimb_t a, limb_t m)
-{
-    return a;
-}
-
-static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
-                             NTTLimb *tmp_buf, int fft_len_log2,
-                             int inverse, int m_idx)
-{
-    limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j, m, m2;
-    NTTLimb *tab_in, *tab_out, *tmp, a0, a1, b0, b1, c, *trig, c_inv;
-    int l;
-    
-    m = ntt_mods[m_idx];
-    m2 = 2 * m;
-    n = (limb_t)1 << fft_len_log2;
-    nb_blocks = n;
-    fft_per_block = 1;
-    stride_in = n / 2;
-    tab_in = in_buf;
-    tab_out = tmp_buf;
-    l = fft_len_log2;
-    while (nb_blocks != 2) {
-        nb_blocks >>= 1;
-        p = 0;
-        k = 0;
-        trig = get_trig(s, l, inverse, m_idx);
-        if (!trig)
-            return -1;
-        for(i = 0; i < nb_blocks; i++) {
-            c = trig[0];
-            c_inv = trig[1];
-            trig += 2;
-            for(j = 0; j < fft_per_block; j++) {
-                a0 = tab_in[k + j];
-                a1 = tab_in[k + j + stride_in];
-                b0 = add_mod(a0, a1, m2);
-                b1 = a0 - a1 + m2;
-                b1 = mul_mod_fast3(b1, c, m, c_inv);
-                tab_out[p + j] = b0;
-                tab_out[p + j + fft_per_block] = b1;
-            }
-            k += fft_per_block;
-            p += 2 * fft_per_block;
-        }
-        fft_per_block <<= 1;
-        l--;
-        tmp = tab_in;
-        tab_in = tab_out;
-        tab_out = tmp;
-    }
-    /* no twiddle in last step */
-    tab_out = out_buf; 
-    for(k = 0; k < stride_in; k++) {
-        a0 = tab_in[k];
-        a1 = tab_in[k + stride_in];
-        b0 = add_mod(a0, a1, m2);
-        b1 = sub_mod(a0, a1, m2);
-        tab_out[k] = b0;
-        tab_out[k + stride_in] = b1;
-    }
-    return 0;
-}
-
-static void ntt_vec_mul(BFNTTState *s,
-                        NTTLimb *tab1, NTTLimb *tab2, int fft_len_log2,
-                        int k_tot, int m_idx)
-{
-    limb_t i, norm, norm_inv, a, n, m, m_inv;
-    
-    m = ntt_mods[m_idx];
-    m_inv = s->ntt_mods_div[m_idx];
-    norm = s->ntt_len_inv[m_idx][k_tot][0];
-    norm_inv = s->ntt_len_inv[m_idx][k_tot][1];
-    n = (limb_t)1 << fft_len_log2;
-    for(i = 0; i < n; i++) {
-        a = tab1[i];
-        /* need to reduce the range so that the product is <
-           2^(LIMB_BITS+NTT_MOD_LOG2_MIN) */
-        if (a >= m)
-            a -= m;
-        a = mul_mod_fast(a, tab2[i], m, m_inv);
-        a = mul_mod_fast3(a, norm, m, norm_inv);
-        tab1[i] = a;
-    }
-}
-
-static no_inline void mul_trig(NTTLimb *buf,
-                               limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
-{
-    limb_t i, c0, c_mul_inv;
-    
-    c0 = 1;
-    c_mul_inv = init_mul_mod_fast2(c_mul, m);
-    for(i = 0; i < n; i++) {
-        buf[i] = mul_mod_fast(buf[i], c0, m, m_inv);
-        c0 = mul_mod_fast2(c0, c_mul, m, c_mul_inv);
-    }
-}
-
-#endif /* !AVX2 */
-
-static no_inline NTTLimb *get_trig(BFNTTState *s,
-                                   int k, int inverse, int m_idx)
-{
-    NTTLimb *tab;
-    limb_t i, n2, c, c_mul, m, c_mul_inv;
-    
-    if (k > NTT_TRIG_K_MAX)
-        return NULL;
-
-    tab = s->ntt_trig[m_idx][inverse][k];
-    if (tab)
-        return tab;
-    n2 = (limb_t)1 << (k - 1);
-    m = ntt_mods[m_idx];
-#ifdef __AVX2__
-    tab = ntt_malloc(s, sizeof(NTTLimb) * n2);
-#else
-    tab = ntt_malloc(s, sizeof(NTTLimb) * n2 * 2);
-#endif
-    if (!tab)
-        return NULL;
-    c = 1;
-    c_mul = s->ntt_proot_pow[m_idx][inverse][k];
-    c_mul_inv = s->ntt_proot_pow_inv[m_idx][inverse][k];
-    for(i = 0; i < n2; i++) {
-#ifdef __AVX2__
-        tab[i] = int_to_ntt_limb2(c, m);
-#else
-        tab[2 * i] = int_to_ntt_limb(c, m);
-        tab[2 * i + 1] = init_mul_mod_fast2(c, m);
-#endif
-        c = mul_mod_fast2(c, c_mul, m, c_mul_inv);
-    }
-    s->ntt_trig[m_idx][inverse][k] = tab;
-    return tab;
-}
-
-void fft_clear_cache(bf_context_t *s1)
-{
-    int m_idx, inverse, k;
-    BFNTTState *s = s1->ntt_state;
-    if (s) {
-        for(m_idx = 0; m_idx < NB_MODS; m_idx++) {
-            for(inverse = 0; inverse < 2; inverse++) {
-                for(k = 0; k < NTT_TRIG_K_MAX + 1; k++) {
-                    if (s->ntt_trig[m_idx][inverse][k]) {
-                        ntt_free(s, s->ntt_trig[m_idx][inverse][k]);
-                        s->ntt_trig[m_idx][inverse][k] = NULL;
-                    }
-                }
-            }
-        }
-#if defined(__AVX2__)
-        bf_aligned_free(s1, s);
-#else
-        bf_free(s1, s);
-#endif
-        s1->ntt_state = NULL;
-    }
-}
-
-#define STRIP_LEN 16
-
-/* dst = buf1, src = buf2 */
-static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
-                           int k1, int k2, limb_t n1, limb_t n2, int inverse,
-                           limb_t m_idx)
-{
-    limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
-    NTTLimb *buf2, *buf3;
-    
-    buf2 = NULL;
-    buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
-    if (!buf3)
-        goto fail;
-    if (k2 == 0) {
-        if (ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx))
-            goto fail;
-    } else {
-        strip_len = STRIP_LEN;
-        buf2 = ntt_malloc(s, sizeof(NTTLimb) * n1 * strip_len);
-        if (!buf2)
-            goto fail;
-        m = ntt_mods[m_idx];
-        m_inv = s->ntt_mods_div[m_idx];
-        c0 = s->ntt_proot_pow[m_idx][inverse][k1 + k2];
-        c_mul = 1;
-        assert((n2 % strip_len) == 0);
-        for(j = 0; j < n2; j += strip_len) {
-            for(i = 0; i < n1; i++) {
-                for(l = 0; l < strip_len; l++) {
-                    buf2[i + l * n1] = buf1[i * n2 + (j + l)];
-                }
-            }
-            for(l = 0; l < strip_len; l++) {
-                if (inverse)
-                    mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
-                if (ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx))
-                    goto fail;
-                if (!inverse)
-                    mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
-                c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
-            }
-            
-            for(i = 0; i < n1; i++) {
-                for(l = 0; l < strip_len; l++) {
-                    buf1[i * n2 + (j + l)] = buf2[i + l *n1];
-                }
-            }
-        }
-        ntt_free(s, buf2);
-    }
-    ntt_free(s, buf3);
-    return 0;
- fail:
-    ntt_free(s, buf2);
-    ntt_free(s, buf3);
-    return -1;
-}
-
-
-/* dst = buf1, src = buf2, tmp = buf3 */
-static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
-                    int k, int k_tot, limb_t m_idx)
-{
-    limb_t n1, n2, i;
-    int k1, k2;
-    
-    if (k <= NTT_TRIG_K_MAX) {
-        k1 = k;
-    } else {
-        /* recursive split of the FFT */
-        k1 = bf_min(k / 2, NTT_TRIG_K_MAX);
-    }
-    k2 = k - k1;
-    n1 = (limb_t)1 << k1;
-    n2 = (limb_t)1 << k2;
-    
-    if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
-        return -1;
-    if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
-        return -1;
-    if (k2 == 0) {
-        ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
-    } else {
-        for(i = 0; i < n1; i++) {
-            ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
-        }
-    }
-    if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
-        return -1;
-    return 0;
-}
-
-
-static no_inline void limb_to_ntt(BFNTTState *s,
-                                  NTTLimb *tabr, limb_t fft_len,
-                                  const limb_t *taba, limb_t a_len, int dpl,
-                                  int first_m_idx, int nb_mods)
-{
-    slimb_t i, n;
-    dlimb_t a, b;
-    int j, shift;
-    limb_t base_mask1, a0, a1, a2, r, m, m_inv;
-    
-#if 0
-    for(i = 0; i < a_len; i++) {
-        printf("%" PRId64 ": " FMT_LIMB "\n",
-               (int64_t)i, taba[i]);
-    }
-#endif   
-    memset(tabr, 0, sizeof(NTTLimb) * fft_len * nb_mods);
-    shift = dpl & (LIMB_BITS - 1);
-    if (shift == 0)
-        base_mask1 = -1;
-    else
-        base_mask1 = ((limb_t)1 << shift) - 1;
-    n = bf_min(fft_len, (a_len * LIMB_BITS + dpl - 1) / dpl);
-    for(i = 0; i < n; i++) {
-        a0 = get_bits(taba, a_len, i * dpl);
-        if (dpl <= LIMB_BITS) {
-            a0 &= base_mask1;
-            a = a0;
-        } else {
-            a1 = get_bits(taba, a_len, i * dpl + LIMB_BITS);
-            if (dpl <= (LIMB_BITS + NTT_MOD_LOG2_MIN)) {
-                a = a0 | ((dlimb_t)(a1 & base_mask1) << LIMB_BITS);
-            } else {
-                if (dpl > 2 * LIMB_BITS) {
-                    a2 = get_bits(taba, a_len, i * dpl + LIMB_BITS * 2) &
-                        base_mask1;
-                } else {
-                    a1 &= base_mask1;
-                    a2 = 0;
-                }
-                //            printf("a=0x%016lx%016lx%016lx\n", a2, a1, a0);
-                a = (a0 >> (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) |
-                    ((dlimb_t)a1 << (NTT_MOD_LOG2_MAX - NTT_MOD_LOG2_MIN)) |
-                    ((dlimb_t)a2 << (LIMB_BITS + NTT_MOD_LOG2_MAX - NTT_MOD_LOG2_MIN));
-                a0 &= ((limb_t)1 << (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) - 1;
-            }
-        }
-        for(j = 0; j < nb_mods; j++) {
-            m = ntt_mods[first_m_idx + j];
-            m_inv = s->ntt_mods_div[first_m_idx + j];
-            r = mod_fast(a, m, m_inv);
-            if (dpl > (LIMB_BITS + NTT_MOD_LOG2_MIN)) {
-                b = ((dlimb_t)r << (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) | a0;
-                r = mod_fast(b, m, m_inv);
-            }
-            tabr[i + j * fft_len] = int_to_ntt_limb(r, m);
-        }
-    }
-}
-
-#if defined(__AVX2__)
-
-#define VEC_LEN 4
-
-typedef union {
-    __m256d v;
-    double d[4];
-} VecUnion;
-
-static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
-                                  const NTTLimb *buf, int fft_len_log2, int dpl,
-                                  int nb_mods)
-{
-    const limb_t *mods = ntt_mods + NB_MODS - nb_mods;
-    const __m256d *mods_cr_vec, *mf, *m_inv;
-    VecUnion y[NB_MODS];
-    limb_t u[NB_MODS], carry[NB_MODS], fft_len, base_mask1, r;
-    slimb_t i, len, pos;
-    int j, k, l, shift, n_limb1, p;
-    dlimb_t t;
-        
-    j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
-    mods_cr_vec = s->ntt_mods_cr_vec + j;
-    mf = s->ntt_mods_vec + NB_MODS - nb_mods;
-    m_inv = s->ntt_mods_inv_vec + NB_MODS - nb_mods;
-        
-    shift = dpl & (LIMB_BITS - 1);
-    if (shift == 0)
-        base_mask1 = -1;
-    else
-        base_mask1 = ((limb_t)1 << shift) - 1;
-    n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
-    for(j = 0; j < NB_MODS; j++) 
-        carry[j] = 0;
-    for(j = 0; j < NB_MODS; j++) 
-        u[j] = 0; /* avoid warnings */
-    memset(tabr, 0, sizeof(limb_t) * r_len);
-    fft_len = (limb_t)1 << fft_len_log2;
-    len = bf_min(fft_len, (r_len * LIMB_BITS + dpl - 1) / dpl);
-    len = (len + VEC_LEN - 1) & ~(VEC_LEN - 1);
-    i = 0;
-    while (i < len) {
-        for(j = 0; j < nb_mods; j++)
-            y[j].v = *(__m256d *)&buf[i + fft_len * j];
-
-        /* Chinese remainder to get mixed radix representation */
-        l = 0;
-        for(j = 0; j < nb_mods - 1; j++) {
-            y[j].v = ntt_mod1(y[j].v, mf[j]);
-            for(k = j + 1; k < nb_mods; k++) {
-                y[k].v = ntt_mul_mod(y[k].v - y[j].v,
-                                     mods_cr_vec[l], mf[k], m_inv[k]);
-                l++;
-            }
-        }
-        y[j].v = ntt_mod1(y[j].v, mf[j]);
-        
-        for(p = 0; p < VEC_LEN; p++) {
-            /* back to normal representation */
-            u[0] = (int64_t)y[nb_mods - 1].d[p];
-            l = 1;
-            for(j = nb_mods - 2; j >= 1; j--) {
-                r = (int64_t)y[j].d[p];
-                for(k = 0; k < l; k++) {
-                    t = (dlimb_t)u[k] * mods[j] + r;
-                    r = t >> LIMB_BITS;
-                    u[k] = t;
-                }
-                u[l] = r;
-                l++;
-            }
-            /* XXX: for nb_mods = 5, l should be 4 */
-            
-            /* last step adds the carry */
-            r = (int64_t)y[0].d[p];
-            for(k = 0; k < l; k++) {
-                t = (dlimb_t)u[k] * mods[j] + r + carry[k];
-                r = t >> LIMB_BITS;
-                u[k] = t;
-            }
-            u[l] = r + carry[l];
-
-#if 0
-            printf("%" PRId64 ": ", i);
-            for(j = nb_mods - 1; j >= 0; j--) {
-                printf(" %019" PRIu64, u[j]);
-            }
-            printf("\n");
-#endif
-            
-            /* write the digits */
-            pos = i * dpl;
-            for(j = 0; j < n_limb1; j++) {
-                put_bits(tabr, r_len, pos, u[j]);
-                pos += LIMB_BITS;
-            }
-            put_bits(tabr, r_len, pos, u[n_limb1] & base_mask1);
-            /* shift by dpl digits and set the carry */
-            if (shift == 0) {
-                for(j = n_limb1 + 1; j < nb_mods; j++)
-                    carry[j - (n_limb1 + 1)] = u[j];
-            } else {
-                for(j = n_limb1; j < nb_mods - 1; j++) {
-                    carry[j - n_limb1] = (u[j] >> shift) |
-                        (u[j + 1] << (LIMB_BITS - shift));
-                }
-                carry[nb_mods - 1 - n_limb1] = u[nb_mods - 1] >> shift;
-            }
-            i++;
-        }
-    }
-}
-#else
-static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
-                                  const NTTLimb *buf, int fft_len_log2, int dpl,
-                                  int nb_mods)
-{
-    const limb_t *mods = ntt_mods + NB_MODS - nb_mods;
-    const limb_t *mods_cr, *mods_cr_inv;
-    limb_t y[NB_MODS], u[NB_MODS], carry[NB_MODS], fft_len, base_mask1, r;
-    slimb_t i, len, pos;
-    int j, k, l, shift, n_limb1;
-    dlimb_t t;
-        
-    j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
-    mods_cr = ntt_mods_cr + j;
-    mods_cr_inv = s->ntt_mods_cr_inv + j;
-
-    shift = dpl & (LIMB_BITS - 1);
-    if (shift == 0)
-        base_mask1 = -1;
-    else
-        base_mask1 = ((limb_t)1 << shift) - 1;
-    n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
-    for(j = 0; j < NB_MODS; j++) 
-        carry[j] = 0;
-    for(j = 0; j < NB_MODS; j++) 
-        u[j] = 0; /* avoid warnings */
-    memset(tabr, 0, sizeof(limb_t) * r_len);
-    fft_len = (limb_t)1 << fft_len_log2;
-    len = bf_min(fft_len, (r_len * LIMB_BITS + dpl - 1) / dpl);
-    for(i = 0; i < len; i++) {
-        for(j = 0; j < nb_mods; j++)  {
-            y[j] = ntt_limb_to_int(buf[i + fft_len * j], mods[j]);
-        }
-
-        /* Chinese remainder to get mixed radix representation */
-        l = 0;
-        for(j = 0; j < nb_mods - 1; j++) {
-            for(k = j + 1; k < nb_mods; k++) {
-                limb_t m;
-                m = mods[k];
-                /* Note: there is no overflow in the sub_mod() because
-                   the modulos are sorted by increasing order */
-                y[k] = mul_mod_fast2(y[k] - y[j] + m, 
-                                     mods_cr[l], m, mods_cr_inv[l]);
-                l++;
-            }
-        }
-        
-        /* back to normal representation */
-        u[0] = y[nb_mods - 1];
-        l = 1;
-        for(j = nb_mods - 2; j >= 1; j--) {
-            r = y[j];
-            for(k = 0; k < l; k++) {
-                t = (dlimb_t)u[k] * mods[j] + r;
-                r = t >> LIMB_BITS;
-                u[k] = t;
-            }
-            u[l] = r;
-            l++;
-        }
-        
-        /* last step adds the carry */
-        r = y[0];
-        for(k = 0; k < l; k++) {
-            t = (dlimb_t)u[k] * mods[j] + r + carry[k];
-            r = t >> LIMB_BITS;
-            u[k] = t;
-        }
-        u[l] = r + carry[l];
-
-#if 0
-        printf("%" PRId64 ": ", (int64_t)i);
-        for(j = nb_mods - 1; j >= 0; j--) {
-            printf(" " FMT_LIMB, u[j]);
-        }
-        printf("\n");
-#endif
-        
-        /* write the digits */
-        pos = i * dpl;
-        for(j = 0; j < n_limb1; j++) {
-            put_bits(tabr, r_len, pos, u[j]);
-            pos += LIMB_BITS;
-        }
-        put_bits(tabr, r_len, pos, u[n_limb1] & base_mask1);
-        /* shift by dpl digits and set the carry */
-        if (shift == 0) {
-            for(j = n_limb1 + 1; j < nb_mods; j++)
-                carry[j - (n_limb1 + 1)] = u[j];
-        } else {
-            for(j = n_limb1; j < nb_mods - 1; j++) {
-                carry[j - n_limb1] = (u[j] >> shift) |
-                    (u[j + 1] << (LIMB_BITS - shift));
-            }
-            carry[nb_mods - 1 - n_limb1] = u[nb_mods - 1] >> shift;
-        }
-    }
-}
-#endif
-
-static int ntt_static_init(bf_context_t *s1)
-{
-    BFNTTState *s;
-    int inverse, i, j, k, l;
-    limb_t c, c_inv, c_inv2, m, m_inv;
-
-    if (s1->ntt_state)
-        return 0;
-#if defined(__AVX2__)
-    s = bf_aligned_malloc(s1, sizeof(*s), 64);
-#else
-    s = bf_malloc(s1, sizeof(*s));
-#endif
-    if (!s)
-        return -1;
-    memset(s, 0, sizeof(*s));
-    s1->ntt_state = s;
-    s->ctx = s1;
-    
-    for(j = 0; j < NB_MODS; j++) {
-        m = ntt_mods[j];
-        m_inv = init_mul_mod_fast(m);
-        s->ntt_mods_div[j] = m_inv;
-#if defined(__AVX2__)
-        s->ntt_mods_vec[j] = _mm256_set1_pd(m);
-        s->ntt_mods_inv_vec[j] = _mm256_set1_pd(1.0 / (double)m);
-#endif
-        c_inv2 = (m + 1) / 2; /* 1/2 */
-        c_inv = 1;
-        for(i = 0; i <= NTT_PROOT_2EXP; i++) {
-            s->ntt_len_inv[j][i][0] = c_inv;
-            s->ntt_len_inv[j][i][1] = init_mul_mod_fast2(c_inv, m);
-            c_inv = mul_mod_fast(c_inv, c_inv2, m, m_inv);
-        }
-
-        for(inverse = 0; inverse < 2; inverse++) {
-            c = ntt_proot[inverse][j];
-            for(i = 0; i < NTT_PROOT_2EXP; i++) {
-                s->ntt_proot_pow[j][inverse][NTT_PROOT_2EXP - i] = c;
-                s->ntt_proot_pow_inv[j][inverse][NTT_PROOT_2EXP - i] =
-                    init_mul_mod_fast2(c, m);
-                c = mul_mod_fast(c, c, m, m_inv);
-            }
-        }
-    }
-
-    l = 0;
-    for(j = 0; j < NB_MODS - 1; j++) {
-        for(k = j + 1; k < NB_MODS; k++) {
-#if defined(__AVX2__)
-            s->ntt_mods_cr_vec[l] = _mm256_set1_pd(int_to_ntt_limb2(ntt_mods_cr[l],
-                                                                    ntt_mods[k]));
-#else
-            s->ntt_mods_cr_inv[l] = init_mul_mod_fast2(ntt_mods_cr[l],
-                                                       ntt_mods[k]);
-#endif
-            l++;
-        }
-    }
-    return 0;
-}
-
-int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
-{
-    int dpl, fft_len_log2, n_bits, nb_mods, dpl_found, fft_len_log2_found;
-    int int_bits, nb_mods_found;
-    limb_t cost, min_cost;
-    
-    min_cost = -1;
-    dpl_found = 0;
-    nb_mods_found = 4;
-    fft_len_log2_found = 0;
-    for(nb_mods = 3; nb_mods <= NB_MODS; nb_mods++) {
-        int_bits = ntt_int_bits[NB_MODS - nb_mods];
-        dpl = bf_min((int_bits - 4) / 2,
-                     2 * LIMB_BITS + 2 * NTT_MOD_LOG2_MIN - NTT_MOD_LOG2_MAX);
-        for(;;) {
-            fft_len_log2 = ceil_log2((len * LIMB_BITS + dpl - 1) / dpl);
-            if (fft_len_log2 > NTT_PROOT_2EXP)
-                goto next;
-            n_bits = fft_len_log2 + 2 * dpl;
-            if (n_bits <= int_bits) {
-                cost = ((limb_t)(fft_len_log2 + 1) << fft_len_log2) * nb_mods;
-                //                printf("n=%d dpl=%d: cost=%" PRId64 "\n", nb_mods, dpl, (int64_t)cost);
-                if (cost < min_cost) {
-                    min_cost = cost;
-                    dpl_found = dpl;
-                    nb_mods_found = nb_mods;
-                    fft_len_log2_found = fft_len_log2;
-                }
-                break;
-            }
-            dpl--;
-            if (dpl == 0)
-                break;
-        }
-    next: ;
-    }
-    if (!dpl_found)
-        abort();
-    /* limit dpl if possible to reduce fixed cost of limb/NTT conversion */
-    if (dpl_found > (LIMB_BITS + NTT_MOD_LOG2_MIN) &&
-        ((limb_t)(LIMB_BITS + NTT_MOD_LOG2_MIN) << fft_len_log2_found) >=
-        len * LIMB_BITS) {
-        dpl_found = LIMB_BITS + NTT_MOD_LOG2_MIN;
-    }
-    *pnb_mods = nb_mods_found;
-    *pdpl = dpl_found;
-    return fft_len_log2_found;
-}
-
-/* return 0 if OK, -1 if memory error */
-static no_inline int fft_mul(bf_context_t *s1,
-                             bf_t *res, limb_t *a_tab, limb_t a_len,
-                             limb_t *b_tab, limb_t b_len, int mul_flags)
-{
-    BFNTTState *s;
-    int dpl, fft_len_log2, j, nb_mods, reduced_mem;
-    slimb_t len, fft_len;
-    NTTLimb *buf1, *buf2, *ptr;
-#if defined(USE_MUL_CHECK)
-    limb_t ha, hb, hr, h_ref;
-#endif
-    
-    if (ntt_static_init(s1))
-        return -1;
-    s = s1->ntt_state;
-    
-    /* find the optimal number of digits per limb (dpl) */
-    len = a_len + b_len;
-    fft_len_log2 = bf_get_fft_size(&dpl, &nb_mods, len);
-    fft_len = (uint64_t)1 << fft_len_log2;
-    //    printf("len=%" PRId64 " fft_len_log2=%d dpl=%d\n", len, fft_len_log2, dpl);
-#if defined(USE_MUL_CHECK)
-    ha = mp_mod1(a_tab, a_len, BF_CHKSUM_MOD, 0);
-    hb = mp_mod1(b_tab, b_len, BF_CHKSUM_MOD, 0);
-#endif
-    if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 0) {
-        if (!(mul_flags & FFT_MUL_R_NORESIZE))
-            bf_resize(res, 0);
-    } else if (mul_flags & FFT_MUL_R_OVERLAP_B) {
-        limb_t *tmp_tab, tmp_len;
-        /* it is better to free 'b' first */
-        tmp_tab = a_tab;
-        a_tab = b_tab;
-        b_tab = tmp_tab;
-        tmp_len = a_len;
-        a_len = b_len;
-        b_len = tmp_len;
-    }
-    buf1 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
-    if (!buf1)
-        return -1;
-    limb_to_ntt(s, buf1, fft_len, a_tab, a_len, dpl,
-                NB_MODS - nb_mods, nb_mods);
-    if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 
-        FFT_MUL_R_OVERLAP_A) {
-        if (!(mul_flags & FFT_MUL_R_NORESIZE))
-            bf_resize(res, 0);
-    }
-    reduced_mem = (fft_len_log2 >= 14);
-    if (!reduced_mem) {
-        buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
-        if (!buf2)
-            goto fail;
-        limb_to_ntt(s, buf2, fft_len, b_tab, b_len, dpl,
-                    NB_MODS - nb_mods, nb_mods);
-        if (!(mul_flags & FFT_MUL_R_NORESIZE))
-            bf_resize(res, 0); /* in case res == b */
-    } else {
-        buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len);
-        if (!buf2)
-            goto fail;
-    }
-    for(j = 0; j < nb_mods; j++) {
-        if (reduced_mem) {
-            limb_to_ntt(s, buf2, fft_len, b_tab, b_len, dpl,
-                        NB_MODS - nb_mods + j, 1);
-            ptr = buf2;
-        } else {
-            ptr = buf2 + fft_len * j;
-        }
-        if (ntt_conv(s, buf1 + fft_len * j, ptr,
-                     fft_len_log2, fft_len_log2, j + NB_MODS - nb_mods))
-            goto fail;
-    }
-    if (!(mul_flags & FFT_MUL_R_NORESIZE))
-        bf_resize(res, 0); /* in case res == b and reduced mem */
-    ntt_free(s, buf2);
-    buf2 = NULL;
-    if (!(mul_flags & FFT_MUL_R_NORESIZE)) {
-        if (bf_resize(res, len))
-            goto fail;
-    }
-    ntt_to_limb(s, res->tab, len, buf1, fft_len_log2, dpl, nb_mods);
-    ntt_free(s, buf1);
-#if defined(USE_MUL_CHECK)
-    hr = mp_mod1(res->tab, len, BF_CHKSUM_MOD, 0);
-    h_ref = mul_mod(ha, hb, BF_CHKSUM_MOD);
-    if (hr != h_ref) {
-        printf("ntt_mul_error: len=%" PRId_LIMB " fft_len_log2=%d dpl=%d nb_mods=%d\n",
-               len, fft_len_log2, dpl, nb_mods);
-        //        printf("ha=0x" FMT_LIMB" hb=0x" FMT_LIMB " hr=0x" FMT_LIMB " expected=0x" FMT_LIMB "\n", ha, hb, hr, h_ref);
-        exit(1);
-    }
-#endif    
-    return 0;
- fail:
-    ntt_free(s, buf1);
-    ntt_free(s, buf2);
-    return -1;
-}
-
-#else /* USE_FFT_MUL */
-
-int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
-{
-    return 0;
-}
-
-#endif /* !USE_FFT_MUL */
diff --git a/quickjs/libbf.h b/quickjs/libbf.h
deleted file mode 100644
index 48e9d956a2..0000000000
--- a/quickjs/libbf.h
+++ /dev/null
@@ -1,535 +0,0 @@
-/*
- * Tiny arbitrary precision floating point library
- * 
- * Copyright (c) 2017-2021 Fabrice Bellard
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#ifndef LIBBF_H
-#define LIBBF_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#if INTPTR_MAX >= INT64_MAX
-#define LIMB_LOG2_BITS 6
-#else
-#define LIMB_LOG2_BITS 5
-#endif
-
-#define LIMB_BITS (1 << LIMB_LOG2_BITS)
-
-#if LIMB_BITS == 64
-typedef __int128 int128_t;
-typedef unsigned __int128 uint128_t;
-typedef int64_t slimb_t;
-typedef uint64_t limb_t;
-typedef uint128_t dlimb_t;
-#define BF_RAW_EXP_MIN INT64_MIN
-#define BF_RAW_EXP_MAX INT64_MAX
-
-#define LIMB_DIGITS 19
-#define BF_DEC_BASE UINT64_C(10000000000000000000)
-
-#else
-
-typedef int32_t slimb_t;
-typedef uint32_t limb_t;
-typedef uint64_t dlimb_t;
-#define BF_RAW_EXP_MIN INT32_MIN
-#define BF_RAW_EXP_MAX INT32_MAX
-
-#define LIMB_DIGITS 9
-#define BF_DEC_BASE 1000000000U
-
-#endif
-
-/* in bits */
-/* minimum number of bits for the exponent */
-#define BF_EXP_BITS_MIN 3
-/* maximum number of bits for the exponent */
-#define BF_EXP_BITS_MAX (LIMB_BITS - 3)
-/* extended range for exponent, used internally */
-#define BF_EXT_EXP_BITS_MAX (BF_EXP_BITS_MAX + 1)
-/* minimum possible precision */
-#define BF_PREC_MIN 2
-/* minimum possible precision */
-#define BF_PREC_MAX (((limb_t)1 << (LIMB_BITS - 2)) - 2)
-/* some operations support infinite precision */
-#define BF_PREC_INF (BF_PREC_MAX + 1) /* infinite precision */
-
-#if LIMB_BITS == 64
-#define BF_CHKSUM_MOD (UINT64_C(975620677) * UINT64_C(9795002197))
-#else
-#define BF_CHKSUM_MOD 975620677U
-#endif
-
-#define BF_EXP_ZERO BF_RAW_EXP_MIN
-#define BF_EXP_INF (BF_RAW_EXP_MAX - 1)
-#define BF_EXP_NAN BF_RAW_EXP_MAX
-
-/* +/-zero is represented with expn = BF_EXP_ZERO and len = 0,
-   +/-infinity is represented with expn = BF_EXP_INF and len = 0,
-   NaN is represented with expn = BF_EXP_NAN and len = 0 (sign is ignored)
- */
-typedef struct {
-    struct bf_context_t *ctx;
-    int sign;
-    slimb_t expn;
-    limb_t len;
-    limb_t *tab;
-} bf_t;
-
-typedef struct {
-    /* must be kept identical to bf_t */
-    struct bf_context_t *ctx;
-    int sign;
-    slimb_t expn;
-    limb_t len;
-    limb_t *tab;
-} bfdec_t;
-
-typedef enum {
-    BF_RNDN, /* round to nearest, ties to even */
-    BF_RNDZ, /* round to zero */
-    BF_RNDD, /* round to -inf (the code relies on (BF_RNDD xor BF_RNDU) = 1) */
-    BF_RNDU, /* round to +inf */
-    BF_RNDNA, /* round to nearest, ties away from zero */
-    BF_RNDA, /* round away from zero */
-    BF_RNDF, /* faithful rounding (nondeterministic, either RNDD or RNDU,
-                inexact flag is always set)  */
-} bf_rnd_t;
-
-/* allow subnormal numbers. Only available if the number of exponent
-   bits is <= BF_EXP_BITS_USER_MAX and prec != BF_PREC_INF. */
-#define BF_FLAG_SUBNORMAL (1 << 3)
-/* 'prec' is the precision after the radix point instead of the whole
-   mantissa. Can only be used with bf_round() and
-   bfdec_[add|sub|mul|div|sqrt|round](). */
-#define BF_FLAG_RADPNT_PREC (1 << 4)
-
-#define BF_RND_MASK 0x7
-#define BF_EXP_BITS_SHIFT 5
-#define BF_EXP_BITS_MASK 0x3f
-
-/* shortcut for bf_set_exp_bits(BF_EXT_EXP_BITS_MAX) */
-#define BF_FLAG_EXT_EXP (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)
-
-/* contains the rounding mode and number of exponents bits */
-typedef uint32_t bf_flags_t;
-
-typedef void *bf_realloc_func_t(void *opaque, void *ptr, size_t size);
-
-typedef struct {
-    bf_t val;
-    limb_t prec;
-} BFConstCache;
-
-typedef struct bf_context_t {
-    void *realloc_opaque;
-    bf_realloc_func_t *realloc_func;
-    BFConstCache log2_cache;
-    BFConstCache pi_cache;
-    struct BFNTTState *ntt_state;
-} bf_context_t;
-
-static inline int bf_get_exp_bits(bf_flags_t flags)
-{
-    int e;
-    e = (flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK;
-    if (e == BF_EXP_BITS_MASK)
-        return BF_EXP_BITS_MAX + 1;
-    else
-        return BF_EXP_BITS_MAX - e;
-}
-
-static inline bf_flags_t bf_set_exp_bits(int n)
-{
-    return ((BF_EXP_BITS_MAX - n) & BF_EXP_BITS_MASK) << BF_EXP_BITS_SHIFT;
-}
-
-/* returned status */
-#define BF_ST_INVALID_OP  (1 << 0)
-#define BF_ST_DIVIDE_ZERO (1 << 1)
-#define BF_ST_OVERFLOW    (1 << 2)
-#define BF_ST_UNDERFLOW   (1 << 3)
-#define BF_ST_INEXACT     (1 << 4)
-/* indicate that a memory allocation error occured. NaN is returned */
-#define BF_ST_MEM_ERROR   (1 << 5) 
-
-#define BF_RADIX_MAX 36 /* maximum radix for bf_atof() and bf_ftoa() */
-
-static inline slimb_t bf_max(slimb_t a, slimb_t b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline slimb_t bf_min(slimb_t a, slimb_t b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
-                     void *realloc_opaque);
-void bf_context_end(bf_context_t *s);
-/* free memory allocated for the bf cache data */
-void bf_clear_cache(bf_context_t *s);
-
-static inline void *bf_realloc(bf_context_t *s, void *ptr, size_t size)
-{
-    return s->realloc_func(s->realloc_opaque, ptr, size);
-}
-
-/* 'size' must be != 0 */
-static inline void *bf_malloc(bf_context_t *s, size_t size)
-{
-    return bf_realloc(s, NULL, size);
-}
-
-static inline void bf_free(bf_context_t *s, void *ptr)
-{
-    /* must test ptr otherwise equivalent to malloc(0) */
-    if (ptr)
-        bf_realloc(s, ptr, 0);
-}
-
-void bf_init(bf_context_t *s, bf_t *r);
-
-static inline void bf_delete(bf_t *r)
-{
-    bf_context_t *s = r->ctx;
-    /* we accept to delete a zeroed bf_t structure */
-    if (s && r->tab) {
-        bf_realloc(s, r->tab, 0);
-    }
-}
-
-static inline void bf_neg(bf_t *r)
-{
-    r->sign ^= 1;
-}
-
-static inline int bf_is_finite(const bf_t *a)
-{
-    return (a->expn < BF_EXP_INF);
-}
-
-static inline int bf_is_nan(const bf_t *a)
-{
-    return (a->expn == BF_EXP_NAN);
-}
-
-static inline int bf_is_zero(const bf_t *a)
-{
-    return (a->expn == BF_EXP_ZERO);
-}
-
-static inline void bf_memcpy(bf_t *r, const bf_t *a)
-{
-    *r = *a;
-}
-
-int bf_set_ui(bf_t *r, uint64_t a);
-int bf_set_si(bf_t *r, int64_t a);
-void bf_set_nan(bf_t *r);
-void bf_set_zero(bf_t *r, int is_neg);
-void bf_set_inf(bf_t *r, int is_neg);
-int bf_set(bf_t *r, const bf_t *a);
-void bf_move(bf_t *r, bf_t *a);
-int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode);
-int bf_set_float64(bf_t *a, double d);
-
-int bf_cmpu(const bf_t *a, const bf_t *b);
-int bf_cmp_full(const bf_t *a, const bf_t *b);
-int bf_cmp(const bf_t *a, const bf_t *b);
-static inline int bf_cmp_eq(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b) == 0;
-}
-
-static inline int bf_cmp_le(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b) <= 0;
-}
-
-static inline int bf_cmp_lt(const bf_t *a, const bf_t *b)
-{
-    return bf_cmp(a, b) < 0;
-}
-
-int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
-int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
-int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
-int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
-int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec, bf_flags_t flags);
-int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, 
-              bf_flags_t flags);
-int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags);
-int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
-#define BF_DIVREM_EUCLIDIAN BF_RNDF
-int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
-              limb_t prec, bf_flags_t flags, int rnd_mode);
-int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-           bf_flags_t flags, int rnd_mode);
-int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
-              bf_flags_t flags, int rnd_mode);
-/* round to integer with infinite precision */
-int bf_rint(bf_t *r, int rnd_mode);
-int bf_round(bf_t *r, limb_t prec, bf_flags_t flags);
-int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a);
-int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-slimb_t bf_get_exp_min(const bf_t *a);
-int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b);
-int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b);
-int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
-
-/* additional flags for bf_atof */
-/* do not accept hex radix prefix (0x or 0X) if radix = 0 or radix = 16 */
-#define BF_ATOF_NO_HEX       (1 << 16)
-/* accept binary (0b or 0B) or octal (0o or 0O) radix prefix if radix = 0 */
-#define BF_ATOF_BIN_OCT      (1 << 17)
-/* Do not parse NaN or Inf */
-#define BF_ATOF_NO_NAN_INF   (1 << 18)
-/* return the exponent separately */
-#define BF_ATOF_EXPONENT       (1 << 19)
-
-int bf_atof(bf_t *a, const char *str, const char **pnext, int radix,
-            limb_t prec, bf_flags_t flags);
-/* this version accepts prec = BF_PREC_INF and returns the radix
-   exponent */
-int bf_atof2(bf_t *r, slimb_t *pexponent,
-             const char *str, const char **pnext, int radix,
-             limb_t prec, bf_flags_t flags);
-int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
-                     slimb_t expn, limb_t prec, bf_flags_t flags);
-
-
-/* Conversion of floating point number to string. Return a null
-   terminated string or NULL if memory error. *plen contains its
-   length if plen != NULL.  The exponent letter is "e" for base 10,
-   "p" for bases 2, 8, 16 with a binary exponent and "@" for the other
-   bases. */
-
-#define BF_FTOA_FORMAT_MASK (3 << 16)
-
-/* fixed format: prec significant digits rounded with (flags &
-   BF_RND_MASK). Exponential notation is used if too many zeros are
-   needed.*/
-#define BF_FTOA_FORMAT_FIXED (0 << 16)
-/* fractional format: prec digits after the decimal point rounded with
-   (flags & BF_RND_MASK) */
-#define BF_FTOA_FORMAT_FRAC  (1 << 16)
-/* free format: 
-   
-   For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
-   number of digits to represent 'a'. The precision and the rounding
-   mode are ignored.
-   
-   For the non binary radices with bf_ftoa(): use as many digits as
-   necessary so that bf_atof() return the same number when using
-   precision 'prec', rounding to nearest and the subnormal
-   configuration of 'flags'. The result is meaningful only if 'a' is
-   already rounded to 'prec' bits. If the subnormal flag is set, the
-   exponent in 'flags' must also be set to the desired exponent range.
-*/
-#define BF_FTOA_FORMAT_FREE  (2 << 16)
-/* same as BF_FTOA_FORMAT_FREE but uses the minimum number of digits
-   (takes more computation time). Identical to BF_FTOA_FORMAT_FREE for
-   binary radices with bf_ftoa() and for bfdec_ftoa(). */
-#define BF_FTOA_FORMAT_FREE_MIN (3 << 16)
-
-/* force exponential notation for fixed or free format */
-#define BF_FTOA_FORCE_EXP    (1 << 20)
-/* add 0x prefix for base 16, 0o prefix for base 8 or 0b prefix for
-   base 2 if non zero value */
-#define BF_FTOA_ADD_PREFIX   (1 << 21)
-/* return "Infinity" instead of "Inf" and add a "+" for positive
-   exponents */
-#define BF_FTOA_JS_QUIRKS    (1 << 22)
-
-char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
-              bf_flags_t flags);
-
-/* modulo 2^n instead of saturation. NaN and infinity return 0 */
-#define BF_GET_INT_MOD (1 << 0) 
-int bf_get_int32(int *pres, const bf_t *a, int flags);
-int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
-int bf_get_uint64(uint64_t *pres, const bf_t *a);
-
-/* the following functions are exported for testing only. */
-void mp_print_str(const char *str, const limb_t *tab, limb_t n);
-void bf_print_str(const char *str, const bf_t *a);
-int bf_resize(bf_t *r, limb_t len);
-int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len);
-int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags);
-int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k);
-slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
-                          int is_ceil1);
-int mp_mul(bf_context_t *s, limb_t *result, 
-           const limb_t *op1, limb_t op1_size, 
-           const limb_t *op2, limb_t op2_size);
-limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
-              limb_t n, limb_t carry);
-limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n);
-int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n);
-int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n);
-limb_t bf_isqrt(limb_t a);
-
-/* transcendental functions */
-int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags);
-int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags);
-int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-#define BF_POW_JS_QUIRKS (1 << 16) /* (+/-1)^(+/-Inf) = NaN, 1^NaN = NaN */
-int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags);
-int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_atan2(bf_t *r, const bf_t *y, const bf_t *x,
-             limb_t prec, bf_flags_t flags);
-int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
-
-/* decimal floating point */
-
-static inline void bfdec_init(bf_context_t *s, bfdec_t *r)
-{
-    bf_init(s, (bf_t *)r);
-}
-static inline void bfdec_delete(bfdec_t *r)
-{
-    bf_delete((bf_t *)r);
-}
-
-static inline void bfdec_neg(bfdec_t *r)
-{
-    r->sign ^= 1;
-}
-
-static inline int bfdec_is_finite(const bfdec_t *a)
-{
-    return (a->expn < BF_EXP_INF);
-}
-
-static inline int bfdec_is_nan(const bfdec_t *a)
-{
-    return (a->expn == BF_EXP_NAN);
-}
-
-static inline int bfdec_is_zero(const bfdec_t *a)
-{
-    return (a->expn == BF_EXP_ZERO);
-}
-
-static inline void bfdec_memcpy(bfdec_t *r, const bfdec_t *a)
-{
-    bf_memcpy((bf_t *)r, (const bf_t *)a);
-}
-
-int bfdec_set_ui(bfdec_t *r, uint64_t a);
-int bfdec_set_si(bfdec_t *r, int64_t a);
-
-static inline void bfdec_set_nan(bfdec_t *r)
-{
-    bf_set_nan((bf_t *)r);
-}
-static inline void bfdec_set_zero(bfdec_t *r, int is_neg)
-{
-    bf_set_zero((bf_t *)r, is_neg);
-}
-static inline void bfdec_set_inf(bfdec_t *r, int is_neg)
-{
-    bf_set_inf((bf_t *)r, is_neg);
-}
-static inline int bfdec_set(bfdec_t *r, const bfdec_t *a)
-{
-    return bf_set((bf_t *)r, (bf_t *)a);
-}
-static inline void bfdec_move(bfdec_t *r, bfdec_t *a)
-{
-    bf_move((bf_t *)r, (bf_t *)a);
-}
-static inline int bfdec_cmpu(const bfdec_t *a, const bfdec_t *b)
-{
-    return bf_cmpu((const bf_t *)a, (const bf_t *)b);
-}
-static inline int bfdec_cmp_full(const bfdec_t *a, const bfdec_t *b)
-{
-    return bf_cmp_full((const bf_t *)a, (const bf_t *)b);
-}
-static inline int bfdec_cmp(const bfdec_t *a, const bfdec_t *b)
-{
-    return bf_cmp((const bf_t *)a, (const bf_t *)b);
-}
-static inline int bfdec_cmp_eq(const bfdec_t *a, const bfdec_t *b)
-{
-    return bfdec_cmp(a, b) == 0;
-}
-static inline int bfdec_cmp_le(const bfdec_t *a, const bfdec_t *b)
-{
-    return bfdec_cmp(a, b) <= 0;
-}
-static inline int bfdec_cmp_lt(const bfdec_t *a, const bfdec_t *b)
-{
-    return bfdec_cmp(a, b) < 0;
-}
-
-int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags);
-int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags);
-int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
-                 bf_flags_t flags);
-int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags);
-int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
-                 bf_flags_t flags);
-int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags);
-int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
-                 limb_t prec, bf_flags_t flags, int rnd_mode);
-int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
-              bf_flags_t flags, int rnd_mode);
-int bfdec_rint(bfdec_t *r, int rnd_mode);
-int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags);
-int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags);
-int bfdec_get_int32(int *pres, const bfdec_t *a);
-int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b);
-
-char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags);
-int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
-               limb_t prec, bf_flags_t flags);
-
-/* the following functions are exported for testing only. */
-extern const limb_t mp_pow_dec[LIMB_DIGITS + 1];
-void bfdec_print_str(const char *str, const bfdec_t *a);
-static inline int bfdec_resize(bfdec_t *r, limb_t len)
-{
-    return bf_resize((bf_t *)r, len);
-}
-int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags);
-
-#endif /* LIBBF_H */
diff --git a/quickjs/libregexp-opcode.h b/quickjs/libregexp-opcode.h
index f90c23b347..ebab751dfc 100644
--- a/quickjs/libregexp-opcode.h
+++ b/quickjs/libregexp-opcode.h
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -26,11 +26,15 @@
 
 DEF(invalid, 1) /* never used */
 DEF(char, 3)
+DEF(char_i, 3)
 DEF(char32, 5)
+DEF(char32_i, 5)
 DEF(dot, 1)
 DEF(any, 1) /* same as dot but match any character including line terminator */
 DEF(line_start, 1)
+DEF(line_start_m, 1)
 DEF(line_end, 1)
+DEF(line_end_m, 1)
 DEF(goto, 5)
 DEF(split_goto_first, 5)
 DEF(split_next_first, 5)
@@ -42,16 +46,21 @@ DEF(loop, 5) /* decrement the top the stack and goto if != 0 */
 DEF(push_i32, 5) /* push integer on the stack */
 DEF(drop, 1)
 DEF(word_boundary, 1)
+DEF(word_boundary_i, 1)
 DEF(not_word_boundary, 1)
+DEF(not_word_boundary_i, 1)
 DEF(back_reference, 2)
-DEF(backward_back_reference, 2) /* must come after back_reference */
+DEF(back_reference_i, 2) /* must come after */
+DEF(backward_back_reference, 2) /* must come after */
+DEF(backward_back_reference_i, 2) /* must come after */
 DEF(range, 3) /* variable length */
+DEF(range_i, 3) /* variable length */
 DEF(range32, 3) /* variable length */
+DEF(range32_i, 3) /* variable length */
 DEF(lookahead, 5)
 DEF(negative_lookahead, 5)
 DEF(push_char_pos, 1) /* push the character position on the stack */
-DEF(bne_char_pos, 5) /* pop one stack element and jump if equal to the character
- position */
+DEF(check_advance, 1) /* pop one stack element and check that it is different from the character position */
 DEF(prev, 1) /* go to the previous char */
 DEF(simple_greedy_quant, 17)
 
diff --git a/quickjs/libregexp.c b/quickjs/libregexp.c
index dab8fa1e2e..2b33c86953 100644
--- a/quickjs/libregexp.c
+++ b/quickjs/libregexp.c
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -30,13 +30,11 @@
 
 #include "cutils.h"
 #include "libregexp.h"
+#include "libunicode.h"
 
 /*
   TODO:
 
-  - Add full unicode canonicalize rules for character ranges (not
-    really useful but needed for exact "ignorecase" compatibility).
-
   - Add a lock step execution mode (=linear time execution guaranteed)
     when the regular expression is "simple" i.e. no backreference nor
     complicated lookahead. The opcodes are designed for this execution
@@ -56,6 +54,9 @@ typedef enum {
 
 #define CAPTURE_COUNT_MAX 255
 #define STACK_SIZE_MAX 255
+/* must be large enough to have a negligible runtime cost and small
+   enough to call the interrupt callback often. */
+#define INTERRUPT_COUNTER_INIT 10000
 
 /* unicode code points */
 #define CP_LS   0x2028
@@ -69,8 +70,10 @@ typedef struct {
     const uint8_t *buf_end;
     const uint8_t *buf_start;
     int re_flags;
-    BOOL is_utf16;
+    BOOL is_unicode;
+    BOOL unicode_sets; /* if set, is_unicode is also set */
     BOOL ignore_case;
+    BOOL multi_line;
     BOOL dotall;
     int capture_count;
     int total_capture_count; /* -1 = not computed yet */
@@ -101,10 +104,11 @@ static const REOpCode reopcode_info[REOP_COUNT] = {
 };
 
 #define RE_HEADER_FLAGS         0
-#define RE_HEADER_CAPTURE_COUNT 1
-#define RE_HEADER_STACK_SIZE    2
+#define RE_HEADER_CAPTURE_COUNT 2
+#define RE_HEADER_STACK_SIZE    3
+#define RE_HEADER_BYTECODE_LEN  4
 
-#define RE_HEADER_LEN 7
+#define RE_HEADER_LEN 8
 
 static inline int is_digit(int c) {
     return c >= '0' && c <= '9';
@@ -120,31 +124,262 @@ static int dbuf_insert(DynBuf *s, int pos, int len)
     return 0;
 }
 
-/* canonicalize with the specific JS regexp rules */
-static uint32_t lre_canonicalize(uint32_t c, BOOL is_utf16)
+typedef struct REString {
+    struct REString *next;
+    uint32_t hash;
+    uint32_t len;
+    uint32_t buf[];
+} REString;
+
+typedef struct {
+    /* the string list is the union of 'char_range' and of the strings
+       in hash_table[]. The strings in hash_table[] have a length !=
+       1. */
+    CharRange cr;
+    uint32_t n_strings;
+    uint32_t hash_size;
+    int hash_bits;
+    REString **hash_table;
+} REStringList;
+
+static uint32_t re_string_hash(int len, const uint32_t *buf)
 {
-    uint32_t res[LRE_CC_RES_LEN_MAX];
-    int len;
-    if (is_utf16) {
-        if (likely(c < 128)) {
-            if (c >= 'A' && c <= 'Z')
-                c = c - 'A' + 'a';
-        } else {
-            lre_case_conv(res, c, 2);
-            c = res[0];
+    int i;
+    uint32_t h;
+    h = 1;
+    for(i = 0; i < len; i++)
+        h = h * 263 + buf[i];
+    return h * 0x61C88647;
+}
+
+static void re_string_list_init(REParseState *s1, REStringList *s)
+{
+    cr_init(&s->cr, s1->opaque, lre_realloc);
+    s->n_strings = 0;
+    s->hash_size = 0;
+    s->hash_bits = 0;
+    s->hash_table = NULL;
+}
+
+static void re_string_list_free(REStringList *s)
+{
+    REString *p, *p_next;
+    int i;
+    for(i = 0; i < s->hash_size; i++) {
+        for(p = s->hash_table[i]; p != NULL; p = p_next) {
+            p_next = p->next;
+            lre_realloc(s->cr.mem_opaque, p, 0);
         }
+    }
+    lre_realloc(s->cr.mem_opaque, s->hash_table, 0);
+
+    cr_free(&s->cr);
+}
+
+static void lre_print_char(int c, BOOL is_range)
+{
+    if (c == '\'' || c == '\\' ||
+        (is_range && (c == '-' || c == ']'))) {
+        printf("\\%c", c);
+    } else if (c >= ' ' && c <= 126) {
+        printf("%c", c);
     } else {
-        if (likely(c < 128)) {
-            if (c >= 'a' && c <= 'z')
-                c = c - 'a' + 'A';
-        } else {
-            /* legacy regexp: to upper case if single char >= 128 */
-            len = lre_case_conv(res, c, FALSE);
-            if (len == 1 && res[0] >= 128)
-                c = res[0];
+        printf("\\u{%04x}", c);
+    }
+}
+
+static __maybe_unused void re_string_list_dump(const char *str, const REStringList *s)
+{
+    REString *p;
+    const CharRange *cr;
+    int i, j, k;
+
+    printf("%s:\n", str);
+    printf("  ranges: [");
+    cr = &s->cr;
+    for(i = 0; i < cr->len; i += 2) {
+        lre_print_char(cr->points[i], TRUE);
+        if (cr->points[i] != cr->points[i + 1] - 1) {
+            printf("-");
+            lre_print_char(cr->points[i + 1] - 1, TRUE);
+        }
+    }
+    printf("]\n");
+    
+    j = 0;
+    for(i = 0; i < s->hash_size; i++) {
+        for(p = s->hash_table[i]; p != NULL; p = p->next) {
+            printf("  %d/%d: '", j, s->n_strings);
+            for(k = 0; k < p->len; k++) {
+                lre_print_char(p->buf[k], FALSE);
+            }
+            printf("'\n");
+            j++;
         }
     }
-    return c;
+}
+
+static int re_string_find2(REStringList *s, int len, const uint32_t *buf,
+                           uint32_t h0, BOOL add_flag)
+{
+    uint32_t h = 0; /* avoid warning */
+    REString *p;
+    if (s->n_strings != 0) {
+        h = h0 >> (32 - s->hash_bits);
+        for(p = s->hash_table[h]; p != NULL; p = p->next) {
+            if (p->hash == h0 && p->len == len &&
+                !memcmp(p->buf, buf, len * sizeof(buf[0]))) {
+                return 1;
+            }
+        }
+    }
+    /* not found */
+    if (!add_flag)
+        return 0;
+    /* increase the size of the hash table if needed */
+    if (unlikely((s->n_strings + 1) > s->hash_size)) {
+        REString **new_hash_table, *p_next;
+        int new_hash_bits, i;
+        uint32_t new_hash_size;
+        new_hash_bits = max_int(s->hash_bits + 1, 4);
+        new_hash_size = 1 << new_hash_bits;
+        new_hash_table = lre_realloc(s->cr.mem_opaque, NULL,
+                                     sizeof(new_hash_table[0]) * new_hash_size);
+        if (!new_hash_table)
+            return -1;
+        memset(new_hash_table, 0, sizeof(new_hash_table[0]) * new_hash_size);
+        for(i = 0; i < s->hash_size; i++) {
+            for(p = s->hash_table[i]; p != NULL; p = p_next) {
+                p_next = p->next;
+                h = p->hash >> (32 - new_hash_bits);
+                p->next = new_hash_table[h];
+                new_hash_table[h] = p;
+            }
+        }
+        lre_realloc(s->cr.mem_opaque, s->hash_table, 0);
+        s->hash_bits = new_hash_bits;
+        s->hash_size = new_hash_size;
+        s->hash_table = new_hash_table;
+        h = h0 >> (32 - s->hash_bits);
+    }
+
+    p = lre_realloc(s->cr.mem_opaque, NULL, sizeof(REString) + len * sizeof(buf[0]));
+    if (!p)
+        return -1;
+    p->next = s->hash_table[h];
+    s->hash_table[h] = p;
+    s->n_strings++;
+    p->hash = h0;
+    p->len = len;
+    memcpy(p->buf, buf, sizeof(buf[0]) * len);
+    return 1;
+}
+
+static int re_string_find(REStringList *s, int len, const uint32_t *buf,
+                          BOOL add_flag)
+{
+    uint32_t h0;
+    h0 = re_string_hash(len, buf);
+    return re_string_find2(s, len, buf, h0, add_flag);
+}
+
+/* return -1 if memory error, 0 if OK */
+static int re_string_add(REStringList *s, int len, const uint32_t *buf)
+{
+    if (len == 1) {
+        return cr_union_interval(&s->cr, buf[0], buf[0]);
+    }
+    if (re_string_find(s, len, buf, TRUE) < 0)
+        return -1;
+    return 0;
+}
+
+/* a = a op b */
+static int re_string_list_op(REStringList *a, REStringList *b, int op)
+{
+    int i, ret;
+    REString *p, **pp;
+
+    if (cr_op1(&a->cr, b->cr.points, b->cr.len, op))
+        return -1;
+
+    switch(op) {
+    case CR_OP_UNION:
+        if (b->n_strings != 0) {
+            for(i = 0; i < b->hash_size; i++) {
+                for(p = b->hash_table[i]; p != NULL; p = p->next) {
+                    if (re_string_find2(a, p->len, p->buf, p->hash, TRUE) < 0)
+                        return -1;
+                }
+            }
+        }
+        break;
+    case CR_OP_INTER:
+    case CR_OP_SUB:
+        for(i = 0; i < a->hash_size; i++) {
+            pp = &a->hash_table[i];
+            for(;;) {
+                p = *pp;
+                if (p == NULL)
+                    break;
+                ret = re_string_find2(b, p->len, p->buf, p->hash, FALSE);
+                if (op == CR_OP_SUB)
+                    ret = !ret;
+                if (!ret) {
+                    /* remove it */
+                    *pp = p->next;
+                    a->n_strings--;
+                    lre_realloc(a->cr.mem_opaque, p, 0);
+                } else {
+                    /* keep it */
+                    pp = &p->next;
+                }
+            }
+        }
+        break;
+    default:
+        abort();
+    }
+    return 0;
+}
+
+static int re_string_list_canonicalize(REParseState *s1,
+                                       REStringList *s, BOOL is_unicode)
+{
+    if (cr_regexp_canonicalize(&s->cr, is_unicode))
+        return -1;
+    if (s->n_strings != 0) {
+        REStringList a_s, *a = &a_s;
+        int i, j;
+        REString *p;
+        
+        /* XXX: simplify */
+        re_string_list_init(s1, a);
+
+        a->n_strings = s->n_strings;
+        a->hash_size = s->hash_size;
+        a->hash_bits = s->hash_bits;
+        a->hash_table = s->hash_table;
+        
+        s->n_strings = 0;
+        s->hash_size = 0;
+        s->hash_bits = 0;
+        s->hash_table = NULL;
+
+        for(i = 0; i < a->hash_size; i++) {
+            for(p = a->hash_table[i]; p != NULL; p = p->next) {
+                for(j = 0; j < p->len; j++) {
+                    p->buf[j] = lre_canonicalize(p->buf[j], is_unicode);
+                }
+                if (re_string_add(s, p->len, p->buf)) {
+                    re_string_list_free(a);
+                    return -1;
+                }
+            }
+        }
+        re_string_list_free(a);
+    }
+    return 0;
 }
 
 static const uint16_t char_range_d[] = {
@@ -170,32 +405,6 @@ static const uint16_t char_range_s[] = {
     0xFEFF, 0xFEFF + 1,
 };
 
-BOOL lre_is_space(int c)
-{
-    int i, n, low, high;
-    n = (countof(char_range_s) - 1) / 2;
-    for(i = 0; i < n; i++) {
-        low = char_range_s[2 * i + 1];
-        if (c < low)
-            return FALSE;
-        high = char_range_s[2 * i + 2];
-        if (c < high)
-            return TRUE;
-    }
-    return FALSE;
-}
-
-uint32_t const lre_id_start_table_ascii[4] = {
-    /* $ A-Z _ a-z */
-    0x00000000, 0x00000010, 0x87FFFFFE, 0x07FFFFFE
-};
-
-uint32_t const lre_id_continue_table_ascii[4] = {
-    /* $ 0-9 A-Z _ a-z */
-    0x00000000, 0x03FF0010, 0x87FFFFFE, 0x07FFFFFE
-};
-
-
 static const uint16_t char_range_w[] = {
     4,
     0x0030, 0x0039 + 1,
@@ -215,80 +424,55 @@ typedef enum {
     CHAR_RANGE_W,
 } CharRangeEnum;
 
-static const uint16_t *char_range_table[] = {
+static const uint16_t * const char_range_table[] = {
     char_range_d,
     char_range_s,
     char_range_w,
 };
 
-static int cr_init_char_range(REParseState *s, CharRange *cr, uint32_t c)
+static int cr_init_char_range(REParseState *s, REStringList *cr, uint32_t c)
 {
     BOOL invert;
     const uint16_t *c_pt;
     int len, i;
-    
+
     invert = c & 1;
     c_pt = char_range_table[c >> 1];
     len = *c_pt++;
-    cr_init(cr, s->opaque, lre_realloc);
+    re_string_list_init(s, cr);
     for(i = 0; i < len * 2; i++) {
-        if (cr_add_point(cr, c_pt[i]))
+        if (cr_add_point(&cr->cr, c_pt[i]))
             goto fail;
     }
     if (invert) {
-        if (cr_invert(cr))
+        if (cr_invert(&cr->cr))
             goto fail;
     }
     return 0;
  fail:
-    cr_free(cr);
+    re_string_list_free(cr);
     return -1;
 }
 
-static int cr_canonicalize(CharRange *cr)
-{
-    CharRange a;
-    uint32_t pt[2];
-    int i, ret;
-
-    cr_init(&a, cr->mem_opaque, lre_realloc);
-    pt[0] = 'a';
-    pt[1] = 'z' + 1;
-    ret = cr_op(&a, cr->points, cr->len, pt, 2, CR_OP_INTER);
-    if (ret)
-        goto fail;
-    /* convert to upper case */
-    /* XXX: the generic unicode case would be much more complicated
-       and not really useful */
-    for(i = 0; i < a.len; i++) {
-        a.points[i] += 'A' - 'a';
-    }
-    /* Note: for simplicity we keep the lower case ranges */
-    ret = cr_union1(cr, a.points, a.len);
- fail:
-    cr_free(&a);
-    return ret;
-}
-
 #ifdef DUMP_REOP
 static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
                                                      int buf_len)
 {
     int pos, len, opcode, bc_len, re_flags, i;
     uint32_t val;
-    
+
     assert(buf_len >= RE_HEADER_LEN);
 
-    re_flags=  buf[0];
-    bc_len = get_u32(buf + 3);
+    re_flags = lre_get_flags(buf);
+    bc_len = get_u32(buf + RE_HEADER_BYTECODE_LEN);
     assert(bc_len + RE_HEADER_LEN <= buf_len);
     printf("flags: 0x%x capture_count=%d stack_size=%d\n",
-           re_flags, buf[1], buf[2]);
+           re_flags, buf[RE_HEADER_CAPTURE_COUNT], buf[RE_HEADER_STACK_SIZE]);
     if (re_flags & LRE_FLAG_NAMED_GROUPS) {
         const char *p;
         p = (char *)buf + RE_HEADER_LEN + bc_len;
         printf("named groups: ");
-        for(i = 1; i < buf[1]; i++) {
+        for(i = 1; i < buf[RE_HEADER_CAPTURE_COUNT]; i++) {
             if (i != 1)
                 printf(",");
             printf("<%s>", p);
@@ -316,6 +500,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
         printf("%s", reopcode_info[opcode].name);
         switch(opcode) {
         case REOP_char:
+        case REOP_char_i:
             val = get_u16(buf + pos + 1);
             if (val >= ' ' && val <= 126)
                 printf(" '%c'", val);
@@ -323,6 +508,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
                 printf(" 0x%04x", val);
             break;
         case REOP_char32:
+        case REOP_char32_i:
             val = get_u32(buf + pos + 1);
             if (val >= ' ' && val <= 126)
                 printf(" '%c'", val);
@@ -335,7 +521,6 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
         case REOP_loop:
         case REOP_lookahead:
         case REOP_negative_lookahead:
-        case REOP_bne_char_pos:
             val = get_u32(buf + pos + 1);
             val += (pos + 5);
             printf(" %u", val);
@@ -350,7 +535,9 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
         case REOP_save_start:
         case REOP_save_end:
         case REOP_back_reference:
+        case REOP_back_reference_i:
         case REOP_backward_back_reference:
+        case REOP_backward_back_reference_i:
             printf(" %u", buf[pos + 1]);
             break;
         case REOP_save_reset:
@@ -361,6 +548,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
             printf(" %d", val);
             break;
         case REOP_range:
+        case REOP_range_i:
             {
                 int n, i;
                 n = get_u16(buf + pos + 1);
@@ -372,6 +560,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
             }
             break;
         case REOP_range32:
+        case REOP_range32_i:
             {
                 int n, i;
                 n = get_u16(buf + pos + 1);
@@ -448,7 +637,7 @@ static int parse_digits(const uint8_t **pp, BOOL allow_overflow)
     const uint8_t *p;
     uint64_t v;
     int c;
-    
+
     p = *pp;
     v = 0;
     for(;;) {
@@ -520,7 +709,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
         {
             int h, n, i;
             uint32_t c1;
-            
+
             if (*p == '{' && allow_utf16) {
                 p++;
                 c = 0;
@@ -550,7 +739,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
                     }
                     c = (c << 4) | h;
                 }
-                if (c >= 0xd800 && c < 0xdc00 &&
+                if (is_hi_surrogate(c) &&
                     allow_utf16 == 2 && p[0] == '\\' && p[1] == 'u') {
                     /* convert an escaped surrogate pair into a
                        unicode char */
@@ -561,9 +750,9 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
                             break;
                         c1 = (c1 << 4) | h;
                     }
-                    if (i == 4 && c1 >= 0xdc00 && c1 < 0xe000) {
+                    if (i == 4 && is_lo_surrogate(c1)) {
                         p += 6;
-                        c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+                        c = from_surrogate(c, c1);
                     }
                 }
             }
@@ -610,8 +799,16 @@ static BOOL is_unicode_char(int c)
             (c == '_'));
 }
 
-static int parse_unicode_property(REParseState *s, CharRange *cr,
-                                  const uint8_t **pp, BOOL is_inv)
+/* XXX: memory error test */
+static void seq_prop_cb(void *opaque, const uint32_t *seq, int seq_len)
+{
+    REStringList *sl = opaque;
+    re_string_add(sl, seq_len, seq);
+}
+
+static int parse_unicode_property(REParseState *s, REStringList *cr,
+                                  const uint8_t **pp, BOOL is_inv,
+                                  BOOL allow_sequence_prop)
 {
     const uint8_t *p;
     char name[64], value[64];
@@ -651,51 +848,76 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
     } else if (!strcmp(name, "Script_Extensions") || !strcmp(name, "scx")) {
         script_ext = TRUE;
     do_script:
-        cr_init(cr, s->opaque, lre_realloc);
-        ret = unicode_script(cr, value, script_ext);
+        re_string_list_init(s, cr);
+        ret = unicode_script(&cr->cr, value, script_ext);
         if (ret) {
-            cr_free(cr);
+            re_string_list_free(cr);
             if (ret == -2)
                 return re_parse_error(s, "unknown unicode script");
             else
                 goto out_of_memory;
         }
     } else if (!strcmp(name, "General_Category") || !strcmp(name, "gc")) {
-        cr_init(cr, s->opaque, lre_realloc);
-        ret = unicode_general_category(cr, value);
+        re_string_list_init(s, cr);
+        ret = unicode_general_category(&cr->cr, value);
         if (ret) {
-            cr_free(cr);
+            re_string_list_free(cr);
             if (ret == -2)
                 return re_parse_error(s, "unknown unicode general category");
             else
                 goto out_of_memory;
         }
     } else if (value[0] == '\0') {
-        cr_init(cr, s->opaque, lre_realloc);
-        ret = unicode_general_category(cr, name);
+        re_string_list_init(s, cr);
+        ret = unicode_general_category(&cr->cr, name);
         if (ret == -1) {
-            cr_free(cr);
+            re_string_list_free(cr);
             goto out_of_memory;
         }
         if (ret < 0) {
-            ret = unicode_prop(cr, name);
-            if (ret) {
-                cr_free(cr);
-                if (ret == -2)
-                    goto unknown_property_name;
-                else
-                    goto out_of_memory;
+            ret = unicode_prop(&cr->cr, name);
+            if (ret == -1) {
+                re_string_list_free(cr);
+                goto out_of_memory;
             }
         }
+        if (ret < 0 && !is_inv && allow_sequence_prop) {
+            CharRange cr_tmp;
+            cr_init(&cr_tmp, s->opaque, lre_realloc);
+            ret = unicode_sequence_prop(name, seq_prop_cb, cr, &cr_tmp);
+            cr_free(&cr_tmp);
+            if (ret == -1) {
+                re_string_list_free(cr);
+                goto out_of_memory;
+            }
+        }
+        if (ret < 0)
+            goto unknown_property_name;
     } else {
     unknown_property_name:
         return re_parse_error(s, "unknown unicode property name");
     }
 
+    /* the ordering of case folding and inversion  differs with
+       unicode_sets. 'unicode_sets' ordering is more consistent */
+    /* XXX: the spec seems incorrect, we do it as the other engines
+       seem to do it. */
+    if (s->ignore_case && s->unicode_sets) {
+        if (re_string_list_canonicalize(s, cr, s->is_unicode)) {
+            re_string_list_free(cr);
+            goto out_of_memory;
+        }
+    }
     if (is_inv) {
-        if (cr_invert(cr)) {
-            cr_free(cr);
-            return -1;
+        if (cr_invert(&cr->cr)) {
+            re_string_list_free(cr);
+            goto out_of_memory;
+        }
+    }
+    if (s->ignore_case && !s->unicode_sets) {
+        if (re_string_list_canonicalize(s, cr, s->is_unicode)) {
+            re_string_list_free(cr);
+            goto out_of_memory;
         }
     }
     *pp = p;
@@ -705,16 +927,67 @@ static int parse_unicode_property(REParseState *s, CharRange *cr,
 }
 #endif /* CONFIG_ALL_UNICODE */
 
+static int get_class_atom(REParseState *s, REStringList *cr,
+                          const uint8_t **pp, BOOL inclass);
+
+static int parse_class_string_disjunction(REParseState *s, REStringList *cr,
+                                          const uint8_t **pp)
+{
+    const uint8_t *p;
+    DynBuf str;
+    int c;
+    
+    p = *pp;
+    if (*p != '{')
+        return re_parse_error(s, "expecting '{' after \\q");
+
+    dbuf_init2(&str, s->opaque, lre_realloc);
+    re_string_list_init(s, cr);
+    
+    p++;
+    for(;;) {
+        str.size = 0;
+        while (*p != '}' && *p != '|') {
+            c = get_class_atom(s, NULL, &p, FALSE);
+            if (c < 0)
+                goto fail;
+            if (dbuf_put_u32(&str, c)) {
+                re_parse_out_of_memory(s);
+                goto fail;
+            }
+        }
+        if (re_string_add(cr, str.size / 4, (uint32_t *)str.buf)) {
+            re_parse_out_of_memory(s);
+            goto fail;
+        }
+        if (*p == '}')
+            break;
+        p++;
+    }
+    if (s->ignore_case) {
+        if (re_string_list_canonicalize(s, cr, TRUE))
+            goto fail;
+    }
+    p++; /* skip the '}' */
+    dbuf_free(&str);
+    *pp = p;
+    return 0;
+ fail:
+    dbuf_free(&str);
+    re_string_list_free(cr);
+    return -1;
+}
+
 /* return -1 if error otherwise the character or a class range
-   (CLASS_RANGE_BASE). In case of class range, 'cr' is
+   (CLASS_RANGE_BASE) if cr != NULL. In case of class range, 'cr' is
    initialized. Otherwise, it is ignored. */
-static int get_class_atom(REParseState *s, CharRange *cr,
+static int get_class_atom(REParseState *s, REStringList *cr,
                           const uint8_t **pp, BOOL inclass)
 {
     const uint8_t *p;
     uint32_t c;
     int ret;
-    
+
     p = *pp;
 
     c = *p;
@@ -743,6 +1016,8 @@ static int get_class_atom(REParseState *s, CharRange *cr,
         case 'W':
             c = CHAR_RANGE_W;
         class_range:
+            if (!cr)
+                goto default_escape;
             if (cr_init_char_range(s, cr, c))
                 return -1;
             c = CLASS_RANGE_BASE;
@@ -752,10 +1027,10 @@ static int get_class_atom(REParseState *s, CharRange *cr,
             if ((c >= 'a' && c <= 'z') ||
                 (c >= 'A' && c <= 'Z') ||
                 (((c >= '0' && c <= '9') || c == '_') &&
-                 inclass && !s->is_utf16)) {   /* Annex B.1.4 */
+                 inclass && !s->is_unicode)) {   /* Annex B.1.4 */
                 c &= 0x1f;
                 p++;
-            } else if (s->is_utf16) {
+            } else if (s->is_unicode) {
                 goto invalid_escape;
             } else {
                 /* otherwise return '\' and 'c' */
@@ -763,27 +1038,54 @@ static int get_class_atom(REParseState *s, CharRange *cr,
                 c = '\\';
             }
             break;
+        case '-':
+            if (!inclass && s->is_unicode)
+                goto invalid_escape;
+            break;
+        case '^':
+        case '$':
+        case '\\':
+        case '.':
+        case '*':
+        case '+':
+        case '?':
+        case '(':
+        case ')':
+        case '[':
+        case ']':
+        case '{':
+        case '}':
+        case '|':
+        case '/':
+            /* always valid to escape these characters */
+            break;
 #ifdef CONFIG_ALL_UNICODE
         case 'p':
         case 'P':
-            if (s->is_utf16) {
-                if (parse_unicode_property(s, cr, &p, (c == 'P')))
+            if (s->is_unicode && cr) {
+                if (parse_unicode_property(s, cr, &p, (c == 'P'), s->unicode_sets))
                     return -1;
                 c = CLASS_RANGE_BASE;
                 break;
             }
-            /* fall thru */
+            goto default_escape;
 #endif
+        case 'q':
+            if (s->unicode_sets && cr && inclass) {
+                if (parse_class_string_disjunction(s, cr, &p))
+                    return -1;
+                c = CLASS_RANGE_BASE;
+                break;
+            }
+            goto default_escape;
         default:
+        default_escape:
             p--;
-            ret = lre_parse_escape(&p, s->is_utf16 * 2);
+            ret = lre_parse_escape(&p, s->is_unicode * 2);
             if (ret >= 0) {
                 c = ret;
             } else {
-                if (ret == -2 && *p != '\0' && strchr("^$\\.*+?()[]{}|/", *p)) {
-                    /* always valid to escape these characters */
-                    goto normal_char;
-                } else if (s->is_utf16) {
+                if (s->is_unicode) {
                 invalid_escape:
                     return re_parse_error(s, "invalid escape sequence in regular expression");
                 } else {
@@ -800,12 +1102,54 @@ static int get_class_atom(REParseState *s, CharRange *cr,
             return re_parse_error(s, "unexpected end");
         }
         /* fall thru */
+        goto normal_char;
+
+    case '&':
+    case '!':
+    case '#':
+    case '$':
+    case '%':
+    case '*':
+    case '+':
+    case ',':
+    case '.':
+    case ':':
+    case ';':
+    case '<':
+    case '=':
+    case '>':
+    case '?':
+    case '@':
+    case '^':
+    case '`':
+    case '~':
+        if (s->unicode_sets && p[1] == c) {
+            /* forbidden double characters */
+            return re_parse_error(s, "invalid class set operation in regular expression");
+        }
+        goto normal_char;
+
+    case '(':
+    case ')':
+    case '[':
+    case ']':
+    case '{':
+    case '}':
+    case '/':
+    case '-':
+    case '|':
+        if (s->unicode_sets) {
+            /* invalid characters in unicode sets */
+            return re_parse_error(s, "invalid character in class in regular expression");
+        }
+        goto normal_char;
+
     default:
     normal_char:
         /* normal char */
         if (c >= 128) {
             c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
-            if ((unsigned)c > 0xffff && !s->is_utf16) {
+            if ((unsigned)c > 0xffff && !s->is_unicode) {
                 /* XXX: should handle non BMP-1 code points */
                 return re_parse_error(s, "malformed unicode char");
             }
@@ -822,13 +1166,11 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
 {
     int len, i;
     uint32_t high;
-    
+
     len = (unsigned)cr->len / 2;
     if (len >= 65535)
         return re_parse_error(s, "too many ranges");
     if (len == 0) {
-        /* not sure it can really happen. Emit a match that is always
-           false */
         re_emit_op_u32(s, REOP_char32, -1);
     } else {
         high = cr->points[cr->len - 1];
@@ -837,7 +1179,7 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
         if (high <= 0xffff) {
             /* can use 16 bit ranges with the conversion that 0xffff =
                infinity */
-            re_emit_op_u16(s, REOP_range, len);
+            re_emit_op_u16(s, s->ignore_case ? REOP_range_i : REOP_range, len);
             for(i = 0; i < cr->len; i += 2) {
                 dbuf_put_u16(&s->byte_code, cr->points[i]);
                 high = cr->points[i + 1] - 1;
@@ -846,7 +1188,7 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
                 dbuf_put_u16(&s->byte_code, high);
             }
         } else {
-            re_emit_op_u16(s, REOP_range32, len);
+            re_emit_op_u16(s, s->ignore_case ? REOP_range32_i : REOP_range32, len);
             for(i = 0; i < cr->len; i += 2) {
                 dbuf_put_u32(&s->byte_code, cr->points[i]);
                 dbuf_put_u32(&s->byte_code, cr->points[i + 1] - 1);
@@ -856,176 +1198,362 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
     return 0;
 }
 
-static int re_parse_char_class(REParseState *s, const uint8_t **pp)
+static int re_string_cmp_len(const void *a, const void *b, void *arg)
+{
+    REString *p1 = *(REString **)a;
+    REString *p2 = *(REString **)b;
+    return (p1->len < p2->len) - (p1->len > p2->len);
+}
+
+static void re_emit_char(REParseState *s, int c)
+{
+    if (c <= 0xffff)
+        re_emit_op_u16(s, s->ignore_case ? REOP_char_i : REOP_char, c);
+    else
+        re_emit_op_u32(s, s->ignore_case ? REOP_char32_i : REOP_char32, c);
+}
+
+static int re_emit_string_list(REParseState *s, const REStringList *sl)
+{
+    REString **tab, *p;
+    int i, j, split_pos, last_match_pos, n;
+    BOOL has_empty_string, is_last;
+    
+    //    re_string_list_dump("sl", sl);
+    if (sl->n_strings == 0) {
+        /* simple case: only characters */
+        if (re_emit_range(s, &sl->cr))
+            return -1;
+    } else {
+        /* at least one string list is present : match the longest ones first */
+        /* XXX: add a new op_switch opcode to compile as a trie */
+        tab = lre_realloc(s->opaque, NULL, sizeof(tab[0]) * sl->n_strings);
+        if (!tab) {
+            re_parse_out_of_memory(s);
+            return -1;
+        }
+        has_empty_string = FALSE;
+        n = 0;
+        for(i = 0; i < sl->hash_size; i++) {
+            for(p = sl->hash_table[i]; p != NULL; p = p->next) {
+                if (p->len == 0) {
+                    has_empty_string = TRUE;
+                } else {
+                    tab[n++] = p;
+                }
+            }
+        }
+        assert(n <= sl->n_strings);
+        
+        rqsort(tab, n, sizeof(tab[0]), re_string_cmp_len, NULL);
+
+        last_match_pos = -1;
+        for(i = 0; i < n; i++) {
+            p = tab[i];
+            is_last = !has_empty_string && sl->cr.len == 0 && i == (n - 1);
+            if (!is_last)
+                split_pos = re_emit_op_u32(s, REOP_split_next_first, 0);
+            else
+                split_pos = 0;
+            for(j = 0; j < p->len; j++) {
+                re_emit_char(s, p->buf[j]);
+            }
+            if (!is_last) {
+                last_match_pos = re_emit_op_u32(s, REOP_goto, last_match_pos);
+                put_u32(s->byte_code.buf + split_pos, s->byte_code.size - (split_pos + 4));
+            }
+        }
+
+        if (sl->cr.len != 0) {
+            /* char range */
+            is_last = !has_empty_string;
+            if (!is_last)
+                split_pos = re_emit_op_u32(s, REOP_split_next_first, 0);
+            else
+                split_pos = 0; /* not used */
+            if (re_emit_range(s, &sl->cr)) {
+                lre_realloc(s->opaque, tab, 0);
+                return -1;
+            }
+            if (!is_last)
+                put_u32(s->byte_code.buf + split_pos, s->byte_code.size - (split_pos + 4));
+        }
+
+        /* patch the 'goto match' */
+        while (last_match_pos != -1) {
+            int next_pos = get_u32(s->byte_code.buf + last_match_pos);
+            put_u32(s->byte_code.buf + last_match_pos, s->byte_code.size - (last_match_pos + 4));
+            last_match_pos = next_pos;
+        }
+        
+        lre_realloc(s->opaque, tab, 0);
+    }
+    return 0;
+}
+
+static int re_parse_nested_class(REParseState *s, REStringList *cr, const uint8_t **pp);
+
+static int re_parse_class_set_operand(REParseState *s, REStringList *cr, const uint8_t **pp)
+{
+    int c1;
+    const uint8_t *p = *pp;
+    
+    if (*p == '[') {
+        if (re_parse_nested_class(s, cr, pp))
+            return -1;
+    } else {
+        c1 = get_class_atom(s, cr, pp, TRUE);
+        if (c1 < 0)
+            return -1;
+        if (c1 < CLASS_RANGE_BASE) {
+            /* create a range with a single character */
+            re_string_list_init(s, cr);
+            if (s->ignore_case)
+                c1 = lre_canonicalize(c1, s->is_unicode);
+            if (cr_union_interval(&cr->cr, c1, c1)) {
+                re_string_list_free(cr);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+static int re_parse_nested_class(REParseState *s, REStringList *cr, const uint8_t **pp)
 {
     const uint8_t *p;
     uint32_t c1, c2;
-    CharRange cr_s, *cr = &cr_s;
-    CharRange cr1_s, *cr1 = &cr1_s;
-    BOOL invert;
-    
-    cr_init(cr, s->opaque, lre_realloc);
+    int ret;
+    REStringList cr1_s, *cr1 = &cr1_s;
+    BOOL invert, is_first;
+
+    if (lre_check_stack_overflow(s->opaque, 0))
+        return re_parse_error(s, "stack overflow");
+
+    re_string_list_init(s, cr);
     p = *pp;
     p++;    /* skip '[' */
+
     invert = FALSE;
     if (*p == '^') {
         p++;
         invert = TRUE;
     }
+    
+    /* handle unions */
+    is_first = TRUE;
     for(;;) {
         if (*p == ']')
             break;
-        c1 = get_class_atom(s, cr1, &p, TRUE);
-        if ((int)c1 < 0)
-            goto fail;
-        if (*p == '-' && p[1] != ']') {
-            const uint8_t *p0 = p + 1;
-            if (c1 >= CLASS_RANGE_BASE) {
-                if (s->is_utf16) {
-                    cr_free(cr1);
-                    goto invalid_class_range;
-                }
-                /* Annex B: match '-' character */
-                goto class_atom;
-            }
-            c2 = get_class_atom(s, cr1, &p0, TRUE);
-            if ((int)c2 < 0)
+        if (*p == '[' && s->unicode_sets) {
+            if (re_parse_nested_class(s, cr1, &p))
                 goto fail;
-            if (c2 >= CLASS_RANGE_BASE) {
-                cr_free(cr1);
-                if (s->is_utf16) {
-                    goto invalid_class_range;
-                }
-                /* Annex B: match '-' character */
-                goto class_atom;
-            }
-            p = p0;
-            if (c2 < c1) {
-            invalid_class_range:
-                re_parse_error(s, "invalid class range");
-                goto fail;
-            }
-            if (cr_union_interval(cr, c1, c2))
-                goto memory_error;
+            goto class_union;
         } else {
-        class_atom:
-            if (c1 >= CLASS_RANGE_BASE) {
-                int ret;
-                ret = cr_union1(cr, cr1->points, cr1->len);
-                cr_free(cr1);
-                if (ret)
-                    goto memory_error;
+            c1 = get_class_atom(s, cr1, &p, TRUE);
+            if ((int)c1 < 0)
+                goto fail;
+            if (*p == '-' && p[1] != ']') {
+                const uint8_t *p0 = p + 1;
+                if (p[1] == '-' && s->unicode_sets && is_first)
+                    goto class_atom; /* first character class followed by '--' */
+                if (c1 >= CLASS_RANGE_BASE) {
+                    if (s->is_unicode) {
+                        re_string_list_free(cr1);
+                        goto invalid_class_range;
+                    }
+                    /* Annex B: match '-' character */
+                    goto class_atom;
+                }
+                c2 = get_class_atom(s, cr1, &p0, TRUE);
+                if ((int)c2 < 0)
+                    goto fail;
+                if (c2 >= CLASS_RANGE_BASE) {
+                    re_string_list_free(cr1);
+                    if (s->is_unicode) {
+                        goto invalid_class_range;
+                    }
+                    /* Annex B: match '-' character */
+                    goto class_atom;
+                }
+                p = p0;
+                if (c2 < c1) {
+                invalid_class_range:
+                    re_parse_error(s, "invalid class range");
+                    goto fail;
+                }
+                if (s->ignore_case) {
+                    CharRange cr2_s, *cr2 = &cr2_s;
+                    cr_init(cr2, s->opaque, lre_realloc);
+                    if (cr_add_interval(cr2, c1, c2 + 1) ||
+                        cr_regexp_canonicalize(cr2, s->is_unicode) ||
+                        cr_op1(&cr->cr, cr2->points, cr2->len, CR_OP_UNION)) {
+                        cr_free(cr2);
+                        goto memory_error;
+                    }
+                    cr_free(cr2);
+                } else {
+                    if (cr_union_interval(&cr->cr, c1, c2))
+                        goto memory_error;
+                }
+                is_first = FALSE; /* union operation */
             } else {
-                if (cr_union_interval(cr, c1, c1))
-                    goto memory_error;
+            class_atom:
+                if (c1 >= CLASS_RANGE_BASE) {
+                class_union:
+                    ret = re_string_list_op(cr, cr1, CR_OP_UNION);
+                    re_string_list_free(cr1);
+                    if (ret)
+                        goto memory_error;
+                } else {
+                    if (s->ignore_case)
+                        c1 = lre_canonicalize(c1, s->is_unicode);
+                    if (cr_union_interval(&cr->cr, c1, c1))
+                        goto memory_error;
+                }
             }
         }
+        if (s->unicode_sets && is_first) {
+            if (*p == '&' && p[1] == '&' && p[2] != '&') {
+                /* handle '&&' */
+                for(;;) {
+                    if (*p == ']') {
+                        break;
+                    } else if (*p == '&' && p[1] == '&' && p[2] != '&') {
+                        p += 2;
+                    } else {
+                        goto invalid_operation;
+                    }
+                    if (re_parse_class_set_operand(s, cr1, &p))
+                        goto fail;
+                    ret = re_string_list_op(cr, cr1, CR_OP_INTER);
+                    re_string_list_free(cr1);
+                    if (ret)
+                        goto memory_error;
+                }
+            } else if (*p == '-' && p[1] == '-') {
+                /* handle '--' */
+                for(;;) {
+                    if (*p == ']') {
+                        break;
+                    } else if (*p == '-' && p[1] == '-') {
+                        p += 2;
+                    } else {
+                    invalid_operation:
+                        re_parse_error(s, "invalid operation in regular expression");
+                        goto fail;
+                    }
+                    if (re_parse_class_set_operand(s, cr1, &p))
+                        goto fail;
+                    ret = re_string_list_op(cr, cr1, CR_OP_SUB);
+                    re_string_list_free(cr1);
+                    if (ret)
+                        goto memory_error;
+                }
+            }
+        }
+        is_first = FALSE;
     }
-    if (s->ignore_case) {
-        if (cr_canonicalize(cr))
-            goto memory_error;
-    }
+
+    p++;    /* skip ']' */
+    *pp = p;
     if (invert) {
-        if (cr_invert(cr))
+        /* XXX: add may_contain_string syntax check to be fully
+           compliant. The test here accepts more input than the
+           spec. */
+        if (cr->n_strings != 0) {
+            re_parse_error(s, "negated character class with strings in regular expression debugger eval code");
+            goto fail;
+        }
+        if (cr_invert(&cr->cr))
             goto memory_error;
     }
-    if (re_emit_range(s, cr))
-        goto fail;
-    cr_free(cr);
-    p++;    /* skip ']' */
-    *pp = p;
     return 0;
  memory_error:
     re_parse_out_of_memory(s);
  fail:
-    cr_free(cr);
+    re_string_list_free(cr);
+    return -1;
+}
+
+static int re_parse_char_class(REParseState *s, const uint8_t **pp)
+{
+    REStringList cr_s, *cr = &cr_s;
+
+    if (re_parse_nested_class(s, cr, pp))
+        return -1;
+    if (re_emit_string_list(s, cr))
+        goto fail;
+    re_string_list_free(cr);
+    return 0;
+ fail:
+    re_string_list_free(cr);
     return -1;
 }
 
 /* Return:
-   1 if the opcodes in bc_buf[] always advance the character pointer.
-   0 if the character pointer may not be advanced.
-   -1 if the code may depend on side effects of its previous execution (backreference)
+   - true if the opcodes may not advance the char pointer
+   - false if the opcodes always advance the char pointer
 */
-static int re_check_advance(const uint8_t *bc_buf, int bc_buf_len)
+static BOOL re_need_check_advance(const uint8_t *bc_buf, int bc_buf_len)
 {
-    int pos, opcode, ret, len, i;
-    uint32_t val, last;
-    BOOL has_back_reference;
-    uint8_t capture_bitmap[CAPTURE_COUNT_MAX];
-    
-    ret = -2; /* not known yet */
+    int pos, opcode, len;
+    uint32_t val;
+    BOOL ret;
+
+    ret = TRUE;
     pos = 0;
-    has_back_reference = FALSE;
-    memset(capture_bitmap, 0, sizeof(capture_bitmap));
-    
     while (pos < bc_buf_len) {
         opcode = bc_buf[pos];
         len = reopcode_info[opcode].size;
         switch(opcode) {
         case REOP_range:
+        case REOP_range_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 4;
             goto simple_char;
         case REOP_range32:
+        case REOP_range32_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 8;
             goto simple_char;
         case REOP_char:
+        case REOP_char_i:
         case REOP_char32:
+        case REOP_char32_i:
         case REOP_dot:
         case REOP_any:
         simple_char:
-            if (ret == -2)
-                ret = 1;
+            ret = FALSE;
             break;
         case REOP_line_start:
+        case REOP_line_start_m:
         case REOP_line_end:
+        case REOP_line_end_m:
         case REOP_push_i32:
         case REOP_push_char_pos:
         case REOP_drop:
         case REOP_word_boundary:
+        case REOP_word_boundary_i:
         case REOP_not_word_boundary:
+        case REOP_not_word_boundary_i:
         case REOP_prev:
             /* no effect */
             break;
         case REOP_save_start:
         case REOP_save_end:
-            val = bc_buf[pos + 1];
-            capture_bitmap[val] |= 1;
-            break;
         case REOP_save_reset:
-            {
-                val = bc_buf[pos + 1];
-                last = bc_buf[pos + 2];
-                while (val < last)
-                    capture_bitmap[val++] |= 1;
-            }
-            break;
         case REOP_back_reference:
+        case REOP_back_reference_i:
         case REOP_backward_back_reference:
-            val = bc_buf[pos + 1];
-            capture_bitmap[val] |= 2;
-            has_back_reference = TRUE;
+        case REOP_backward_back_reference_i:
             break;
         default:
-            /* safe behvior: we cannot predict the outcome */
-            if (ret == -2)
-                ret = 0;
-            break;
+            /* safe behavior: we cannot predict the outcome */
+            return TRUE;
         }
         pos += len;
     }
-    if (has_back_reference) {
-        /* check if there is back reference which references a capture
-           made in the some code */
-        for(i = 0; i < CAPTURE_COUNT_MAX; i++) {
-            if (capture_bitmap[i] == 3)
-                return -1;
-        }
-    }
-    if (ret == -2)
-        ret = 0;
     return ret;
 }
 
@@ -1035,7 +1563,7 @@ static int re_is_simple_quantifier(const uint8_t *bc_buf, int bc_buf_len)
 {
     int pos, opcode, len, count;
     uint32_t val;
-    
+
     count = 0;
     pos = 0;
     while (pos < bc_buf_len) {
@@ -1043,24 +1571,32 @@ static int re_is_simple_quantifier(const uint8_t *bc_buf, int bc_buf_len)
         len = reopcode_info[opcode].size;
         switch(opcode) {
         case REOP_range:
+        case REOP_range_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 4;
             goto simple_char;
         case REOP_range32:
+        case REOP_range32_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 8;
             goto simple_char;
         case REOP_char:
+        case REOP_char_i:
         case REOP_char32:
+        case REOP_char32_i:
         case REOP_dot:
         case REOP_any:
         simple_char:
             count++;
             break;
         case REOP_line_start:
+        case REOP_line_start_m:
         case REOP_line_end:
+        case REOP_line_end_m:
         case REOP_word_boundary:
+        case REOP_word_boundary_i:
         case REOP_not_word_boundary:
+        case REOP_not_word_boundary_i:
             break;
         default:
             return -1;
@@ -1090,10 +1626,10 @@ static int re_parse_group_name(char *buf, int buf_size, const uint8_t **pp)
             break;
         } else if (c >= 128) {
             c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
-            if (c >= 0xD800 && c <= 0xDBFF) {
+            if (is_hi_surrogate(c)) {
                 d = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p1);
-                if (d >= 0xDC00 && d <= 0xDFFF) {
-                    c = 0x10000 + 0x400 * (c - 0xD800) + (d - 0xDC00);
+                if (is_lo_surrogate(d)) {
+                    c = from_surrogate(c, d);
                     p = p1;
                 }
             }
@@ -1200,10 +1736,11 @@ static int find_group_name(REParseState *s, const char *name)
     const char *p, *buf_end;
     size_t len, name_len;
     int capture_index;
-    
-    name_len = strlen(name);
+
     p = (char *)s->group_names.buf;
+    if (!p) return -1;
     buf_end = (char *)s->group_names.buf + s->group_names.size;
+    name_len = strlen(name);
     capture_index = 1;
     while (p < buf_end) {
         len = strlen(p);
@@ -1217,13 +1754,48 @@ static int find_group_name(REParseState *s, const char *name)
 
 static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir);
 
+static int re_parse_modifiers(REParseState *s, const uint8_t **pp)
+{
+    const uint8_t *p = *pp;
+    int mask = 0;
+    int val;
+
+    for(;;) {
+        if (*p == 'i') {
+            val = LRE_FLAG_IGNORECASE;
+        } else if (*p == 'm') {
+            val = LRE_FLAG_MULTILINE;
+        } else if (*p == 's') {
+            val = LRE_FLAG_DOTALL;
+        } else {
+            break;
+        }
+        if (mask & val)
+            return re_parse_error(s, "duplicate modifier: '%c'", *p);
+        mask |= val;
+        p++;
+    }
+    *pp = p;
+    return mask;
+}
+
+static BOOL update_modifier(BOOL val, int add_mask, int remove_mask,
+                            int mask)
+{
+    if (add_mask & mask)
+        val = TRUE;
+    if (remove_mask & mask)
+        val = FALSE;
+    return val;
+}
+
 static int re_parse_term(REParseState *s, BOOL is_backward_dir)
 {
     const uint8_t *p;
     int c, last_atom_start, quant_min, quant_max, last_capture_count;
     BOOL greedy, add_zero_advance_check, is_neg, is_backward_lookahead;
-    CharRange cr_s, *cr = &cr_s;
-    
+    REStringList cr_s, *cr = &cr_s;
+
     last_atom_start = -1;
     last_capture_count = 0;
     p = s->buf_ptr;
@@ -1231,11 +1803,11 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
     switch(c) {
     case '^':
         p++;
-        re_emit_op(s, REOP_line_start);
+        re_emit_op(s, s->multi_line ? REOP_line_start_m : REOP_line_start);
         break;
     case '$':
         p++;
-        re_emit_op(s, REOP_line_end);
+        re_emit_op(s, s->multi_line ? REOP_line_end_m : REOP_line_end);
         break;
     case '.':
         p++;
@@ -1248,7 +1820,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             re_emit_op(s, REOP_prev);
         break;
     case '{':
-        if (s->is_utf16) {
+        if (s->is_unicode) {
             return re_parse_error(s, "syntax error");
         } else if (!is_digit(p[1])) {
             /* Annex B: we accept '{' not followed by digits as a
@@ -1285,6 +1857,44 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 p = s->buf_ptr;
                 if (re_parse_expect(s, &p, ')'))
                     return -1;
+            } else if (p[2] == 'i' || p[2] == 'm' || p[2] == 's' || p[2] == '-') {
+                BOOL saved_ignore_case, saved_multi_line, saved_dotall;
+                int add_mask, remove_mask;
+                p += 2;
+                remove_mask = 0;
+                add_mask = re_parse_modifiers(s, &p);
+                if (add_mask < 0)
+                    return -1;
+                if (*p == '-') {
+                    p++;
+                    remove_mask = re_parse_modifiers(s, &p);
+                    if (remove_mask < 0)
+                        return -1;
+                }
+                if ((add_mask == 0 && remove_mask == 0) ||
+                    (add_mask & remove_mask) != 0) {
+                    return re_parse_error(s, "invalid modifiers");
+                }
+                if (re_parse_expect(s, &p, ':'))
+                    return -1;
+                saved_ignore_case = s->ignore_case;
+                saved_multi_line = s->multi_line;
+                saved_dotall = s->dotall;
+                s->ignore_case = update_modifier(s->ignore_case, add_mask, remove_mask, LRE_FLAG_IGNORECASE);
+                s->multi_line = update_modifier(s->multi_line, add_mask, remove_mask, LRE_FLAG_MULTILINE);
+                s->dotall = update_modifier(s->dotall, add_mask, remove_mask, LRE_FLAG_DOTALL);
+
+                last_atom_start = s->byte_code.size;
+                last_capture_count = s->capture_count;
+                s->buf_ptr = p;
+                if (re_parse_disjunction(s, is_backward_dir))
+                    return -1;
+                p = s->buf_ptr;
+                if (re_parse_expect(s, &p, ')'))
+                    return -1;
+                s->ignore_case = saved_ignore_case;
+                s->multi_line = saved_multi_line;
+                s->dotall = saved_dotall;
             } else if ((p[2] == '=' || p[2] == '!')) {
                 is_neg = (p[2] == '!');
                 is_backward_lookahead = FALSE;
@@ -1300,7 +1910,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             lookahead:
                 /* Annex B allows lookahead to be used as an atom for
                    the quantifiers */
-                if (!s->is_utf16 && !is_backward_lookahead)  {
+                if (!s->is_unicode && !is_backward_lookahead)  {
                     last_atom_start = s->byte_code.size;
                     last_capture_count = s->capture_count;
                 }
@@ -1346,15 +1956,15 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             capture_index = s->capture_count++;
             re_emit_op_u8(s, REOP_save_start + is_backward_dir,
                           capture_index);
-            
+
             s->buf_ptr = p;
             if (re_parse_disjunction(s, is_backward_dir))
                 return -1;
             p = s->buf_ptr;
-            
+
             re_emit_op_u8(s, REOP_save_start + 1 - is_backward_dir,
                           capture_index);
-            
+
             if (re_parse_expect(s, &p, ')'))
                 return -1;
         }
@@ -1363,20 +1973,24 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
         switch(p[1]) {
         case 'b':
         case 'B':
-            re_emit_op(s, REOP_word_boundary + (p[1] != 'b'));
+            if (p[1] != 'b') {
+                re_emit_op(s, s->ignore_case ? REOP_not_word_boundary_i : REOP_not_word_boundary);
+            } else {
+                re_emit_op(s, s->ignore_case ? REOP_word_boundary_i : REOP_word_boundary);
+            }
             p += 2;
             break;
         case 'k':
             {
                 const uint8_t *p1;
                 int dummy_res;
-                
+
                 p1 = p;
                 if (p1[2] != '<') {
                     /* annex B: we tolerate invalid group names in non
                        unicode mode if there is no named capture
                        definition */
-                    if (s->is_utf16 || re_has_named_captures(s))
+                    if (s->is_unicode || re_has_named_captures(s))
                         return re_parse_error(s, "expecting group name");
                     else
                         goto parse_class_atom;
@@ -1384,7 +1998,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 p1 += 3;
                 if (re_parse_group_name(s->u.tmp_buf, sizeof(s->u.tmp_buf),
                                         &p1)) {
-                    if (s->is_utf16 || re_has_named_captures(s))
+                    if (s->is_unicode || re_has_named_captures(s))
                         return re_parse_error(s, "invalid group name");
                     else
                         goto parse_class_atom;
@@ -1395,7 +2009,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                        after (inefficient, but hopefully not common */
                     c = re_parse_captures(s, &dummy_res, s->u.tmp_buf);
                     if (c < 0) {
-                        if (s->is_utf16 || re_has_named_captures(s))
+                        if (s->is_unicode || re_has_named_captures(s))
                             return re_parse_error(s, "group name not defined");
                         else
                             goto parse_class_atom;
@@ -1407,7 +2021,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
         case '0':
             p += 2;
             c = 0;
-            if (s->is_utf16) {
+            if (s->is_unicode) {
                 if (is_digit(*p)) {
                     return re_parse_error(s, "invalid decimal escape in regular expression");
                 }
@@ -1423,13 +2037,13 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             goto normal_char;
         case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8':
-        case '9': 
+        case '9':
             {
                 const uint8_t *q = ++p;
-                
+
                 c = parse_digits(&p, FALSE);
                 if (c < 0 || (c >= s->capture_count && c >= re_count_captures(s))) {
-                    if (!s->is_utf16) {
+                    if (!s->is_unicode) {
                         /* Annex B.1.4: accept legacy octal */
                         p = q;
                         if (*p <= '7') {
@@ -1452,7 +2066,8 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             emit_back_reference:
                 last_atom_start = s->byte_code.size;
                 last_capture_count = s->capture_count;
-                re_emit_op_u8(s, REOP_back_reference + is_backward_dir, c);
+                
+                re_emit_op_u8(s, REOP_back_reference + 2 * is_backward_dir + s->ignore_case, c);
             }
             break;
         default:
@@ -1471,7 +2086,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
         break;
     case ']':
     case '}':
-        if (s->is_utf16)
+        if (s->is_unicode)
             return re_parse_error(s, "syntax error");
         goto parse_class_atom;
     default:
@@ -1486,18 +2101,14 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             re_emit_op(s, REOP_prev);
         if (c >= CLASS_RANGE_BASE) {
             int ret;
-            /* Note: canonicalization is not needed */
-            ret = re_emit_range(s, cr);
-            cr_free(cr);
+            ret = re_emit_string_list(s, cr);
+            re_string_list_free(cr);
             if (ret)
                 return -1;
         } else {
             if (s->ignore_case)
-                c = lre_canonicalize(c, s->is_utf16);
-            if (c <= 0xffff)
-                re_emit_op_u16(s, REOP_char, c);
-            else
-                re_emit_op_u32(s, REOP_char32, c);
+                c = lre_canonicalize(c, s->is_unicode);
+            re_emit_char(s, c);
         }
         if (is_backward_dir)
             re_emit_op(s, REOP_prev);
@@ -1529,7 +2140,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                 /* As an extension (see ES6 annex B), we accept '{' not
                    followed by digits as a normal atom */
                 if (!is_digit(p[1])) {
-                    if (s->is_utf16)
+                    if (s->is_unicode)
                         goto invalid_quant_count;
                     break;
                 }
@@ -1548,7 +2159,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                         quant_max = INT32_MAX; /* infinity */
                     }
                 }
-                if (*p != '}' && !s->is_utf16) {
+                if (*p != '}' && !s->is_unicode) {
                     /* Annex B: normal atom if invalid '{' syntax */
                     p = p1;
                     break;
@@ -1567,7 +2178,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             }
             if (greedy) {
                 int len, pos;
-                
+
                 if (quant_max > 0) {
                     /* specific optimization for simple quantifiers */
                     if (dbuf_error(&s->byte_code))
@@ -1576,7 +2187,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                                                  s->byte_code.size - last_atom_start);
                     if (len > 0) {
                         re_emit_op(s, REOP_match);
-                        
+
                         if (dbuf_insert(&s->byte_code, last_atom_start, 17))
                             goto out_of_memory;
                         pos = last_atom_start;
@@ -1593,15 +2204,17 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                         goto done;
                     }
                 }
-                
+
                 if (dbuf_error(&s->byte_code))
                     goto out_of_memory;
-                add_zero_advance_check = (re_check_advance(s->byte_code.buf + last_atom_start,
-                                                           s->byte_code.size - last_atom_start) == 0);
-            } else {
-                add_zero_advance_check = FALSE;
             }
-            
+            /* the spec tells that if there is no advance when
+               running the atom after the first quant_min times,
+               then there is no match. We remove this test when we
+               are sure the atom always advances the position. */
+            add_zero_advance_check = re_need_check_advance(s->byte_code.buf + last_atom_start,
+                                                           s->byte_code.size - last_atom_start);
+
             {
                 int len, pos;
                 len = s->byte_code.size - last_atom_start;
@@ -1617,38 +2230,34 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     }
                     if (quant_max == 0) {
                         s->byte_code.size = last_atom_start;
-                    } else if (quant_max == 1) {
-                        if (dbuf_insert(&s->byte_code, last_atom_start, 5))
-                            goto out_of_memory;
-                        s->byte_code.buf[last_atom_start] = REOP_split_goto_first +
-                            greedy;
-                        put_u32(s->byte_code.buf + last_atom_start + 1, len);
-                    } else if (quant_max == INT32_MAX) {
+                    } else if (quant_max == 1 || quant_max == INT32_MAX) {
+                        BOOL has_goto = (quant_max == INT32_MAX);
                         if (dbuf_insert(&s->byte_code, last_atom_start, 5 + add_zero_advance_check))
                             goto out_of_memory;
                         s->byte_code.buf[last_atom_start] = REOP_split_goto_first +
                             greedy;
                         put_u32(s->byte_code.buf + last_atom_start + 1,
-                                len + 5 + add_zero_advance_check);
+                                len + 5 * has_goto + add_zero_advance_check * 2);
                         if (add_zero_advance_check) {
-                            /* avoid infinite loop by stoping the
-                               recursion if no advance was made in the
-                               atom (only works if the atom has no
-                               side effect) */
                             s->byte_code.buf[last_atom_start + 1 + 4] = REOP_push_char_pos;
-                            re_emit_goto(s, REOP_bne_char_pos, last_atom_start); 
-                        } else {
-                            re_emit_goto(s, REOP_goto, last_atom_start);
+                            re_emit_op(s, REOP_check_advance);
                         }
+                        if (has_goto)
+                            re_emit_goto(s, REOP_goto, last_atom_start);
                     } else {
-                        if (dbuf_insert(&s->byte_code, last_atom_start, 10))
+                        if (dbuf_insert(&s->byte_code, last_atom_start, 10 + add_zero_advance_check))
                             goto out_of_memory;
                         pos = last_atom_start;
                         s->byte_code.buf[pos++] = REOP_push_i32;
                         put_u32(s->byte_code.buf + pos, quant_max);
                         pos += 4;
                         s->byte_code.buf[pos++] = REOP_split_goto_first + greedy;
-                        put_u32(s->byte_code.buf + pos, len + 5);
+                        put_u32(s->byte_code.buf + pos, len + 5 + add_zero_advance_check * 2);
+                        pos += 4;
+                        if (add_zero_advance_check) {
+                            s->byte_code.buf[pos++] = REOP_push_char_pos;
+                            re_emit_op(s, REOP_check_advance);
+                        }
                         re_emit_goto(s, REOP_loop, last_atom_start + 5);
                         re_emit_op(s, REOP_drop);
                     }
@@ -1672,22 +2281,25 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                     if (quant_max == INT32_MAX) {
                         pos = s->byte_code.size;
                         re_emit_op_u32(s, REOP_split_goto_first + greedy,
-                                       len + 5 + add_zero_advance_check);
+                                       len + 5 + add_zero_advance_check * 2);
                         if (add_zero_advance_check)
                             re_emit_op(s, REOP_push_char_pos);
                         /* copy the atom */
                         dbuf_put_self(&s->byte_code, last_atom_start, len);
                         if (add_zero_advance_check)
-                            re_emit_goto(s, REOP_bne_char_pos, pos);
-                        else
-                            re_emit_goto(s, REOP_goto, pos);
+                            re_emit_op(s, REOP_check_advance);
+                        re_emit_goto(s, REOP_goto, pos);
                     } else if (quant_max > quant_min) {
                         re_emit_op_u32(s, REOP_push_i32, quant_max - quant_min);
                         pos = s->byte_code.size;
-                        re_emit_op_u32(s, REOP_split_goto_first + greedy, len + 5);
+                        re_emit_op_u32(s, REOP_split_goto_first + greedy,
+                                       len + 5 + add_zero_advance_check * 2);
+                        if (add_zero_advance_check)
+                            re_emit_op(s, REOP_push_char_pos);
                         /* copy the atom */
                         dbuf_put_self(&s->byte_code, last_atom_start, len);
-                        
+                        if (add_zero_advance_check)
+                            re_emit_op(s, REOP_check_advance);
                         re_emit_goto(s, REOP_loop, pos);
                         re_emit_op(s, REOP_drop);
                     }
@@ -1739,14 +2351,14 @@ static int re_parse_alternative(REParseState *s, BOOL is_backward_dir)
     }
     return 0;
 }
-    
+
 static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
 {
     int start, len, pos;
 
     if (lre_check_stack_overflow(s->opaque, 0))
         return re_parse_error(s, "stack overflow");
-    
+
     start = s->byte_code.size;
     if (re_parse_alternative(s, is_backward_dir))
         return -1;
@@ -1766,7 +2378,7 @@ static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
 
         if (re_parse_alternative(s, is_backward_dir))
             return -1;
-        
+
         /* patch the goto */
         len = s->byte_code.size - (pos + 4);
         put_u32(s->byte_code.buf + pos, len);
@@ -1779,7 +2391,7 @@ static int compute_stack_size(const uint8_t *bc_buf, int bc_buf_len)
 {
     int stack_size, stack_size_max, pos, opcode, len;
     uint32_t val;
-    
+
     stack_size = 0;
     stack_size_max = 0;
     bc_buf += RE_HEADER_LEN;
@@ -1801,15 +2413,17 @@ static int compute_stack_size(const uint8_t *bc_buf, int bc_buf_len)
             }
             break;
         case REOP_drop:
-        case REOP_bne_char_pos:
+        case REOP_check_advance:
             assert(stack_size > 0);
             stack_size--;
             break;
         case REOP_range:
+        case REOP_range_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 4;
             break;
         case REOP_range32:
+        case REOP_range32_i:
             val = get_u16(bc_buf + pos + 1);
             len += val * 8;
             break;
@@ -1830,29 +2444,31 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     REParseState s_s, *s = &s_s;
     int stack_size;
     BOOL is_sticky;
-    
+
     memset(s, 0, sizeof(*s));
     s->opaque = opaque;
     s->buf_ptr = (const uint8_t *)buf;
     s->buf_end = s->buf_ptr + buf_len;
     s->buf_start = s->buf_ptr;
     s->re_flags = re_flags;
-    s->is_utf16 = ((re_flags & LRE_FLAG_UTF16) != 0);
+    s->is_unicode = ((re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0);
     is_sticky = ((re_flags & LRE_FLAG_STICKY) != 0);
     s->ignore_case = ((re_flags & LRE_FLAG_IGNORECASE) != 0);
+    s->multi_line = ((re_flags & LRE_FLAG_MULTILINE) != 0);
     s->dotall = ((re_flags & LRE_FLAG_DOTALL) != 0);
+    s->unicode_sets = ((re_flags & LRE_FLAG_UNICODE_SETS) != 0);
     s->capture_count = 1;
     s->total_capture_count = -1;
     s->has_named_captures = -1;
-    
+
     dbuf_init2(&s->byte_code, opaque, lre_realloc);
     dbuf_init2(&s->group_names, opaque, lre_realloc);
 
-    dbuf_putc(&s->byte_code, re_flags); /* first element is the flags */
+    dbuf_put_u16(&s->byte_code, re_flags); /* first element is the flags */
     dbuf_putc(&s->byte_code, 0); /* second element is the number of captures */
     dbuf_putc(&s->byte_code, 0); /* stack size */
     dbuf_put_u32(&s->byte_code, 0); /* bytecode length */
-    
+
     if (!is_sticky) {
         /* iterate thru all positions (about the same as .*?( ... ) )
            .  We do it without an explicit loop so that lock step
@@ -1874,7 +2490,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     }
 
     re_emit_op_u8(s, REOP_save_end, 0);
-    
+
     re_emit_op(s, REOP_match);
 
     if (*s->buf_ptr != '\0') {
@@ -1886,28 +2502,30 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
         re_parse_out_of_memory(s);
         goto error;
     }
-    
+
     stack_size = compute_stack_size(s->byte_code.buf, s->byte_code.size);
     if (stack_size < 0) {
         re_parse_error(s, "too many imbricated quantifiers");
         goto error;
     }
-    
+
     s->byte_code.buf[RE_HEADER_CAPTURE_COUNT] = s->capture_count;
     s->byte_code.buf[RE_HEADER_STACK_SIZE] = stack_size;
-    put_u32(s->byte_code.buf + 3, s->byte_code.size - RE_HEADER_LEN);
+    put_u32(s->byte_code.buf + RE_HEADER_BYTECODE_LEN,
+            s->byte_code.size - RE_HEADER_LEN);
 
     /* add the named groups if needed */
     if (s->group_names.size > (s->capture_count - 1)) {
         dbuf_put(&s->byte_code, s->group_names.buf, s->group_names.size);
-        s->byte_code.buf[RE_HEADER_FLAGS] |= LRE_FLAG_NAMED_GROUPS;
+        put_u16(s->byte_code.buf + RE_HEADER_FLAGS,
+                lre_get_flags(s->byte_code.buf) | LRE_FLAG_NAMED_GROUPS);
     }
     dbuf_free(&s->group_names);
-    
+
 #ifdef DUMP_REOP
     lre_dump_bytecode(s->byte_code.buf, s->byte_code.size);
 #endif
-    
+
     error_msg[0] = '\0';
     *plen = s->byte_code.size;
     return s->byte_code.buf;
@@ -1926,93 +2544,86 @@ static BOOL is_word_char(uint32_t c)
             (c == '_'));
 }
 
-#define GET_CHAR(c, cptr, cbuf_end)                                     \
+#define GET_CHAR(c, cptr, cbuf_end, cbuf_type)                          \
     do {                                                                \
         if (cbuf_type == 0) {                                           \
             c = *cptr++;                                                \
         } else {                                                        \
-            uint32_t __c1;                                              \
-            c = *(uint16_t *)cptr;                                      \
-            cptr += 2;                                                  \
-            if (c >= 0xd800 && c < 0xdc00 &&                            \
-                cbuf_type == 2 && cptr < cbuf_end) {                    \
-                __c1 = *(uint16_t *)cptr;                               \
-                if (__c1 >= 0xdc00 && __c1 < 0xe000) {                  \
-                    c = (((c & 0x3ff) << 10) | (__c1 & 0x3ff)) + 0x10000; \
-                    cptr += 2;                                          \
+            const uint16_t *_p = (const uint16_t *)cptr;                \
+            const uint16_t *_end = (const uint16_t *)cbuf_end;          \
+            c = *_p++;                                                  \
+            if (is_hi_surrogate(c) && cbuf_type == 2) {                 \
+                if (_p < _end && is_lo_surrogate(*_p)) {                \
+                    c = from_surrogate(c, *_p++);                       \
                 }                                                       \
             }                                                           \
+            cptr = (const void *)_p;                                    \
         }                                                               \
     } while (0)
 
-#define PEEK_CHAR(c, cptr, cbuf_end)             \
-    do {                                         \
-        if (cbuf_type == 0) {                    \
-            c = cptr[0];                         \
-        } else {                                 \
-            uint32_t __c1;                                              \
-            c = ((uint16_t *)cptr)[0];                                  \
-            if (c >= 0xd800 && c < 0xdc00 &&                            \
-                cbuf_type == 2 && (cptr + 2) < cbuf_end) {              \
-                __c1 = ((uint16_t *)cptr)[1];                           \
-                if (__c1 >= 0xdc00 && __c1 < 0xe000) {                  \
-                    c = (((c & 0x3ff) << 10) | (__c1 & 0x3ff)) + 0x10000; \
+#define PEEK_CHAR(c, cptr, cbuf_end, cbuf_type)                         \
+    do {                                                                \
+        if (cbuf_type == 0) {                                           \
+            c = cptr[0];                                                \
+        } else {                                                        \
+            const uint16_t *_p = (const uint16_t *)cptr;                \
+            const uint16_t *_end = (const uint16_t *)cbuf_end;          \
+            c = *_p++;                                                  \
+            if (is_hi_surrogate(c) && cbuf_type == 2) {                 \
+                if (_p < _end && is_lo_surrogate(*_p)) {                \
+                    c = from_surrogate(c, *_p);                         \
                 }                                                       \
             }                                                           \
-        }                                        \
+        }                                                               \
     } while (0)
 
-#define PEEK_PREV_CHAR(c, cptr, cbuf_start)                 \
-    do {                                         \
-        if (cbuf_type == 0) {                    \
-            c = cptr[-1];                        \
-        } else {                                 \
-            uint32_t __c1;                                              \
-            c = ((uint16_t *)cptr)[-1];                                 \
-            if (c >= 0xdc00 && c < 0xe000 &&                            \
-                cbuf_type == 2 && (cptr - 4) >= cbuf_start) {              \
-                __c1 = ((uint16_t *)cptr)[-2];                          \
-                if (__c1 >= 0xd800 && __c1 < 0xdc00 ) {                 \
-                    c = (((__c1 & 0x3ff) << 10) | (c & 0x3ff)) + 0x10000; \
+#define PEEK_PREV_CHAR(c, cptr, cbuf_start, cbuf_type)                  \
+    do {                                                                \
+        if (cbuf_type == 0) {                                           \
+            c = cptr[-1];                                               \
+        } else {                                                        \
+            const uint16_t *_p = (const uint16_t *)cptr - 1;            \
+            const uint16_t *_start = (const uint16_t *)cbuf_start;      \
+            c = *_p;                                                    \
+            if (is_lo_surrogate(c) && cbuf_type == 2) {                 \
+                if (_p > _start && is_hi_surrogate(_p[-1])) {           \
+                    c = from_surrogate(*--_p, c);                       \
                 }                                                       \
             }                                                           \
         }                                                               \
     } while (0)
 
-#define GET_PREV_CHAR(c, cptr, cbuf_start)       \
-    do {                                         \
-        if (cbuf_type == 0) {                    \
-            cptr--;                              \
-            c = cptr[0];                         \
-        } else {                                 \
-            uint32_t __c1;                                              \
-            cptr -= 2;                                                  \
-            c = ((uint16_t *)cptr)[0];                                 \
-            if (c >= 0xdc00 && c < 0xe000 &&                            \
-                cbuf_type == 2 && cptr > cbuf_start) {                  \
-                __c1 = ((uint16_t *)cptr)[-1];                          \
-                if (__c1 >= 0xd800 && __c1 < 0xdc00 ) {                 \
-                    cptr -= 2;                                          \
-                    c = (((__c1 & 0x3ff) << 10) | (c & 0x3ff)) + 0x10000; \
+#define GET_PREV_CHAR(c, cptr, cbuf_start, cbuf_type)                   \
+    do {                                                                \
+        if (cbuf_type == 0) {                                           \
+            cptr--;                                                     \
+            c = cptr[0];                                                \
+        } else {                                                        \
+            const uint16_t *_p = (const uint16_t *)cptr - 1;            \
+            const uint16_t *_start = (const uint16_t *)cbuf_start;      \
+            c = *_p;                                                    \
+            if (is_lo_surrogate(c) && cbuf_type == 2) {                 \
+                if (_p > _start && is_hi_surrogate(_p[-1])) {           \
+                    c = from_surrogate(*--_p, c);                       \
                 }                                                       \
             }                                                           \
+            cptr = (const void *)_p;                                    \
         }                                                               \
     } while (0)
 
-#define PREV_CHAR(cptr, cbuf_start)       \
-    do {                                  \
-        if (cbuf_type == 0) {             \
-            cptr--;                       \
-        } else {                          \
-            cptr -= 2;                          \
-            if (cbuf_type == 2) {                                       \
-                c = ((uint16_t *)cptr)[0];                              \
-                if (c >= 0xdc00 && c < 0xe000 && cptr > cbuf_start) {   \
-                    c = ((uint16_t *)cptr)[-1];                         \
-                    if (c >= 0xd800 && c < 0xdc00)                      \
-                        cptr -= 2;                                      \
+#define PREV_CHAR(cptr, cbuf_start, cbuf_type)                          \
+    do {                                                                \
+        if (cbuf_type == 0) {                                           \
+            cptr--;                                                     \
+        } else {                                                        \
+            const uint16_t *_p = (const uint16_t *)cptr - 1;            \
+            const uint16_t *_start = (const uint16_t *)cbuf_start;      \
+            if (is_lo_surrogate(*_p) && cbuf_type == 2) {               \
+                if (_p > _start && is_hi_surrogate(_p[-1])) {           \
+                    --_p;                                               \
                 }                                                       \
             }                                                           \
+            cptr = (const void *)_p;                                    \
         }                                                               \
     } while (0)
 
@@ -2038,12 +2649,11 @@ typedef struct {
     const uint8_t *cbuf;
     const uint8_t *cbuf_end;
     /* 0 = 8 bit chars, 1 = 16 bit chars, 2 = 16 bit chars, UTF-16 */
-    int cbuf_type; 
+    int cbuf_type;
     int capture_count;
     int stack_size_max;
-    BOOL multi_line;
-    BOOL ignore_case;
-    BOOL is_utf16;
+    BOOL is_unicode;
+    int interrupt_counter;
     void *opaque; /* used for stack overflow check */
 
     size_t state_size;
@@ -2090,7 +2700,17 @@ static int push_state(REExecContext *s,
     return 0;
 }
 
-/* return 1 if match, 0 if not match or -1 if error. */
+static int lre_poll_timeout(REExecContext *s)
+{
+    if (unlikely(--s->interrupt_counter <= 0)) {
+        s->interrupt_counter = INTERRUPT_COUNTER_INIT;
+        if (lre_check_timeout(s->opaque))
+            return LRE_RET_TIMEOUT;
+    }
+    return 0;
+}
+
+/* return 1 if match, 0 if not match or < 0 if error. */
 static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                                    StackInt *stack, int stack_len,
                                    const uint8_t *pc, const uint8_t *cptr,
@@ -2100,7 +2720,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
     int cbuf_type;
     uint32_t val, c;
     const uint8_t *cbuf_end;
-    
+
     cbuf_type = s->cbuf_type;
     cbuf_end = s->cbuf_end;
 
@@ -2121,6 +2741,8 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 ret = 0;
             recurse:
                 for(;;) {
+                    if (lre_poll_timeout(s))
+                        return LRE_RET_TIMEOUT;
                     if (s->state_stack_len == 0)
                         return ret;
                     rs = (REExecState *)(s->state_stack +
@@ -2152,7 +2774,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                             /* go backward */
                             char_count = get_u32(pc + 12);
                             for(i = 0; i < char_count; i++) {
-                                PREV_CHAR(cptr, s->cbuf);
+                                PREV_CHAR(cptr, s->cbuf, cbuf_type);
                             }
                             pc = (pc + 16) + (int)get_u32(pc);
                             rs->cptr = cptr;
@@ -2178,18 +2800,20 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             }
             break;
         case REOP_char32:
+        case REOP_char32_i:
             val = get_u32(pc);
             pc += 4;
             goto test_char;
         case REOP_char:
+        case REOP_char_i:
             val = get_u16(pc);
             pc += 2;
         test_char:
             if (cptr >= cbuf_end)
                 goto no_match;
-            GET_CHAR(c, cptr, cbuf_end);
-            if (s->ignore_case) {
-                c = lre_canonicalize(c, s->is_utf16);
+            GET_CHAR(c, cptr, cbuf_end, cbuf_type);
+            if (opcode == REOP_char_i || opcode == REOP_char32_i) {
+                c = lre_canonicalize(c, s->is_unicode);
             }
             if (val != c)
                 goto no_match;
@@ -2198,7 +2822,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
         case REOP_split_next_first:
             {
                 const uint8_t *pc1;
-                
+
                 val = get_u32(pc);
                 pc += 4;
                 if (opcode == REOP_split_next_first) {
@@ -2210,7 +2834,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 ret = push_state(s, capture, stack, stack_len,
                                  pc1, cptr, RE_EXEC_STATE_SPLIT, 0);
                 if (ret < 0)
-                    return -1;
+                    return LRE_RET_MEMORY_ERROR;
                 break;
             }
         case REOP_lookahead:
@@ -2222,42 +2846,46 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                              RE_EXEC_STATE_LOOKAHEAD + opcode - REOP_lookahead,
                              0);
             if (ret < 0)
-                return -1;
+                return LRE_RET_MEMORY_ERROR;
             break;
-            
+
         case REOP_goto:
             val = get_u32(pc);
             pc += 4 + (int)val;
+            if (lre_poll_timeout(s))
+                return LRE_RET_TIMEOUT;
             break;
         case REOP_line_start:
+        case REOP_line_start_m:
             if (cptr == s->cbuf)
                 break;
-            if (!s->multi_line)
+            if (opcode == REOP_line_start)
                 goto no_match;
-            PEEK_PREV_CHAR(c, cptr, s->cbuf);
+            PEEK_PREV_CHAR(c, cptr, s->cbuf, cbuf_type);
             if (!is_line_terminator(c))
                 goto no_match;
             break;
         case REOP_line_end:
+        case REOP_line_end_m:
             if (cptr == cbuf_end)
                 break;
-            if (!s->multi_line)
+            if (opcode == REOP_line_end)
                 goto no_match;
-            PEEK_CHAR(c, cptr, cbuf_end);
+            PEEK_CHAR(c, cptr, cbuf_end, cbuf_type);
             if (!is_line_terminator(c))
                 goto no_match;
             break;
         case REOP_dot:
             if (cptr == cbuf_end)
                 goto no_match;
-            GET_CHAR(c, cptr, cbuf_end);
+            GET_CHAR(c, cptr, cbuf_end, cbuf_type);
             if (is_line_terminator(c))
                 goto no_match;
             break;
         case REOP_any:
             if (cptr == cbuf_end)
                 goto no_match;
-            GET_CHAR(c, cptr, cbuf_end);
+            GET_CHAR(c, cptr, cbuf_end, cbuf_type);
             break;
         case REOP_save_start:
         case REOP_save_end:
@@ -2292,45 +2920,55 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             pc += 4;
             if (--stack[stack_len - 1] != 0) {
                 pc += (int)val;
+                if (lre_poll_timeout(s))
+                    return LRE_RET_TIMEOUT;
             }
             break;
         case REOP_push_char_pos:
             stack[stack_len++] = (uintptr_t)cptr;
             break;
-        case REOP_bne_char_pos:
-            val = get_u32(pc);
-            pc += 4;
-            if (stack[--stack_len] != (uintptr_t)cptr)
-                pc += (int)val;
+        case REOP_check_advance:
+            if (stack[--stack_len] == (uintptr_t)cptr)
+                goto no_match;
             break;
         case REOP_word_boundary:
+        case REOP_word_boundary_i:
         case REOP_not_word_boundary:
+        case REOP_not_word_boundary_i:
             {
                 BOOL v1, v2;
+                int ignore_case = (opcode == REOP_word_boundary_i || opcode == REOP_not_word_boundary_i);
+                BOOL is_boundary = (opcode == REOP_word_boundary || opcode == REOP_word_boundary_i);
                 /* char before */
                 if (cptr == s->cbuf) {
                     v1 = FALSE;
                 } else {
-                    PEEK_PREV_CHAR(c, cptr, s->cbuf);
+                    PEEK_PREV_CHAR(c, cptr, s->cbuf, cbuf_type);
+                    if (ignore_case)
+                        c = lre_canonicalize(c, s->is_unicode);
                     v1 = is_word_char(c);
                 }
                 /* current char */
                 if (cptr >= cbuf_end) {
                     v2 = FALSE;
                 } else {
-                    PEEK_CHAR(c, cptr, cbuf_end);
+                    PEEK_CHAR(c, cptr, cbuf_end, cbuf_type);
+                    if (ignore_case)
+                        c = lre_canonicalize(c, s->is_unicode);
                     v2 = is_word_char(c);
                 }
-                if (v1 ^ v2 ^ (REOP_not_word_boundary - opcode))
+                if (v1 ^ v2 ^ is_boundary)
                     goto no_match;
             }
             break;
         case REOP_back_reference:
+        case REOP_back_reference_i:
         case REOP_backward_back_reference:
+        case REOP_backward_back_reference_i:
             {
                 const uint8_t *cptr1, *cptr1_end, *cptr1_start;
                 uint32_t c1, c2;
-                
+
                 val = *pc++;
                 if (val >= s->capture_count)
                     goto no_match;
@@ -2338,16 +2976,17 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 cptr1_end = capture[2 * val + 1];
                 if (!cptr1_start || !cptr1_end)
                     break;
-                if (opcode == REOP_back_reference) {
+                if (opcode == REOP_back_reference ||
+                    opcode == REOP_back_reference_i) {
                     cptr1 = cptr1_start;
                     while (cptr1 < cptr1_end) {
                         if (cptr >= cbuf_end)
                             goto no_match;
-                        GET_CHAR(c1, cptr1, cptr1_end);
-                        GET_CHAR(c2, cptr, cbuf_end);
-                        if (s->ignore_case) {
-                            c1 = lre_canonicalize(c1, s->is_utf16);
-                            c2 = lre_canonicalize(c2, s->is_utf16);
+                        GET_CHAR(c1, cptr1, cptr1_end, cbuf_type);
+                        GET_CHAR(c2, cptr, cbuf_end, cbuf_type);
+                        if (opcode == REOP_back_reference_i) {
+                            c1 = lre_canonicalize(c1, s->is_unicode);
+                            c2 = lre_canonicalize(c2, s->is_unicode);
                         }
                         if (c1 != c2)
                             goto no_match;
@@ -2357,11 +2996,11 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                     while (cptr1 > cptr1_start) {
                         if (cptr == s->cbuf)
                             goto no_match;
-                        GET_PREV_CHAR(c1, cptr1, cptr1_start);
-                        GET_PREV_CHAR(c2, cptr, s->cbuf);
-                        if (s->ignore_case) {
-                            c1 = lre_canonicalize(c1, s->is_utf16);
-                            c2 = lre_canonicalize(c2, s->is_utf16);
+                        GET_PREV_CHAR(c1, cptr1, cptr1_start, cbuf_type);
+                        GET_PREV_CHAR(c2, cptr, s->cbuf, cbuf_type);
+                        if (opcode == REOP_backward_back_reference_i) {
+                            c1 = lre_canonicalize(c1, s->is_unicode);
+                            c2 = lre_canonicalize(c2, s->is_unicode);
                         }
                         if (c1 != c2)
                             goto no_match;
@@ -2370,17 +3009,18 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             }
             break;
         case REOP_range:
+        case REOP_range_i:
             {
                 int n;
                 uint32_t low, high, idx_min, idx_max, idx;
-                
+
                 n = get_u16(pc); /* n must be >= 1 */
                 pc += 2;
                 if (cptr >= cbuf_end)
                     goto no_match;
-                GET_CHAR(c, cptr, cbuf_end);
-                if (s->ignore_case) {
-                    c = lre_canonicalize(c, s->is_utf16);
+                GET_CHAR(c, cptr, cbuf_end, cbuf_type);
+                if (opcode == REOP_range_i) {
+                    c = lre_canonicalize(c, s->is_unicode);
                 }
                 idx_min = 0;
                 low = get_u16(pc + 0 * 4);
@@ -2410,17 +3050,18 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             }
             break;
         case REOP_range32:
+        case REOP_range32_i:
             {
                 int n;
                 uint32_t low, high, idx_min, idx_max, idx;
-                
+
                 n = get_u16(pc); /* n must be >= 1 */
                 pc += 2;
                 if (cptr >= cbuf_end)
                     goto no_match;
-                GET_CHAR(c, cptr, cbuf_end);
-                if (s->ignore_case) {
-                    c = lre_canonicalize(c, s->is_utf16);
+                GET_CHAR(c, cptr, cbuf_end, cbuf_type);
+                if (opcode == REOP_range32_i) {
+                    c = lre_canonicalize(c, s->is_unicode);
                 }
                 idx_min = 0;
                 low = get_u32(pc + 0 * 8);
@@ -2450,7 +3091,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             /* go to the previous char */
             if (cptr == s->cbuf)
                 goto no_match;
-            PREV_CHAR(cptr, s->cbuf);
+            PREV_CHAR(cptr, s->cbuf, cbuf_type);
             break;
         case REOP_simple_greedy_quant:
             {
@@ -2458,19 +3099,22 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 size_t q;
                 intptr_t res;
                 const uint8_t *pc1;
-                
+
                 next_pos = get_u32(pc);
                 quant_min = get_u32(pc + 4);
                 quant_max = get_u32(pc + 8);
                 pc += 16;
                 pc1 = pc;
                 pc += (int)next_pos;
-                
+
                 q = 0;
                 for(;;) {
+                    if (lre_poll_timeout(s))
+                        return LRE_RET_TIMEOUT;
                     res = lre_exec_backtrack(s, capture, stack, stack_len,
                                              pc1, cptr, TRUE);
-                    if (res == -1)
+                    if (res == LRE_RET_MEMORY_ERROR ||
+                        res == LRE_RET_TIMEOUT)
                         return res;
                     if (!res)
                         break;
@@ -2488,7 +3132,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                                      RE_EXEC_STATE_GREEDY_QUANT,
                                      q - quant_min);
                     if (ret < 0)
-                        return -1;
+                        return LRE_RET_MEMORY_ERROR;
                 }
             }
             break;
@@ -2498,7 +3142,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
     }
 }
 
-/* Return 1 if match, 0 if not match or -1 if error. cindex is the
+/* Return 1 if match, 0 if not match or < 0 if error (see LRE_RET_x). cindex is the
    starting position of the match and must be such as 0 <= cindex <=
    clen. */
 int lre_exec(uint8_t **capture,
@@ -2508,18 +3152,17 @@ int lre_exec(uint8_t **capture,
     REExecContext s_s, *s = &s_s;
     int re_flags, i, alloca_size, ret;
     StackInt *stack_buf;
-    
-    re_flags = bc_buf[RE_HEADER_FLAGS];
-    s->multi_line = (re_flags & LRE_FLAG_MULTILINE) != 0;
-    s->ignore_case = (re_flags & LRE_FLAG_IGNORECASE) != 0;
-    s->is_utf16 = (re_flags & LRE_FLAG_UTF16) != 0;
+
+    re_flags = lre_get_flags(bc_buf);
+    s->is_unicode = (re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
     s->capture_count = bc_buf[RE_HEADER_CAPTURE_COUNT];
     s->stack_size_max = bc_buf[RE_HEADER_STACK_SIZE];
     s->cbuf = cbuf;
     s->cbuf_end = cbuf + (clen << cbuf_type);
     s->cbuf_type = cbuf_type;
-    if (s->cbuf_type == 1 && s->is_utf16)
+    if (s->cbuf_type == 1 && s->is_unicode)
         s->cbuf_type = 2;
+    s->interrupt_counter = INTERRUPT_COUNTER_INIT;
     s->opaque = opaque;
 
     s->state_size = sizeof(REExecState) +
@@ -2528,7 +3171,7 @@ int lre_exec(uint8_t **capture,
     s->state_stack = NULL;
     s->state_stack_len = 0;
     s->state_stack_size = 0;
-    
+
     for(i = 0; i < s->capture_count * 2; i++)
         capture[i] = NULL;
     alloca_size = s->stack_size_max * sizeof(stack_buf[0]);
@@ -2546,7 +3189,7 @@ int lre_get_capture_count(const uint8_t *bc_buf)
 
 int lre_get_flags(const uint8_t *bc_buf)
 {
-    return bc_buf[RE_HEADER_FLAGS];
+    return get_u16(bc_buf + RE_HEADER_FLAGS);
 }
 
 /* Return NULL if no group names. Otherwise, return a pointer to
@@ -2556,8 +3199,8 @@ const char *lre_get_groupnames(const uint8_t *bc_buf)
     uint32_t re_bytecode_len;
     if ((lre_get_flags(bc_buf) & LRE_FLAG_NAMED_GROUPS) == 0)
         return NULL;
-    re_bytecode_len = get_u32(bc_buf + 3);
-    return (const char *)(bc_buf + 7 + re_bytecode_len);
+    re_bytecode_len = get_u32(bc_buf + RE_HEADER_BYTECODE_LEN);
+    return (const char *)(bc_buf + RE_HEADER_LEN + re_bytecode_len);
 }
 
 #ifdef TEST
@@ -2574,27 +3217,28 @@ void *lre_realloc(void *opaque, void *ptr, size_t size)
 
 int main(int argc, char **argv)
 {
-    int len, ret, i;
+    int len, flags, ret, i;
     uint8_t *bc;
     char error_msg[64];
     uint8_t *capture[CAPTURE_COUNT_MAX * 2];
     const char *input;
     int input_len, capture_count;
-    
-    if (argc < 3) {
-        printf("usage: %s regexp input\n", argv[0]);
-        exit(1);
+
+    if (argc < 4) {
+        printf("usage: %s regexp flags input\n", argv[0]);
+        return 1;
     }
+    flags = atoi(argv[2]);
     bc = lre_compile(&len, error_msg, sizeof(error_msg), argv[1],
-                     strlen(argv[1]), 0, NULL);
+                     strlen(argv[1]), flags, NULL);
     if (!bc) {
         fprintf(stderr, "error: %s\n", error_msg);
         exit(1);
     }
 
-    input = argv[2];
+    input = argv[3];
     input_len = strlen(input);
-    
+
     ret = lre_exec(capture, bc, (uint8_t *)input, 0, input_len, 0, NULL);
     printf("ret=%d\n", ret);
     if (ret == 1) {
diff --git a/quickjs/libregexp.h b/quickjs/libregexp.h
index 9aedb7e937..da76e4cef6 100644
--- a/quickjs/libregexp.h
+++ b/quickjs/libregexp.h
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -25,19 +25,20 @@
 #define LIBREGEXP_H
 
 #include <stddef.h>
-
-#include "libunicode.h"
-
-#define LRE_BOOL  int       /* for documentation purposes */
+#include <stdint.h>
 
 #define LRE_FLAG_GLOBAL     (1 << 0)
 #define LRE_FLAG_IGNORECASE (1 << 1)
 #define LRE_FLAG_MULTILINE  (1 << 2)
 #define LRE_FLAG_DOTALL     (1 << 3)
-#define LRE_FLAG_UTF16      (1 << 4)
+#define LRE_FLAG_UNICODE    (1 << 4)
 #define LRE_FLAG_STICKY     (1 << 5)
-
+#define LRE_FLAG_INDICES    (1 << 6) /* Unused by libregexp, just recorded. */
 #define LRE_FLAG_NAMED_GROUPS (1 << 7) /* named groups are present in the regexp */
+#define LRE_FLAG_UNICODE_SETS (1 << 8)
+
+#define LRE_RET_MEMORY_ERROR (-1)
+#define LRE_RET_TIMEOUT      (-2)
 
 uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
                      const char *buf, size_t buf_len, int re_flags,
@@ -50,43 +51,11 @@ int lre_exec(uint8_t **capture,
              int cbuf_type, void *opaque);
 
 int lre_parse_escape(const uint8_t **pp, int allow_utf16);
-LRE_BOOL lre_is_space(int c);
 
-/* must be provided by the user */
-LRE_BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size); 
+/* must be provided by the user, return non zero if overflow */
+int lre_check_stack_overflow(void *opaque, size_t alloca_size);
+/* must be provided by the user, return non zero if time out */
+int lre_check_timeout(void *opaque);
 void *lre_realloc(void *opaque, void *ptr, size_t size);
 
-/* JS identifier test */
-extern uint32_t const lre_id_start_table_ascii[4];
-extern uint32_t const lre_id_continue_table_ascii[4];
-
-static inline int lre_js_is_ident_first(int c)
-{
-    if ((uint32_t)c < 128) {
-        return (lre_id_start_table_ascii[c >> 5] >> (c & 31)) & 1;
-    } else {
-#ifdef CONFIG_ALL_UNICODE
-        return lre_is_id_start(c);
-#else
-        return !lre_is_space(c);
-#endif
-    }
-}
-
-static inline int lre_js_is_ident_next(int c)
-{
-    if ((uint32_t)c < 128) {
-        return (lre_id_continue_table_ascii[c >> 5] >> (c & 31)) & 1;
-    } else {
-        /* ZWNJ and ZWJ are accepted in identifiers */
-#ifdef CONFIG_ALL_UNICODE
-        return lre_is_id_continue(c) || c == 0x200C || c == 0x200D;
-#else
-        return !lre_is_space(c) || c == 0x200C || c == 0x200D;
-#endif
-    }
-}
-
-#undef LRE_BOOL
-
 #endif /* LIBREGEXP_H */
diff --git a/quickjs/libunicode-table.h b/quickjs/libunicode-table.h
index b64178b488..67df6b3a3c 100644
--- a/quickjs/libunicode-table.h
+++ b/quickjs/libunicode-table.h
@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-static const uint32_t case_conv_table1[370] = {
+static const uint32_t case_conv_table1[378] = {
     0x00209a30, 0x00309a00, 0x005a8173, 0x00601730,
     0x006c0730, 0x006f81b3, 0x00701700, 0x007c0700,
     0x007f8100, 0x00803040, 0x009801c3, 0x00988190,
@@ -13,140 +13,143 @@ static const uint32_t case_conv_table1[370] = {
     0x00c48230, 0x00c58240, 0x00c70130, 0x00c78130,
     0x00c80130, 0x00c88240, 0x00c98130, 0x00ca0130,
     0x00ca8100, 0x00cb0130, 0x00cb8130, 0x00cc0240,
-    0x00cd0100, 0x00ce0130, 0x00ce8130, 0x00cf0100,
-    0x00cf8130, 0x00d00640, 0x00d30130, 0x00d38240,
-    0x00d48130, 0x00d60240, 0x00d70130, 0x00d78240,
-    0x00d88230, 0x00d98440, 0x00db8130, 0x00dc0240,
-    0x00de0240, 0x00df8100, 0x00e20350, 0x00e38350,
-    0x00e50350, 0x00e69040, 0x00ee8100, 0x00ef1240,
-    0x00f801b4, 0x00f88350, 0x00fa0240, 0x00fb0130,
-    0x00fb8130, 0x00fc2840, 0x01100130, 0x01111240,
-    0x011d0131, 0x011d8240, 0x011e8130, 0x011f0131,
-    0x011f8201, 0x01208240, 0x01218130, 0x01220130,
-    0x01228130, 0x01230a40, 0x01280101, 0x01288101,
-    0x01290101, 0x01298100, 0x012a0100, 0x012b0200,
-    0x012c8100, 0x012d8100, 0x012e0101, 0x01300100,
-    0x01308101, 0x01318100, 0x01328101, 0x01330101,
-    0x01340100, 0x01348100, 0x01350101, 0x01358101,
-    0x01360101, 0x01378100, 0x01388101, 0x01390100,
-    0x013a8100, 0x013e8101, 0x01400100, 0x01410101,
-    0x01418100, 0x01438101, 0x01440100, 0x01448100,
-    0x01450200, 0x01460100, 0x01490100, 0x014e8101,
-    0x014f0101, 0x01a28173, 0x01b80440, 0x01bb0240,
-    0x01bd8300, 0x01bf8130, 0x01c30130, 0x01c40330,
-    0x01c60130, 0x01c70230, 0x01c801d0, 0x01c89130,
-    0x01d18930, 0x01d60100, 0x01d68300, 0x01d801d3,
-    0x01d89100, 0x01e10173, 0x01e18900, 0x01e60100,
-    0x01e68200, 0x01e78130, 0x01e80173, 0x01e88173,
-    0x01ea8173, 0x01eb0173, 0x01eb8100, 0x01ec1840,
-    0x01f80173, 0x01f88173, 0x01f90100, 0x01f98100,
-    0x01fa01a0, 0x01fa8173, 0x01fb8240, 0x01fc8130,
-    0x01fd0240, 0x01fe8330, 0x02001030, 0x02082030,
-    0x02182000, 0x02281000, 0x02302240, 0x02453640,
-    0x02600130, 0x02608e40, 0x02678100, 0x02686040,
-    0x0298a630, 0x02b0a600, 0x02c381b5, 0x08502631,
-    0x08638131, 0x08668131, 0x08682b00, 0x087e8300,
-    0x09d05011, 0x09f80610, 0x09fc0620, 0x0e400174,
-    0x0e408174, 0x0e410174, 0x0e418174, 0x0e420174,
-    0x0e428174, 0x0e430174, 0x0e438180, 0x0e440180,
-    0x0e482b30, 0x0e5e8330, 0x0ebc8101, 0x0ebe8101,
-    0x0ec70101, 0x0f007e40, 0x0f3f1840, 0x0f4b01b5,
-    0x0f4b81b6, 0x0f4c01b6, 0x0f4c81b6, 0x0f4d01b7,
-    0x0f4d8180, 0x0f4f0130, 0x0f506040, 0x0f800800,
-    0x0f840830, 0x0f880600, 0x0f8c0630, 0x0f900800,
-    0x0f940830, 0x0f980800, 0x0f9c0830, 0x0fa00600,
-    0x0fa40630, 0x0fa801b0, 0x0fa88100, 0x0fa901d3,
-    0x0fa98100, 0x0faa01d3, 0x0faa8100, 0x0fab01d3,
-    0x0fab8100, 0x0fac8130, 0x0fad8130, 0x0fae8130,
-    0x0faf8130, 0x0fb00800, 0x0fb40830, 0x0fb80200,
-    0x0fb90400, 0x0fbb0200, 0x0fbc0201, 0x0fbd0201,
-    0x0fbe0201, 0x0fc008b7, 0x0fc40867, 0x0fc808b8,
-    0x0fcc0868, 0x0fd008b8, 0x0fd40868, 0x0fd80200,
-    0x0fd901b9, 0x0fd981b1, 0x0fda01b9, 0x0fdb01b1,
-    0x0fdb81d7, 0x0fdc0230, 0x0fdd0230, 0x0fde0161,
-    0x0fdf0173, 0x0fe101b9, 0x0fe181b2, 0x0fe201ba,
-    0x0fe301b2, 0x0fe381d8, 0x0fe40430, 0x0fe60162,
-    0x0fe80200, 0x0fe901d0, 0x0fe981d0, 0x0feb01b0,
-    0x0feb81d0, 0x0fec0230, 0x0fed0230, 0x0ff00201,
-    0x0ff101d3, 0x0ff181d3, 0x0ff201ba, 0x0ff28101,
-    0x0ff301b0, 0x0ff381d3, 0x0ff40230, 0x0ff50230,
-    0x0ff60131, 0x0ff901ba, 0x0ff981b2, 0x0ffa01bb,
-    0x0ffb01b2, 0x0ffb81d9, 0x0ffc0230, 0x0ffd0230,
-    0x0ffe0162, 0x109301a0, 0x109501a0, 0x109581a0,
-    0x10990131, 0x10a70101, 0x10b01031, 0x10b81001,
-    0x10c18240, 0x125b1a31, 0x12681a01, 0x16003031,
-    0x16183001, 0x16300240, 0x16310130, 0x16318130,
-    0x16320130, 0x16328100, 0x16330100, 0x16338640,
-    0x16368130, 0x16370130, 0x16378130, 0x16380130,
-    0x16390240, 0x163a8240, 0x163f0230, 0x16406440,
-    0x16758440, 0x16790240, 0x16802600, 0x16938100,
-    0x16968100, 0x53202e40, 0x53401c40, 0x53910e40,
-    0x53993e40, 0x53bc8440, 0x53be8130, 0x53bf0a40,
-    0x53c58240, 0x53c68130, 0x53c80440, 0x53ca0101,
-    0x53cb1440, 0x53d50130, 0x53d58130, 0x53d60130,
-    0x53d68130, 0x53d70130, 0x53d80130, 0x53d88130,
-    0x53d90130, 0x53d98131, 0x53da1040, 0x53e20131,
-    0x53e28130, 0x53e30130, 0x53e38440, 0x53e80240,
-    0x53eb0440, 0x53fa8240, 0x55a98101, 0x55b85020,
-    0x7d8001b2, 0x7d8081b2, 0x7d8101b2, 0x7d8181da,
-    0x7d8201da, 0x7d8281b3, 0x7d8301b3, 0x7d8981bb,
-    0x7d8a01bb, 0x7d8a81bb, 0x7d8b01bc, 0x7d8b81bb,
-    0x7f909a31, 0x7fa09a01, 0x82002831, 0x82142801,
-    0x82582431, 0x826c2401, 0x82b80b31, 0x82be0f31,
-    0x82c60731, 0x82ca0231, 0x82cb8b01, 0x82d18f01,
-    0x82d98701, 0x82dd8201, 0x86403331, 0x86603301,
+    0x00cd0100, 0x00cd8101, 0x00ce0130, 0x00ce8130,
+    0x00cf0100, 0x00cf8130, 0x00d00640, 0x00d30130,
+    0x00d38240, 0x00d48130, 0x00d60240, 0x00d70130,
+    0x00d78240, 0x00d88230, 0x00d98440, 0x00db8130,
+    0x00dc0240, 0x00de0240, 0x00df8100, 0x00e20350,
+    0x00e38350, 0x00e50350, 0x00e69040, 0x00ee8100,
+    0x00ef1240, 0x00f801b4, 0x00f88350, 0x00fa0240,
+    0x00fb0130, 0x00fb8130, 0x00fc2840, 0x01100130,
+    0x01111240, 0x011d0131, 0x011d8240, 0x011e8130,
+    0x011f0131, 0x011f8201, 0x01208240, 0x01218130,
+    0x01220130, 0x01228130, 0x01230a40, 0x01280101,
+    0x01288101, 0x01290101, 0x01298100, 0x012a0100,
+    0x012b0200, 0x012c8100, 0x012d8100, 0x012e0101,
+    0x01300100, 0x01308101, 0x01318100, 0x01320101,
+    0x01328101, 0x01330101, 0x01340100, 0x01348100,
+    0x01350101, 0x01358101, 0x01360101, 0x01378100,
+    0x01388101, 0x01390100, 0x013a8100, 0x013e8101,
+    0x01400100, 0x01410101, 0x01418100, 0x01438101,
+    0x01440100, 0x01448100, 0x01450200, 0x01460100,
+    0x01490100, 0x014e8101, 0x014f0101, 0x01a28173,
+    0x01b80440, 0x01bb0240, 0x01bd8300, 0x01bf8130,
+    0x01c30130, 0x01c40330, 0x01c60130, 0x01c70230,
+    0x01c801d0, 0x01c89130, 0x01d18930, 0x01d60100,
+    0x01d68300, 0x01d801d3, 0x01d89100, 0x01e10173,
+    0x01e18900, 0x01e60100, 0x01e68200, 0x01e78130,
+    0x01e80173, 0x01e88173, 0x01ea8173, 0x01eb0173,
+    0x01eb8100, 0x01ec1840, 0x01f80173, 0x01f88173,
+    0x01f90100, 0x01f98100, 0x01fa01a0, 0x01fa8173,
+    0x01fb8240, 0x01fc8130, 0x01fd0240, 0x01fe8330,
+    0x02001030, 0x02082030, 0x02182000, 0x02281000,
+    0x02302240, 0x02453640, 0x02600130, 0x02608e40,
+    0x02678100, 0x02686040, 0x0298a630, 0x02b0a600,
+    0x02c381b5, 0x08502631, 0x08638131, 0x08668131,
+    0x08682b00, 0x087e8300, 0x09d05011, 0x09f80610,
+    0x09fc0620, 0x0e400174, 0x0e408174, 0x0e410174,
+    0x0e418174, 0x0e420174, 0x0e428174, 0x0e430174,
+    0x0e438180, 0x0e440180, 0x0e448240, 0x0e482b30,
+    0x0e5e8330, 0x0ebc8101, 0x0ebe8101, 0x0ec70101,
+    0x0f007e40, 0x0f3f1840, 0x0f4b01b5, 0x0f4b81b6,
+    0x0f4c01b6, 0x0f4c81b6, 0x0f4d01b7, 0x0f4d8180,
+    0x0f4f0130, 0x0f506040, 0x0f800800, 0x0f840830,
+    0x0f880600, 0x0f8c0630, 0x0f900800, 0x0f940830,
+    0x0f980800, 0x0f9c0830, 0x0fa00600, 0x0fa40630,
+    0x0fa801b0, 0x0fa88100, 0x0fa901d3, 0x0fa98100,
+    0x0faa01d3, 0x0faa8100, 0x0fab01d3, 0x0fab8100,
+    0x0fac8130, 0x0fad8130, 0x0fae8130, 0x0faf8130,
+    0x0fb00800, 0x0fb40830, 0x0fb80200, 0x0fb90400,
+    0x0fbb0201, 0x0fbc0201, 0x0fbd0201, 0x0fbe0201,
+    0x0fc008b7, 0x0fc40867, 0x0fc808b8, 0x0fcc0868,
+    0x0fd008b8, 0x0fd40868, 0x0fd80200, 0x0fd901b9,
+    0x0fd981b1, 0x0fda01b9, 0x0fdb01b1, 0x0fdb81d7,
+    0x0fdc0230, 0x0fdd0230, 0x0fde0161, 0x0fdf0173,
+    0x0fe101b9, 0x0fe181b2, 0x0fe201ba, 0x0fe301b2,
+    0x0fe381d8, 0x0fe40430, 0x0fe60162, 0x0fe80201,
+    0x0fe901d0, 0x0fe981d0, 0x0feb01b0, 0x0feb81d0,
+    0x0fec0230, 0x0fed0230, 0x0ff00201, 0x0ff101d3,
+    0x0ff181d3, 0x0ff201ba, 0x0ff28101, 0x0ff301b0,
+    0x0ff381d3, 0x0ff40231, 0x0ff50230, 0x0ff60131,
+    0x0ff901ba, 0x0ff981b2, 0x0ffa01bb, 0x0ffb01b2,
+    0x0ffb81d9, 0x0ffc0230, 0x0ffd0230, 0x0ffe0162,
+    0x109301a0, 0x109501a0, 0x109581a0, 0x10990131,
+    0x10a70101, 0x10b01031, 0x10b81001, 0x10c18240,
+    0x125b1a31, 0x12681a01, 0x16003031, 0x16183001,
+    0x16300240, 0x16310130, 0x16318130, 0x16320130,
+    0x16328100, 0x16330100, 0x16338640, 0x16368130,
+    0x16370130, 0x16378130, 0x16380130, 0x16390240,
+    0x163a8240, 0x163f0230, 0x16406440, 0x16758440,
+    0x16790240, 0x16802600, 0x16938100, 0x16968100,
+    0x53202e40, 0x53401c40, 0x53910e40, 0x53993e40,
+    0x53bc8440, 0x53be8130, 0x53bf0a40, 0x53c58240,
+    0x53c68130, 0x53c80440, 0x53ca0101, 0x53cb1440,
+    0x53d50130, 0x53d58130, 0x53d60130, 0x53d68130,
+    0x53d70130, 0x53d80130, 0x53d88130, 0x53d90130,
+    0x53d98131, 0x53da1040, 0x53e20131, 0x53e28130,
+    0x53e30130, 0x53e38440, 0x53e58130, 0x53e60240,
+    0x53e80240, 0x53eb0640, 0x53ee0130, 0x53fa8240,
+    0x55a98101, 0x55b85020, 0x7d8001b2, 0x7d8081b2,
+    0x7d8101b2, 0x7d8181da, 0x7d8201da, 0x7d8281b3,
+    0x7d8301b3, 0x7d8981bb, 0x7d8a01bb, 0x7d8a81bb,
+    0x7d8b01bc, 0x7d8b81bb, 0x7f909a31, 0x7fa09a01,
+    0x82002831, 0x82142801, 0x82582431, 0x826c2401,
+    0x82b80b31, 0x82be0f31, 0x82c60731, 0x82ca0231,
+    0x82cb8b01, 0x82d18f01, 0x82d98701, 0x82dd8201,
+    0x86403331, 0x86603301, 0x86a81631, 0x86b81601,
     0x8c502031, 0x8c602001, 0xb7202031, 0xb7302001,
     0xf4802231, 0xf4912201,
 };
 
-static const uint8_t case_conv_table2[370] = {
+static const uint8_t case_conv_table2[378] = {
     0x01, 0x00, 0x9c, 0x06, 0x07, 0x4d, 0x03, 0x04,
     0x10, 0x00, 0x8f, 0x0b, 0x00, 0x00, 0x11, 0x00,
-    0x08, 0x00, 0x53, 0x4a, 0x51, 0x00, 0x52, 0x00,
-    0x53, 0x00, 0x3a, 0x54, 0x55, 0x00, 0x57, 0x59,
-    0x3f, 0x5d, 0x5c, 0x00, 0x46, 0x61, 0x63, 0x42,
-    0x64, 0x00, 0x66, 0x00, 0x68, 0x00, 0x6a, 0x00,
-    0x6c, 0x00, 0x6e, 0x00, 0x00, 0x40, 0x00, 0x00,
-    0x00, 0x00, 0x1a, 0x00, 0x93, 0x00, 0x00, 0x20,
-    0x35, 0x00, 0x27, 0x00, 0x21, 0x00, 0x24, 0x22,
-    0x2a, 0x00, 0x13, 0x6b, 0x6d, 0x00, 0x26, 0x24,
-    0x27, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x3e, 0x1e,
-    0x3f, 0x1f, 0x39, 0x3d, 0x22, 0x21, 0x41, 0x1e,
-    0x40, 0x25, 0x25, 0x26, 0x28, 0x20, 0x2a, 0x48,
-    0x2c, 0x43, 0x2e, 0x4b, 0x30, 0x4c, 0x32, 0x44,
-    0x42, 0x99, 0x00, 0x00, 0x95, 0x8f, 0x7d, 0x7e,
-    0x83, 0x84, 0x12, 0x80, 0x82, 0x76, 0x77, 0x12,
-    0x7b, 0xa3, 0x7c, 0x78, 0x79, 0x8a, 0x92, 0x98,
-    0xa6, 0xa0, 0x85, 0x00, 0x9a, 0xa1, 0x93, 0x75,
-    0x33, 0x95, 0x00, 0x8e, 0x00, 0x74, 0x99, 0x98,
-    0x97, 0x96, 0x00, 0x00, 0x9e, 0x00, 0x9c, 0x00,
-    0xa1, 0xa0, 0x15, 0x2e, 0x2f, 0x30, 0xb4, 0xb5,
-    0x4f, 0xaa, 0xa9, 0x12, 0x14, 0x1e, 0x21, 0x22,
-    0x22, 0x2a, 0x34, 0x35, 0xa6, 0xa7, 0x36, 0x1f,
-    0x49, 0x00, 0x00, 0x97, 0x01, 0x5a, 0xda, 0x1d,
-    0x36, 0x05, 0x00, 0xc4, 0xc3, 0xc6, 0xc5, 0xc8,
-    0xc7, 0xca, 0xc9, 0xcc, 0xcb, 0xc4, 0xd5, 0x45,
-    0xd6, 0x42, 0xd7, 0x46, 0xd8, 0xce, 0xd0, 0xd2,
-    0xd4, 0xda, 0xd9, 0xee, 0xf6, 0xfe, 0x0e, 0x07,
-    0x0f, 0x80, 0x9f, 0x00, 0x21, 0x80, 0xa3, 0xed,
-    0x00, 0xc0, 0x40, 0xc6, 0x60, 0xe7, 0xdb, 0xe6,
-    0x99, 0xc0, 0x00, 0x00, 0x06, 0x60, 0xdc, 0x29,
-    0xfd, 0x15, 0x12, 0x06, 0x16, 0xf8, 0xdd, 0x06,
-    0x15, 0x12, 0x84, 0x08, 0xc6, 0x16, 0xff, 0xdf,
-    0x03, 0xc0, 0x40, 0x00, 0x46, 0x60, 0xde, 0xe0,
-    0x6d, 0x37, 0x38, 0x39, 0x15, 0x14, 0x17, 0x16,
-    0x00, 0x1a, 0x19, 0x1c, 0x1b, 0x00, 0x5f, 0xb7,
-    0x65, 0x44, 0x47, 0x00, 0x4f, 0x62, 0x4e, 0x50,
-    0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0xa3, 0xa4,
-    0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0x00,
-    0x00, 0x5a, 0x00, 0x47, 0x00, 0x5b, 0x56, 0x58,
-    0x60, 0x5e, 0x70, 0x69, 0x6f, 0x4e, 0x00, 0x3b,
-    0x67, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x45, 0xa8,
-    0x8a, 0x8b, 0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf,
-    0x94, 0xb0, 0x6f, 0xb2, 0x5d, 0x5c, 0x5f, 0x5e,
-    0x61, 0x60, 0x66, 0x67, 0x68, 0x69, 0x62, 0x63,
-    0x64, 0x65, 0x6b, 0x6a, 0x6d, 0x6c, 0x6f, 0x6e,
-    0x71, 0x70,
+    0x08, 0x00, 0x53, 0x4b, 0x52, 0x00, 0x53, 0x00,
+    0x54, 0x00, 0x3b, 0x55, 0x56, 0x00, 0x58, 0x5a,
+    0x40, 0x5f, 0x5e, 0x00, 0x47, 0x52, 0x63, 0x65,
+    0x43, 0x66, 0x00, 0x68, 0x00, 0x6a, 0x00, 0x6c,
+    0x00, 0x6e, 0x00, 0x70, 0x00, 0x00, 0x41, 0x00,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x93, 0x00, 0x00,
+    0x20, 0x36, 0x00, 0x28, 0x00, 0x24, 0x00, 0x24,
+    0x25, 0x2d, 0x00, 0x13, 0x6d, 0x6f, 0x00, 0x29,
+    0x27, 0x2a, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x41,
+    0x1e, 0x42, 0x1f, 0x4e, 0x3c, 0x40, 0x22, 0x21,
+    0x44, 0x21, 0x43, 0x26, 0x28, 0x27, 0x29, 0x23,
+    0x2b, 0x4b, 0x2d, 0x46, 0x2f, 0x4c, 0x31, 0x4d,
+    0x33, 0x47, 0x45, 0x99, 0x00, 0x00, 0x97, 0x91,
+    0x7f, 0x80, 0x85, 0x86, 0x12, 0x82, 0x84, 0x78,
+    0x79, 0x12, 0x7d, 0xa3, 0x7e, 0x7a, 0x7b, 0x8c,
+    0x92, 0x98, 0xa6, 0xa0, 0x87, 0x00, 0x9a, 0xa1,
+    0x95, 0x77, 0x33, 0x95, 0x00, 0x90, 0x00, 0x76,
+    0x9b, 0x9a, 0x99, 0x98, 0x00, 0x00, 0xa0, 0x00,
+    0x9e, 0x00, 0xa3, 0xa2, 0x15, 0x31, 0x32, 0x33,
+    0xb7, 0xb8, 0x55, 0xac, 0xab, 0x12, 0x14, 0x1e,
+    0x21, 0x22, 0x22, 0x2a, 0x34, 0x35, 0x00, 0xa8,
+    0xa9, 0x39, 0x22, 0x4c, 0x00, 0x00, 0x97, 0x01,
+    0x5a, 0xda, 0x1d, 0x36, 0x05, 0x00, 0xc7, 0xc6,
+    0xc9, 0xc8, 0xcb, 0xca, 0xcd, 0xcc, 0xcf, 0xce,
+    0xc4, 0xd8, 0x45, 0xd9, 0x42, 0xda, 0x46, 0xdb,
+    0xd1, 0xd3, 0xd5, 0xd7, 0xdd, 0xdc, 0xf1, 0xf9,
+    0x01, 0x11, 0x0a, 0x12, 0x80, 0x9f, 0x00, 0x21,
+    0x80, 0xa3, 0xf0, 0x00, 0xc0, 0x40, 0xc6, 0x60,
+    0xea, 0xde, 0xe6, 0x99, 0xc0, 0x00, 0x00, 0x06,
+    0x60, 0xdf, 0x29, 0x00, 0x15, 0x12, 0x06, 0x16,
+    0xfb, 0xe0, 0x09, 0x15, 0x12, 0x84, 0x0b, 0xc6,
+    0x16, 0x02, 0xe2, 0x06, 0xc0, 0x40, 0x00, 0x46,
+    0x60, 0xe1, 0xe3, 0x6d, 0x37, 0x38, 0x39, 0x18,
+    0x17, 0x1a, 0x19, 0x00, 0x1d, 0x1c, 0x1f, 0x1e,
+    0x00, 0x61, 0xba, 0x67, 0x45, 0x48, 0x00, 0x50,
+    0x64, 0x4f, 0x51, 0x00, 0x00, 0x49, 0x00, 0x00,
+    0x00, 0xa5, 0xa6, 0xa7, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xb9, 0x00, 0x00, 0x5c, 0x00, 0x4a, 0x00,
+    0x5d, 0x57, 0x59, 0x62, 0x60, 0x72, 0x6b, 0x71,
+    0x54, 0x00, 0x3e, 0x69, 0xbb, 0x00, 0x5b, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x48, 0xaa, 0x8a, 0x8b,
+    0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf, 0x94, 0xb0,
+    0x6f, 0xb2, 0x63, 0x62, 0x65, 0x64, 0x67, 0x66,
+    0x6c, 0x6d, 0x6e, 0x6f, 0x68, 0x69, 0x6a, 0x6b,
+    0x71, 0x70, 0x73, 0x72, 0x75, 0x74, 0x77, 0x76,
+    0x79, 0x78,
 };
 
 static const uint16_t case_conv_ext[58] = {
@@ -160,41 +163,44 @@ static const uint16_t case_conv_ext[58] = {
     0x006b, 0x00e5,
 };
 
-static const uint8_t unicode_prop_Cased1_table[196] = {
+static const uint8_t unicode_prop_Cased1_table[193] = {
     0x40, 0xa9, 0x80, 0x8e, 0x80, 0xfc, 0x80, 0xd3,
-    0x80, 0x8c, 0x80, 0x8d, 0x81, 0x8d, 0x02, 0x80,
-    0xe1, 0x80, 0x91, 0x85, 0x9a, 0x01, 0x00, 0x01,
-    0x11, 0x00, 0x01, 0x04, 0x08, 0x01, 0x08, 0x30,
-    0x08, 0x01, 0x15, 0x20, 0x00, 0x39, 0x99, 0x31,
-    0x9d, 0x84, 0x40, 0x94, 0x80, 0xd6, 0x82, 0xa6,
-    0x80, 0x41, 0x62, 0x80, 0xa6, 0x80, 0x4b, 0x72,
-    0x80, 0x4c, 0x02, 0xf8, 0x02, 0x80, 0x8f, 0x80,
-    0xb0, 0x40, 0xdb, 0x08, 0x80, 0x41, 0xd0, 0x80,
-    0x8c, 0x80, 0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89,
-    0x00, 0x14, 0x28, 0x10, 0x11, 0x02, 0x01, 0x18,
-    0x0b, 0x24, 0x4b, 0x26, 0x01, 0x01, 0x86, 0xe5,
-    0x80, 0x60, 0x79, 0xb6, 0x81, 0x40, 0x91, 0x81,
-    0xbd, 0x88, 0x94, 0x05, 0x80, 0x98, 0x80, 0xa2,
-    0x00, 0x80, 0x9b, 0x12, 0x82, 0x43, 0x34, 0xa2,
-    0x06, 0x80, 0x8d, 0x60, 0x5c, 0x15, 0x01, 0x10,
-    0xa9, 0x80, 0x88, 0x60, 0xcc, 0x44, 0xd4, 0x80,
-    0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00,
-    0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b,
-    0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81,
-    0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80,
-    0x9e, 0x80, 0x98, 0x07, 0x47, 0x33, 0x89, 0x80,
-    0x93, 0x2d, 0x41, 0x04, 0xbd, 0x50, 0xc1, 0x99,
-    0x85, 0x99, 0x85, 0x99,
+    0x80, 0x9b, 0x81, 0x8d, 0x02, 0x80, 0xe1, 0x80,
+    0x91, 0x85, 0x9a, 0x01, 0x00, 0x01, 0x11, 0x03,
+    0x04, 0x08, 0x01, 0x08, 0x30, 0x08, 0x01, 0x15,
+    0x20, 0x00, 0x39, 0x99, 0x31, 0x9d, 0x84, 0x40,
+    0x94, 0x80, 0xd6, 0x82, 0xa6, 0x80, 0x41, 0x62,
+    0x80, 0xa6, 0x80, 0x4b, 0x72, 0x80, 0x4c, 0x02,
+    0xf8, 0x02, 0x80, 0x8f, 0x80, 0xb0, 0x40, 0xdb,
+    0x08, 0x80, 0x41, 0xd0, 0x80, 0x8c, 0x80, 0x8f,
+    0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x14, 0x28,
+    0x10, 0x11, 0x02, 0x01, 0x18, 0x0b, 0x24, 0x4b,
+    0x26, 0x01, 0x01, 0x86, 0xe5, 0x80, 0x60, 0x79,
+    0xb6, 0x81, 0x40, 0x91, 0x81, 0xbd, 0x88, 0x94,
+    0x05, 0x80, 0x98, 0x80, 0xa2, 0x00, 0x80, 0x9b,
+    0x12, 0x82, 0x43, 0x34, 0xa2, 0x06, 0x80, 0x8d,
+    0x60, 0x5c, 0x15, 0x01, 0x10, 0xa9, 0x80, 0x88,
+    0x60, 0xcc, 0x44, 0xd4, 0x80, 0xc6, 0x01, 0x08,
+    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
+    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
+    0x16, 0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x07, 0x47, 0x33, 0x89, 0x80, 0x93, 0x2d, 0x41,
+    0x04, 0xbd, 0x50, 0xc1, 0x99, 0x85, 0x99, 0x85,
+    0x99,
 };
 
-static const uint8_t unicode_prop_Cased1_index[21] = {
-    0xb9, 0x02, 0xe0, 0xc0, 0x1d, 0x20, 0xe5, 0x2c,
-    0x20, 0xb1, 0x07, 0x21, 0xc1, 0xd6, 0x21, 0x4a,
-    0xf1, 0x01, 0x8a, 0xf1, 0x01,
+static const uint8_t unicode_prop_Cased1_index[18] = {
+    0xb9, 0x02, 0x80,  //  002B9 at 36
+    0xa0, 0x1e, 0x40,  //  01EA0 at 66
+    0x9e, 0xa6, 0x40,  //  0A69E at 98
+    0xbb, 0x07, 0x01,  //  107BB at 128
+    0xdb, 0xd6, 0x01,  //  1D6DB at 160
+    0x8a, 0xf1, 0x01,  //  1F18A at 192 (upper bound)
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_table[737] = {
+static const uint8_t unicode_prop_Case_Ignorable_table[764] = {
     0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80,
     0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
     0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40,
@@ -203,7 +209,7 @@ static const uint8_t unicode_prop_Case_Ignorable_table[737] = {
     0x89, 0x8a, 0x00, 0xa2, 0x80, 0x89, 0x94, 0x8f,
     0x80, 0xe4, 0x38, 0x89, 0x03, 0xa0, 0x00, 0x80,
     0x9d, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0x18, 0x08,
-    0x97, 0x97, 0xaa, 0x82, 0xab, 0x06, 0x0d, 0x87,
+    0x97, 0x97, 0xaa, 0x82, 0xab, 0x06, 0x0c, 0x88,
     0xa8, 0xb9, 0xb6, 0x00, 0x03, 0x3b, 0x02, 0x86,
     0x89, 0x81, 0x8c, 0x80, 0x8e, 0x80, 0xb9, 0x03,
     0x1f, 0x80, 0x93, 0x81, 0x99, 0x01, 0x81, 0xb8,
@@ -257,26 +263,29 @@ static const uint8_t unicode_prop_Case_Ignorable_table[737] = {
     0x80, 0x40, 0x94, 0x84, 0x44, 0x04, 0x28, 0xa9,
     0x80, 0x88, 0x42, 0x45, 0x10, 0x0c, 0x83, 0xa7,
     0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x83,
-    0x41, 0x82, 0x81, 0xcf, 0x82, 0xc5, 0x8a, 0xb0,
-    0x83, 0xfa, 0x80, 0xb5, 0x8e, 0xa8, 0x01, 0x81,
-    0x89, 0x82, 0xb0, 0x19, 0x09, 0x03, 0x80, 0x89,
-    0x80, 0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80,
-    0x8b, 0x81, 0xb3, 0x88, 0x89, 0x19, 0x80, 0xde,
-    0x11, 0x00, 0x0d, 0x01, 0x80, 0x40, 0x9c, 0x02,
-    0x87, 0x94, 0x81, 0xb8, 0x0a, 0x80, 0xa4, 0x32,
-    0x84, 0x40, 0xc2, 0x39, 0x10, 0x80, 0x96, 0x80,
-    0xd3, 0x28, 0x03, 0x08, 0x81, 0x40, 0xed, 0x1d,
-    0x08, 0x81, 0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81,
-    0xe9, 0x00, 0x01, 0x28, 0x80, 0xe4, 0x11, 0x18,
-    0x84, 0x41, 0x02, 0x88, 0x01, 0x40, 0xff, 0x08,
-    0x03, 0x80, 0x40, 0x8f, 0x19, 0x0b, 0x80, 0x9f,
-    0x89, 0xa7, 0x29, 0x1f, 0x80, 0x88, 0x29, 0x82,
-    0xad, 0x8c, 0x01, 0x41, 0x95, 0x30, 0x28, 0x80,
-    0xd1, 0x95, 0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00,
-    0x08, 0x30, 0x80, 0xc7, 0x0a, 0x00, 0x80, 0x41,
-    0x5a, 0x81, 0x8a, 0x81, 0xb3, 0x24, 0x00, 0x80,
-    0x54, 0xec, 0x90, 0x85, 0x8e, 0x60, 0x36, 0x99,
-    0x84, 0xba, 0x86, 0x88, 0x83, 0x44, 0x0a, 0x80,
+    0xa5, 0x80, 0x99, 0x20, 0x80, 0x41, 0x3a, 0x81,
+    0xce, 0x83, 0xc5, 0x8a, 0xb0, 0x83, 0xfa, 0x80,
+    0xb5, 0x8e, 0xa8, 0x01, 0x81, 0x89, 0x82, 0xb0,
+    0x19, 0x09, 0x03, 0x80, 0x89, 0x80, 0xb1, 0x82,
+    0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b, 0x81, 0xb3,
+    0x88, 0x89, 0x19, 0x80, 0xde, 0x11, 0x00, 0x0d,
+    0x01, 0x80, 0x40, 0x9c, 0x02, 0x87, 0x94, 0x81,
+    0xb8, 0x0a, 0x80, 0xa4, 0x32, 0x84, 0xc5, 0x85,
+    0x8c, 0x00, 0x00, 0x80, 0x8d, 0x81, 0xd4, 0x39,
+    0x10, 0x80, 0x96, 0x80, 0xd3, 0x28, 0x03, 0x08,
+    0x81, 0x40, 0xed, 0x1d, 0x08, 0x81, 0x9a, 0x81,
+    0xd4, 0x39, 0x00, 0x81, 0xe9, 0x00, 0x01, 0x28,
+    0x80, 0xe4, 0x00, 0x01, 0x18, 0x84, 0x41, 0x02,
+    0x88, 0x01, 0x40, 0xff, 0x08, 0x03, 0x80, 0x40,
+    0x8f, 0x19, 0x0b, 0x80, 0x9f, 0x89, 0xa7, 0x29,
+    0x1f, 0x80, 0x88, 0x29, 0x82, 0xad, 0x8c, 0x01,
+    0x41, 0x95, 0x30, 0x28, 0x80, 0xd1, 0x95, 0x0e,
+    0x01, 0x01, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x80,
+    0xc7, 0x0a, 0x00, 0x80, 0x41, 0x5a, 0x81, 0x8a,
+    0x81, 0xb3, 0x24, 0x00, 0x80, 0x96, 0x80, 0x54,
+    0xd4, 0x90, 0x85, 0x8e, 0x60, 0x2c, 0xc7, 0x8b,
+    0x12, 0x49, 0xbf, 0x84, 0xba, 0x86, 0x88, 0x83,
+    0x41, 0xfb, 0x82, 0xa7, 0x81, 0x41, 0xe1, 0x80,
     0xbe, 0x90, 0xbf, 0x08, 0x81, 0x60, 0x40, 0x0a,
     0x18, 0x30, 0x81, 0x4c, 0x9d, 0x08, 0x83, 0x52,
     0x5b, 0xad, 0x81, 0x96, 0x42, 0x1f, 0x82, 0x88,
@@ -285,24 +294,39 @@ static const uint8_t unicode_prop_Case_Ignorable_table[737] = {
     0x20, 0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01,
     0x04, 0x84, 0xbd, 0xa0, 0x80, 0x40, 0x9f, 0x8d,
     0x41, 0x6f, 0x80, 0xbc, 0x83, 0x41, 0xfa, 0x84,
-    0x43, 0xdf, 0x86, 0xec, 0x87, 0x4a, 0xae, 0x84,
-    0x6c, 0x0c, 0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40,
-    0xef,
+    0x40, 0xfd, 0x81, 0x42, 0xdf, 0x86, 0xec, 0x87,
+    0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00, 0x80, 0x9d,
+    0xdf, 0xff, 0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_Case_Ignorable_index[69] = {
-    0xbe, 0x05, 0x00, 0xfe, 0x07, 0x00, 0x52, 0x0a,
-    0xa0, 0xc1, 0x0b, 0x00, 0x82, 0x0d, 0x00, 0x3f,
-    0x10, 0x80, 0xd4, 0x17, 0x40, 0xcf, 0x1a, 0x20,
-    0xf5, 0x1c, 0x00, 0x80, 0x20, 0x00, 0x16, 0xa0,
-    0x00, 0xc6, 0xa8, 0x00, 0xc2, 0xaa, 0x60, 0x56,
-    0xfe, 0x20, 0xb1, 0x07, 0x01, 0x75, 0x10, 0x01,
-    0xeb, 0x12, 0x21, 0x41, 0x16, 0x01, 0x5c, 0x1a,
-    0x01, 0x43, 0x1f, 0x01, 0x2e, 0xcf, 0x41, 0x25,
-    0xe0, 0x01, 0xf0, 0x01, 0x0e,
+static const uint8_t unicode_prop_Case_Ignorable_index[72] = {
+    0xbe, 0x05, 0x00,  //  005BE at 32
+    0xfe, 0x07, 0x00,  //  007FE at 64
+    0x52, 0x0a, 0xa0,  //  00A52 at 101
+    0xc1, 0x0b, 0x00,  //  00BC1 at 128
+    0x82, 0x0d, 0x00,  //  00D82 at 160
+    0x3f, 0x10, 0x80,  //  0103F at 196
+    0xd4, 0x17, 0x40,  //  017D4 at 226
+    0xcf, 0x1a, 0x20,  //  01ACF at 257
+    0xf5, 0x1c, 0x00,  //  01CF5 at 288
+    0x80, 0x20, 0x00,  //  02080 at 320
+    0x16, 0xa0, 0x00,  //  0A016 at 352
+    0xc6, 0xa8, 0x00,  //  0A8C6 at 384
+    0xc2, 0xaa, 0x60,  //  0AAC2 at 419
+    0x56, 0xfe, 0x20,  //  0FE56 at 449
+    0xb1, 0x07, 0x01,  //  107B1 at 480
+    0x02, 0x10, 0x01,  //  11002 at 512
+    0x42, 0x12, 0x41,  //  11242 at 546
+    0xc4, 0x14, 0x21,  //  114C4 at 577
+    0xe1, 0x19, 0x81,  //  119E1 at 612
+    0x48, 0x1d, 0x01,  //  11D48 at 640
+    0x44, 0x6b, 0x01,  //  16B44 at 672
+    0x83, 0xd1, 0x21,  //  1D183 at 705
+    0x3e, 0xe1, 0x01,  //  1E13E at 736
+    0xf0, 0x01, 0x0e,  //  E01F0 at 768 (upper bound)
 };
 
-static const uint8_t unicode_prop_ID_Start_table[1100] = {
+static const uint8_t unicode_prop_ID_Start_table[1133] = {
     0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03,
     0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
     0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20,
@@ -346,7 +370,7 @@ static const uint8_t unicode_prop_ID_Start_table[1100] = {
     0x83, 0x99, 0xb5, 0x96, 0x88, 0xb4, 0xd1, 0x80,
     0xdc, 0xae, 0x90, 0x87, 0xb5, 0x9d, 0x8c, 0x81,
     0x89, 0xab, 0x99, 0xa3, 0xa8, 0x82, 0x89, 0xa3,
-    0x81, 0x88, 0x86, 0xaa, 0x0a, 0xa8, 0x18, 0x28,
+    0x81, 0x8a, 0x84, 0xaa, 0x0a, 0xa8, 0x18, 0x28,
     0x0a, 0x04, 0x40, 0xbf, 0xbf, 0x41, 0x15, 0x0d,
     0x81, 0xa5, 0x0d, 0x0f, 0x00, 0x00, 0x00, 0x80,
     0x9e, 0x81, 0xb4, 0x06, 0x00, 0x12, 0x06, 0x13,
@@ -362,8 +386,8 @@ static const uint8_t unicode_prop_ID_Start_table[1100] = {
     0x41, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x56, 0x8c,
     0xc2, 0xad, 0x81, 0x41, 0x0c, 0x82, 0x8f, 0x89,
     0x81, 0x93, 0xae, 0x8f, 0x9e, 0x81, 0xcf, 0xa6,
-    0x88, 0x81, 0xe6, 0x81, 0xbf, 0x21, 0x00, 0x04,
-    0x97, 0x8f, 0x02, 0x03, 0x80, 0x96, 0x9c, 0xb3,
+    0x88, 0x81, 0xe6, 0x81, 0xc2, 0x09, 0x00, 0x07,
+    0x94, 0x8f, 0x02, 0x03, 0x80, 0x96, 0x9c, 0xb3,
     0x8d, 0xb1, 0xbd, 0x2a, 0x00, 0x81, 0x8a, 0x9b,
     0x89, 0x96, 0x98, 0x9c, 0x86, 0xae, 0x9b, 0x80,
     0x8f, 0x20, 0x89, 0x89, 0x20, 0xa8, 0x96, 0x10,
@@ -383,91 +407,117 @@ static const uint8_t unicode_prop_ID_Start_table[1100] = {
     0xa5, 0x89, 0x9d, 0x81, 0xa3, 0x1f, 0x04, 0xa9,
     0x40, 0x9d, 0x91, 0xa3, 0x83, 0xa3, 0x83, 0xa7,
     0x87, 0xb3, 0x8b, 0x8a, 0x80, 0x8e, 0x06, 0x01,
-    0x80, 0x8a, 0x80, 0x8e, 0x06, 0x01, 0xc2, 0x41,
-    0x36, 0x88, 0x95, 0x89, 0x87, 0x97, 0x28, 0xa9,
-    0x80, 0x88, 0xc4, 0x29, 0x00, 0xab, 0x01, 0x10,
-    0x81, 0x96, 0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92,
-    0x01, 0x89, 0x95, 0x89, 0x99, 0xc5, 0xb7, 0x29,
-    0xbf, 0x80, 0x8e, 0x18, 0x10, 0x9c, 0xa9, 0x9c,
-    0x82, 0x9c, 0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89,
-    0x95, 0x89, 0x92, 0x8c, 0x91, 0xed, 0xc8, 0xb6,
-    0xb2, 0x8c, 0xb2, 0x8c, 0xa3, 0x41, 0x5b, 0xa9,
-    0x29, 0xcd, 0x9c, 0x89, 0x07, 0x95, 0xa9, 0x91,
+    0x80, 0x8a, 0x80, 0x8e, 0x06, 0x01, 0x82, 0xb3,
+    0x8b, 0x41, 0x36, 0x88, 0x95, 0x89, 0x87, 0x97,
+    0x28, 0xa9, 0x80, 0x88, 0xc4, 0x29, 0x00, 0xab,
+    0x01, 0x10, 0x81, 0x96, 0x89, 0x96, 0x88, 0x9e,
+    0xc0, 0x92, 0x01, 0x89, 0x95, 0x89, 0x99, 0xc5,
+    0xb7, 0x29, 0xbf, 0x80, 0x8e, 0x18, 0x10, 0x9c,
+    0xa9, 0x9c, 0x82, 0x9c, 0xa2, 0x38, 0x9b, 0x9a,
+    0xb5, 0x89, 0x95, 0x89, 0x92, 0x8c, 0x91, 0xed,
+    0xc8, 0xb6, 0xb2, 0x8c, 0xb2, 0x8c, 0xa3, 0xa5,
+    0x9b, 0x88, 0x96, 0x40, 0xf9, 0xa9, 0x29, 0x8f,
+    0x82, 0xba, 0x9c, 0x89, 0x07, 0x95, 0xa9, 0x91,
     0xad, 0x94, 0x9a, 0x96, 0x8b, 0xb4, 0xb8, 0x09,
     0x80, 0x8c, 0xac, 0x9f, 0x98, 0x99, 0xa3, 0x9c,
     0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d, 0x83,
     0x94, 0x00, 0x80, 0xa2, 0x91, 0x80, 0x98, 0x92,
     0x81, 0xbe, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89,
     0x86, 0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01,
-    0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x40, 0x9d,
-    0xb4, 0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93,
-    0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3,
-    0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6,
-    0x9a, 0xa4, 0x86, 0x40, 0xb8, 0xab, 0xf3, 0xbf,
-    0x9e, 0x39, 0x01, 0x38, 0x08, 0x97, 0x8e, 0x00,
-    0x80, 0xdd, 0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b,
-    0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad,
-    0x92, 0x80, 0x91, 0xc8, 0x41, 0x06, 0x88, 0x80,
-    0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef, 0x30, 0x08,
-    0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d,
-    0x80, 0x41, 0x46, 0x92, 0x8e, 0x00, 0x8c, 0x80,
-    0xa1, 0xfb, 0x80, 0xce, 0x43, 0x99, 0xe5, 0xee,
-    0x90, 0x40, 0xc3, 0x4a, 0x4b, 0xe0, 0x8e, 0x44,
-    0x2f, 0x90, 0x85, 0x4f, 0xb8, 0x42, 0x46, 0x60,
-    0x21, 0xb8, 0x42, 0x38, 0x86, 0x9e, 0x90, 0xce,
-    0x90, 0x9d, 0x91, 0xaf, 0x8f, 0x83, 0x9e, 0x94,
-    0x84, 0x92, 0x42, 0xaf, 0xbf, 0xff, 0xca, 0x20,
-    0xc1, 0x8c, 0xbf, 0x08, 0x80, 0x9b, 0x57, 0xf7,
-    0x87, 0x44, 0xd5, 0xa9, 0x88, 0x60, 0x22, 0xe6,
-    0x18, 0x30, 0x08, 0x41, 0x22, 0x8e, 0x80, 0x9c,
-    0x11, 0x80, 0x8d, 0x1f, 0x41, 0x8b, 0x49, 0x03,
-    0xea, 0x84, 0x8c, 0x82, 0x88, 0x86, 0x89, 0x57,
-    0x65, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b,
-    0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f,
-    0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16, 0x80,
-    0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
-    0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07, 0x47,
-    0x33, 0x9e, 0x2d, 0x41, 0x04, 0xbd, 0x40, 0x91,
-    0xac, 0x89, 0x86, 0x8f, 0x80, 0x41, 0x40, 0x9d,
-    0x91, 0xab, 0x41, 0xe3, 0x9b, 0x42, 0xf3, 0x30,
-    0x18, 0x08, 0x8e, 0x80, 0x40, 0xc4, 0xba, 0xc3,
-    0x30, 0x44, 0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08,
-    0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00,
-    0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00,
-    0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
-    0x51, 0x43, 0x60, 0xa6, 0xdf, 0x9f, 0x50, 0x39,
-    0x85, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d,
-    0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1, 0x53,
-    0x4a, 0x84, 0x50, 0x5f,
+    0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x9d, 0x89,
+    0x00, 0x08, 0x80, 0xa5, 0x00, 0x98, 0x00, 0x80,
+    0xab, 0xb4, 0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf,
+    0x93, 0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83,
+    0xa3, 0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80,
+    0xc6, 0x9a, 0xa4, 0x86, 0x40, 0xb8, 0xab, 0xf3,
+    0xbf, 0x9e, 0x39, 0x01, 0x38, 0x08, 0x97, 0x8e,
+    0x00, 0x80, 0xdd, 0x39, 0xa6, 0x8f, 0x00, 0x80,
+    0x9b, 0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a,
+    0xad, 0x92, 0x80, 0x91, 0xc8, 0x40, 0xc6, 0xa0,
+    0x9e, 0x88, 0x80, 0xa4, 0x90, 0x80, 0xb0, 0x9d,
+    0xef, 0x30, 0x08, 0xa5, 0x94, 0x80, 0x98, 0x28,
+    0x08, 0x9f, 0x8d, 0x80, 0x41, 0x46, 0x92, 0x8e,
+    0x00, 0x8c, 0x80, 0xa1, 0xfb, 0x80, 0xce, 0x43,
+    0x99, 0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a, 0x4b,
+    0xe0, 0x8e, 0x44, 0x2f, 0x90, 0x85, 0x98, 0x4f,
+    0x9a, 0x84, 0x42, 0x46, 0x5a, 0xb8, 0x9d, 0x46,
+    0xe1, 0x42, 0x38, 0x86, 0x9e, 0x90, 0xce, 0x90,
+    0x9d, 0x91, 0xaf, 0x8f, 0x83, 0x9e, 0x94, 0x84,
+    0x92, 0x41, 0xaf, 0xac, 0x40, 0xd2, 0xbf, 0xff,
+    0xca, 0x20, 0xc1, 0x8c, 0xbf, 0x08, 0x80, 0x9b,
+    0x57, 0xf7, 0x87, 0x44, 0xd5, 0xa8, 0x89, 0x60,
+    0x22, 0xe6, 0x18, 0x30, 0x08, 0x41, 0x22, 0x8e,
+    0x80, 0x9c, 0x11, 0x80, 0x8d, 0x1f, 0x41, 0x8b,
+    0x49, 0x03, 0xea, 0x84, 0x8c, 0x82, 0x88, 0x86,
+    0x89, 0x57, 0x65, 0xd4, 0x80, 0xc6, 0x01, 0x08,
+    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
+    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
+    0x16, 0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98,
+    0x07, 0x47, 0x33, 0x9e, 0x2d, 0x41, 0x04, 0xbd,
+    0x40, 0x91, 0xac, 0x89, 0x86, 0x8f, 0x80, 0x41,
+    0x40, 0x9d, 0x91, 0xab, 0x41, 0xe3, 0x9b, 0x40,
+    0xe3, 0x9d, 0x08, 0x41, 0xee, 0x30, 0x18, 0x08,
+    0x8e, 0x80, 0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44,
+    0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89,
+    0x03, 0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02,
+    0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89,
+    0x80, 0x90, 0x22, 0x04, 0x80, 0x90, 0x51, 0x43,
+    0x60, 0xa6, 0xdf, 0x9f, 0x50, 0x39, 0x85, 0x40,
+    0xdd, 0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x8e,
+    0x42, 0x6d, 0x49, 0xa1, 0x42, 0x1d, 0x45, 0xe1,
+    0x53, 0x4a, 0x84, 0x50, 0x5f,
 };
 
-static const uint8_t unicode_prop_ID_Start_index[105] = {
-    0xf6, 0x03, 0x20, 0xa6, 0x07, 0x00, 0xa9, 0x09,
-    0x20, 0xb1, 0x0a, 0x00, 0xba, 0x0b, 0x20, 0x3b,
-    0x0d, 0x20, 0xc7, 0x0e, 0x20, 0x49, 0x12, 0x00,
-    0x9b, 0x16, 0x00, 0xac, 0x19, 0x00, 0xc0, 0x1d,
-    0x80, 0x80, 0x20, 0x20, 0x70, 0x2d, 0x00, 0x00,
-    0x32, 0x00, 0xda, 0xa7, 0x00, 0x4c, 0xaa, 0x20,
-    0xc7, 0xd7, 0x20, 0xfc, 0xfd, 0x20, 0x9d, 0x02,
-    0x21, 0x96, 0x05, 0x01, 0xf3, 0x08, 0x01, 0xb3,
-    0x0c, 0x21, 0x73, 0x11, 0x61, 0x34, 0x13, 0x01,
-    0x1b, 0x17, 0x21, 0x8a, 0x1a, 0x01, 0x34, 0x1f,
-    0x21, 0xbf, 0x6a, 0x01, 0x23, 0xb1, 0xa1, 0xad,
-    0xd4, 0x01, 0x6f, 0xd7, 0x01, 0xff, 0xe7, 0x61,
-    0x5e, 0xee, 0x01, 0xe1, 0xeb, 0x22, 0xb0, 0x23,
-    0x03,
+static const uint8_t unicode_prop_ID_Start_index[108] = {
+    0xf6, 0x03, 0x20,  //  003F6 at 33
+    0xa6, 0x07, 0x00,  //  007A6 at 64
+    0xa9, 0x09, 0x20,  //  009A9 at 97
+    0xb1, 0x0a, 0x00,  //  00AB1 at 128
+    0xba, 0x0b, 0x20,  //  00BBA at 161
+    0x3b, 0x0d, 0x20,  //  00D3B at 193
+    0xc7, 0x0e, 0x20,  //  00EC7 at 225
+    0x49, 0x12, 0x00,  //  01249 at 256
+    0x9b, 0x16, 0x00,  //  0169B at 288
+    0xac, 0x19, 0x00,  //  019AC at 320
+    0xc0, 0x1d, 0x80,  //  01DC0 at 356
+    0x80, 0x20, 0x20,  //  02080 at 385
+    0x70, 0x2d, 0x00,  //  02D70 at 416
+    0x00, 0x32, 0x00,  //  03200 at 448
+    0xdd, 0xa7, 0x00,  //  0A7DD at 480
+    0x4c, 0xaa, 0x20,  //  0AA4C at 513
+    0xc7, 0xd7, 0x20,  //  0D7C7 at 545
+    0xfc, 0xfd, 0x20,  //  0FDFC at 577
+    0x9d, 0x02, 0x21,  //  1029D at 609
+    0x96, 0x05, 0x01,  //  10596 at 640
+    0x9f, 0x08, 0x01,  //  1089F at 672
+    0x49, 0x0c, 0x21,  //  10C49 at 705
+    0x76, 0x10, 0x21,  //  11076 at 737
+    0xa9, 0x12, 0x01,  //  112A9 at 768
+    0xb0, 0x14, 0x01,  //  114B0 at 800
+    0x42, 0x19, 0x41,  //  11942 at 834
+    0x90, 0x1c, 0x01,  //  11C90 at 864
+    0xf1, 0x2f, 0x21,  //  12FF1 at 897
+    0x90, 0x6b, 0x21,  //  16B90 at 929
+    0x33, 0xb1, 0x21,  //  1B133 at 961
+    0x06, 0xd5, 0x01,  //  1D506 at 992
+    0xc3, 0xd7, 0x01,  //  1D7C3 at 1024
+    0xff, 0xe7, 0x21,  //  1E7FF at 1057
+    0x63, 0xee, 0x01,  //  1EE63 at 1088
+    0x5e, 0xee, 0x42,  //  2EE5E at 1122
+    0xb0, 0x23, 0x03,  //  323B0 at 1152 (upper bound)
 };
 
-static const uint8_t unicode_prop_ID_Continue1_table[660] = {
+static const uint8_t unicode_prop_ID_Continue1_table[695] = {
     0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47,
     0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
     0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf,
     0x9e, 0x28, 0xe4, 0x31, 0x29, 0x08, 0x19, 0x89,
     0x96, 0x80, 0x9d, 0x9a, 0xda, 0x8a, 0x8e, 0x89,
     0xa0, 0x88, 0x88, 0x80, 0x97, 0x18, 0x88, 0x02,
-    0x04, 0xaa, 0x82, 0xbb, 0x87, 0xa9, 0x97, 0x80,
+    0x04, 0xaa, 0x82, 0xba, 0x88, 0xa9, 0x97, 0x80,
     0xa0, 0xb5, 0x10, 0x91, 0x06, 0x89, 0x09, 0x89,
     0x90, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x82, 0x88,
     0x80, 0x89, 0x09, 0x89, 0x8d, 0x01, 0x82, 0xb7,
@@ -496,70 +546,88 @@ static const uint8_t unicode_prop_ID_Continue1_table[660] = {
     0xae, 0x90, 0x8a, 0x89, 0x90, 0x88, 0x8b, 0x82,
     0x9d, 0x8c, 0x81, 0x89, 0xab, 0x8d, 0xaf, 0x93,
     0x87, 0x89, 0x85, 0x89, 0xf5, 0x10, 0x94, 0x18,
-    0x28, 0x0a, 0x40, 0xc5, 0xbf, 0x42, 0x3e, 0x81,
-    0x92, 0x80, 0xfa, 0x8c, 0x18, 0x82, 0x8b, 0x4b,
-    0xfd, 0x82, 0x40, 0x8c, 0x80, 0xdf, 0x9f, 0x42,
-    0x29, 0x85, 0xe8, 0x81, 0x60, 0x75, 0x84, 0x89,
-    0xc4, 0x03, 0x89, 0x9f, 0x81, 0xcf, 0x81, 0x41,
-    0x0f, 0x02, 0x03, 0x80, 0x96, 0x23, 0x80, 0xd2,
-    0x81, 0xb1, 0x91, 0x89, 0x89, 0x85, 0x91, 0x8c,
-    0x8a, 0x9b, 0x87, 0x98, 0x8c, 0xab, 0x83, 0xae,
-    0x8d, 0x8e, 0x89, 0x8a, 0x80, 0x89, 0x89, 0xae,
-    0x8d, 0x8b, 0x07, 0x09, 0x89, 0xa0, 0x82, 0xb1,
-    0x00, 0x11, 0x0c, 0x08, 0x80, 0xa8, 0x24, 0x81,
-    0x40, 0xeb, 0x38, 0x09, 0x89, 0x60, 0x4f, 0x23,
-    0x80, 0x42, 0xe0, 0x8f, 0x8f, 0x8f, 0x11, 0x97,
-    0x82, 0x40, 0xbf, 0x89, 0xa4, 0x80, 0x42, 0xbc,
-    0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x41,
-    0x24, 0x89, 0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7,
-    0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f,
-    0x89, 0x41, 0x70, 0x81, 0xcf, 0x82, 0xc5, 0x8a,
-    0xb0, 0x83, 0xf9, 0x82, 0xb4, 0x8e, 0x9e, 0x8a,
-    0x09, 0x89, 0x83, 0xac, 0x8a, 0x30, 0xac, 0x89,
-    0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21, 0xab, 0x80,
-    0x8b, 0x82, 0xaf, 0x8d, 0x3b, 0x80, 0x8b, 0xd1,
-    0x8b, 0x28, 0x08, 0x40, 0x9c, 0x8b, 0x84, 0x89,
-    0x2b, 0xb6, 0x08, 0x31, 0x09, 0x82, 0x88, 0x80,
-    0x89, 0x09, 0x32, 0x84, 0x40, 0xbf, 0x91, 0x88,
-    0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89, 0x40, 0xd4,
-    0x31, 0x88, 0x9a, 0x81, 0xd1, 0x90, 0x8e, 0x89,
-    0xd0, 0x8c, 0x87, 0x89, 0xd2, 0x8e, 0x83, 0x89,
-    0x40, 0xf1, 0x8e, 0x40, 0xa4, 0x89, 0xc5, 0x28,
-    0x09, 0x18, 0x00, 0x81, 0x8b, 0x89, 0xf6, 0x31,
-    0x32, 0x80, 0x9b, 0x89, 0xa7, 0x30, 0x1f, 0x80,
-    0x88, 0x8a, 0xad, 0x8f, 0x41, 0x94, 0x38, 0x87,
-    0x8f, 0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a,
-    0x00, 0x08, 0x30, 0x07, 0x89, 0xaf, 0x20, 0x08,
-    0x27, 0x89, 0x41, 0x48, 0x83, 0x88, 0x08, 0x80,
-    0xaf, 0x32, 0x84, 0x8c, 0x89, 0x54, 0xe5, 0x05,
-    0x8e, 0x60, 0x36, 0x09, 0x89, 0xd5, 0x89, 0xa5,
-    0x84, 0xba, 0x86, 0x98, 0x89, 0x43, 0xf4, 0x00,
-    0xb6, 0x33, 0xd0, 0x80, 0x8a, 0x81, 0x60, 0x4c,
-    0xaa, 0x81, 0x52, 0x60, 0xad, 0x81, 0x96, 0x42,
-    0x1d, 0x22, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x40,
-    0x93, 0x82, 0x45, 0x88, 0xb1, 0x41, 0xff, 0xb6,
-    0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e,
-    0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0xe3,
-    0x80, 0x40, 0x9f, 0x86, 0x88, 0x89, 0x41, 0x63,
-    0x80, 0xbc, 0x8d, 0x41, 0xf1, 0x8d, 0x43, 0xd5,
-    0x86, 0xec, 0x34, 0x89, 0x52, 0x95, 0x89, 0x6c,
-    0x05, 0x05, 0x40, 0xef,
+    0x28, 0x0a, 0x40, 0xc5, 0xbf, 0x42, 0x0b, 0x81,
+    0xb0, 0x81, 0x92, 0x80, 0xfa, 0x8c, 0x18, 0x82,
+    0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c, 0x80, 0xdf,
+    0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81, 0xdf, 0x80,
+    0x60, 0x75, 0x23, 0x89, 0xc4, 0x03, 0x89, 0x9f,
+    0x81, 0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80,
+    0x96, 0x23, 0x80, 0xd2, 0x81, 0xb1, 0x91, 0x89,
+    0x89, 0x85, 0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98,
+    0x8c, 0xab, 0x83, 0xae, 0x8d, 0x8e, 0x89, 0x8a,
+    0x80, 0x89, 0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09,
+    0x89, 0xa0, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08,
+    0x80, 0xa8, 0x24, 0x81, 0x40, 0xeb, 0x38, 0x09,
+    0x89, 0x60, 0x4f, 0x23, 0x80, 0x42, 0xe0, 0x8f,
+    0x8f, 0x8f, 0x11, 0x97, 0x82, 0x40, 0xbf, 0x89,
+    0xa4, 0x80, 0xa4, 0x80, 0x42, 0x96, 0x80, 0x40,
+    0xe1, 0x80, 0x40, 0x94, 0x84, 0x41, 0x24, 0x89,
+    0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80,
+    0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f, 0x89, 0x85,
+    0x89, 0x9e, 0x84, 0x41, 0x3c, 0x81, 0xce, 0x83,
+    0xc5, 0x8a, 0xb0, 0x83, 0xf9, 0x82, 0xb4, 0x8e,
+    0x9e, 0x8a, 0x09, 0x89, 0x83, 0xac, 0x8a, 0x30,
+    0xac, 0x89, 0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21,
+    0xab, 0x80, 0x8b, 0x82, 0xaf, 0x8d, 0x3b, 0x80,
+    0x8b, 0xd1, 0x8b, 0x28, 0x08, 0x40, 0x9c, 0x8b,
+    0x84, 0x89, 0x2b, 0xb6, 0x08, 0x31, 0x09, 0x82,
+    0x88, 0x80, 0x89, 0x09, 0x32, 0x84, 0xc2, 0x88,
+    0x00, 0x08, 0x03, 0x04, 0x00, 0x8d, 0x81, 0xd1,
+    0x91, 0x88, 0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89,
+    0x40, 0xd4, 0x31, 0x88, 0x9a, 0x81, 0xd1, 0x90,
+    0x8e, 0x89, 0xd0, 0x8c, 0x87, 0x89, 0x85, 0x93,
+    0xb8, 0x8e, 0x83, 0x89, 0x40, 0xf1, 0x8e, 0x40,
+    0xa4, 0x89, 0xc5, 0x28, 0x09, 0x18, 0x00, 0x81,
+    0x8b, 0x89, 0xf6, 0x31, 0x32, 0x80, 0x9b, 0x89,
+    0xa7, 0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad, 0x8f,
+    0x41, 0x55, 0x89, 0xb4, 0x38, 0x87, 0x8f, 0x89,
+    0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08,
+    0x30, 0x07, 0x89, 0xaf, 0x20, 0x08, 0x27, 0x89,
+    0x41, 0x48, 0x83, 0x88, 0x08, 0x80, 0xaf, 0x32,
+    0x84, 0x8c, 0x8a, 0x54, 0xe4, 0x05, 0x8e, 0x60,
+    0x2c, 0xc7, 0x9b, 0x49, 0x25, 0x89, 0xd5, 0x89,
+    0xa5, 0x84, 0xba, 0x86, 0x98, 0x89, 0x42, 0x15,
+    0x89, 0x41, 0xd4, 0x00, 0xb6, 0x33, 0xd0, 0x80,
+    0x8a, 0x81, 0x60, 0x4c, 0xaa, 0x81, 0x50, 0x50,
+    0x89, 0x42, 0x05, 0xad, 0x81, 0x96, 0x42, 0x1d,
+    0x22, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x40, 0x93,
+    0x82, 0x45, 0x88, 0xb1, 0x41, 0xff, 0xb6, 0x83,
+    0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45,
+    0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0xe3, 0x80,
+    0x40, 0x9f, 0x86, 0x88, 0x89, 0x41, 0x63, 0x80,
+    0xbc, 0x8d, 0x41, 0xf1, 0x8d, 0x40, 0xf3, 0x08,
+    0x89, 0x42, 0xd4, 0x86, 0xec, 0x34, 0x89, 0x52,
+    0x95, 0x89, 0x6c, 0x05, 0x05, 0x40, 0xef,
 };
 
-static const uint8_t unicode_prop_ID_Continue1_index[63] = {
-    0xfa, 0x06, 0x00, 0x70, 0x09, 0x00, 0xf0, 0x0a,
-    0x40, 0x57, 0x0c, 0x00, 0xf0, 0x0d, 0x60, 0xc7,
-    0x0f, 0x20, 0xea, 0x17, 0x40, 0x05, 0x1b, 0x00,
-    0x41, 0x20, 0x00, 0x0c, 0xa8, 0x80, 0x37, 0xaa,
-    0x20, 0x50, 0xfe, 0x20, 0x3a, 0x0d, 0x21, 0x74,
-    0x11, 0x01, 0x5a, 0x14, 0x21, 0x44, 0x19, 0x81,
-    0x5a, 0x1d, 0xa1, 0xf5, 0x6a, 0x21, 0x45, 0xd2,
-    0x41, 0xaf, 0xe2, 0x21, 0xf0, 0x01, 0x0e,
+static const uint8_t unicode_prop_ID_Continue1_index[66] = {
+    0xfa, 0x06, 0x00,  //  006FA at 32
+    0x70, 0x09, 0x00,  //  00970 at 64
+    0xf0, 0x0a, 0x40,  //  00AF0 at 98
+    0x57, 0x0c, 0x00,  //  00C57 at 128
+    0xf0, 0x0d, 0x60,  //  00DF0 at 163
+    0xc7, 0x0f, 0x20,  //  00FC7 at 193
+    0xea, 0x17, 0x40,  //  017EA at 226
+    0x05, 0x1b, 0x00,  //  01B05 at 256
+    0x0e, 0x20, 0x00,  //  0200E at 288
+    0xa0, 0xa6, 0x20,  //  0A6A0 at 321
+    0xe6, 0xa9, 0x20,  //  0A9E6 at 353
+    0x10, 0xfe, 0x00,  //  0FE10 at 384
+    0x40, 0x0a, 0x01,  //  10A40 at 416
+    0xc3, 0x10, 0x01,  //  110C3 at 448
+    0x4e, 0x13, 0x01,  //  1134E at 480
+    0x41, 0x16, 0x01,  //  11641 at 512
+    0x0b, 0x1a, 0x01,  //  11A0B at 544
+    0xaa, 0x1d, 0x01,  //  11DAA at 576
+    0x7a, 0x6d, 0x21,  //  16D7A at 609
+    0x45, 0xd2, 0x21,  //  1D245 at 641
+    0xaf, 0xe2, 0x01,  //  1E2AF at 672
+    0xf0, 0x01, 0x0e,  //  E01F0 at 704 (upper bound)
 };
 
 #ifdef CONFIG_ALL_UNICODE
 
-static const uint8_t unicode_cc_table[899] = {
+static const uint8_t unicode_cc_table[916] = {
     0xb2, 0xcf, 0xd4, 0x00, 0xe8, 0x03, 0xdc, 0x00,
     0xe8, 0x00, 0xd8, 0x04, 0xdc, 0x01, 0xca, 0x03,
     0xdc, 0x01, 0xca, 0x0a, 0xdc, 0x04, 0x01, 0x03,
@@ -583,7 +651,7 @@ static const uint8_t unicode_cc_table[899] = {
     0xc0, 0x00, 0xdc, 0xc0, 0x00, 0xdc, 0xc1, 0xb0,
     0x6f, 0xc6, 0x00, 0xdc, 0xc0, 0x88, 0x00, 0xdc,
     0x97, 0xc3, 0x80, 0xc8, 0x80, 0xc2, 0x80, 0xc4,
-    0xaa, 0x02, 0xdc, 0xb0, 0x0b, 0xc0, 0x02, 0xdc,
+    0xaa, 0x02, 0xdc, 0xb0, 0x0a, 0xc1, 0x02, 0xdc,
     0xc3, 0xa9, 0xc4, 0x04, 0xdc, 0xcd, 0x80, 0x00,
     0xdc, 0xc1, 0x00, 0xdc, 0xc1, 0x00, 0xdc, 0xc2,
     0x02, 0xdc, 0x42, 0x1b, 0xc2, 0x00, 0xdc, 0xc1,
@@ -641,55 +709,75 @@ static const uint8_t unicode_cc_table[899] = {
     0xdc, 0xb0, 0xb1, 0x00, 0xdc, 0xb0, 0x64, 0xc4,
     0xb6, 0x61, 0x00, 0xdc, 0x80, 0xc0, 0xa7, 0xc0,
     0x00, 0x01, 0x00, 0xdc, 0x83, 0x00, 0x09, 0xb0,
-    0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb1,
-    0x52, 0xc1, 0xb0, 0x1f, 0x02, 0xdc, 0xb0, 0x15,
-    0x01, 0xdc, 0xc2, 0x00, 0xdc, 0xc0, 0x03, 0xdc,
-    0xb0, 0x00, 0xc0, 0x00, 0xdc, 0xc0, 0x00, 0xdc,
-    0xb0, 0x8f, 0x00, 0x09, 0xa8, 0x00, 0x09, 0x8d,
-    0x00, 0x09, 0xb0, 0x08, 0x00, 0x09, 0x00, 0x07,
-    0xb0, 0x14, 0xc2, 0xaf, 0x01, 0x09, 0xb0, 0x0d,
-    0x00, 0x07, 0xb0, 0x1b, 0x00, 0x09, 0x88, 0x00,
-    0x07, 0xb0, 0x39, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0x81, 0x00, 0x07, 0x00, 0x09, 0xb0, 0x1f, 0x01,
-    0x07, 0x8f, 0x00, 0x09, 0x97, 0xc6, 0x82, 0xc4,
-    0xb0, 0x9c, 0x00, 0x09, 0x82, 0x00, 0x07, 0x96,
-    0xc0, 0xb0, 0x32, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0xca, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00,
-    0x09, 0xb0, 0x45, 0x00, 0x09, 0x00, 0x07, 0xb0,
-    0x42, 0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00,
-    0x07, 0xb0, 0xd1, 0x01, 0x09, 0x83, 0x00, 0x07,
-    0xb0, 0x6b, 0x00, 0x09, 0xb0, 0x22, 0x00, 0x09,
-    0x91, 0x00, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1,
-    0x74, 0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07, 0x80,
-    0x01, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1, 0x78,
-    0x01, 0x09, 0xb8, 0x43, 0x7c, 0x04, 0x01, 0xb0,
-    0x0a, 0xc6, 0xb4, 0x88, 0x01, 0x06, 0xb8, 0x44,
-    0x7b, 0x00, 0x01, 0xb8, 0x0c, 0x95, 0x01, 0xd8,
-    0x02, 0x01, 0x82, 0x00, 0xe2, 0x04, 0xd8, 0x87,
-    0x07, 0xdc, 0x81, 0xc4, 0x01, 0xdc, 0x9d, 0xc3,
-    0xb0, 0x63, 0xc2, 0xb8, 0x05, 0x8a, 0xc6, 0x80,
-    0xd0, 0x81, 0xc6, 0x80, 0xc1, 0x80, 0xc4, 0xb0,
-    0x33, 0xc0, 0xb0, 0x6f, 0xc6, 0xb1, 0x46, 0xc0,
-    0xb0, 0x0c, 0xc3, 0xb1, 0xcb, 0x01, 0xe8, 0x00,
-    0xdc, 0xc0, 0xb3, 0xaf, 0x06, 0xdc, 0xb0, 0x3c,
-    0xc5, 0x00, 0x07,
+    0x74, 0xc0, 0x00, 0xdc, 0xb2, 0x0c, 0xc3, 0xb0,
+    0x10, 0xc4, 0xb1, 0x0c, 0xc1, 0xb0, 0x1f, 0x02,
+    0xdc, 0xb0, 0x15, 0x01, 0xdc, 0xc2, 0x00, 0xdc,
+    0xc0, 0x03, 0xdc, 0xb0, 0x00, 0xc0, 0x00, 0xdc,
+    0xc0, 0x00, 0xdc, 0xb0, 0x8f, 0x00, 0x09, 0xa8,
+    0x00, 0x09, 0x8d, 0x00, 0x09, 0xb0, 0x08, 0x00,
+    0x09, 0x00, 0x07, 0xb0, 0x14, 0xc2, 0xaf, 0x01,
+    0x09, 0xb0, 0x0d, 0x00, 0x07, 0xb0, 0x1b, 0x00,
+    0x09, 0x88, 0x00, 0x07, 0xb0, 0x39, 0x00, 0x09,
+    0x00, 0x07, 0xb0, 0x81, 0x00, 0x07, 0x00, 0x09,
+    0xb0, 0x1f, 0x01, 0x07, 0x8f, 0x00, 0x09, 0x97,
+    0xc6, 0x82, 0xc4, 0xb0, 0x28, 0x02, 0x09, 0xb0,
+    0x40, 0x00, 0x09, 0x82, 0x00, 0x07, 0x96, 0xc0,
+    0xb0, 0x32, 0x00, 0x09, 0x00, 0x07, 0xb0, 0xca,
+    0x00, 0x09, 0x00, 0x07, 0xb0, 0x4d, 0x00, 0x09,
+    0xb0, 0x45, 0x00, 0x09, 0x00, 0x07, 0xb0, 0x42,
+    0x00, 0x09, 0xb0, 0xdc, 0x00, 0x09, 0x00, 0x07,
+    0xb0, 0xd1, 0x01, 0x09, 0x83, 0x00, 0x07, 0xb0,
+    0x6b, 0x00, 0x09, 0xb0, 0x22, 0x00, 0x09, 0x91,
+    0x00, 0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1, 0x74,
+    0x00, 0x09, 0xb0, 0xd1, 0x00, 0x07, 0x80, 0x01,
+    0x09, 0xb0, 0x20, 0x00, 0x09, 0xb1, 0x78, 0x01,
+    0x09, 0xb8, 0x39, 0xbb, 0x00, 0x09, 0xb8, 0x01,
+    0x8f, 0x04, 0x01, 0xb0, 0x0a, 0xc6, 0xb4, 0x88,
+    0x01, 0x06, 0xb8, 0x44, 0x7b, 0x00, 0x01, 0xb8,
+    0x0c, 0x95, 0x01, 0xd8, 0x02, 0x01, 0x82, 0x00,
+    0xe2, 0x04, 0xd8, 0x87, 0x07, 0xdc, 0x81, 0xc4,
+    0x01, 0xdc, 0x9d, 0xc3, 0xb0, 0x63, 0xc2, 0xb8,
+    0x05, 0x8a, 0xc6, 0x80, 0xd0, 0x81, 0xc6, 0x80,
+    0xc1, 0x80, 0xc4, 0xb0, 0x33, 0xc0, 0xb0, 0x6f,
+    0xc6, 0xb1, 0x46, 0xc0, 0xb0, 0x0c, 0xc3, 0xb1,
+    0xcb, 0x01, 0xe8, 0x00, 0xdc, 0xc0, 0xb0, 0xcd,
+    0xc0, 0x00, 0xdc, 0xb2, 0xaf, 0x06, 0xdc, 0xb0,
+    0x3c, 0xc5, 0x00, 0x07,
 };
 
 static const uint8_t unicode_cc_index[87] = {
-    0x4d, 0x03, 0x00, 0x97, 0x05, 0x20, 0xc6, 0x05,
-    0x00, 0xe7, 0x06, 0x00, 0x45, 0x07, 0x00, 0x9c,
-    0x08, 0x00, 0x4d, 0x09, 0x00, 0x3c, 0x0b, 0x00,
-    0x3d, 0x0d, 0x00, 0x36, 0x0f, 0x00, 0x38, 0x10,
-    0x20, 0x3a, 0x19, 0x00, 0xcb, 0x1a, 0x20, 0xd3,
-    0x1c, 0x00, 0xcf, 0x1d, 0x00, 0xe2, 0x20, 0x00,
-    0x2e, 0x30, 0x20, 0x2b, 0xa9, 0x20, 0xed, 0xab,
-    0x00, 0x39, 0x0a, 0x01, 0x51, 0x0f, 0x01, 0x73,
-    0x11, 0x01, 0x75, 0x13, 0x01, 0x2b, 0x17, 0x21,
-    0x3f, 0x1c, 0x21, 0x9e, 0xbc, 0x21, 0x08, 0xe0,
-    0x01, 0x44, 0xe9, 0x01, 0x4b, 0xe9, 0x01,
+    0x4d, 0x03, 0x00,  //  0034D at 32
+    0x97, 0x05, 0x20,  //  00597 at 65
+    0xc6, 0x05, 0x00,  //  005C6 at 96
+    0xe7, 0x06, 0x00,  //  006E7 at 128
+    0x45, 0x07, 0x00,  //  00745 at 160
+    0x9c, 0x08, 0x00,  //  0089C at 192
+    0x4d, 0x09, 0x00,  //  0094D at 224
+    0x3c, 0x0b, 0x00,  //  00B3C at 256
+    0x3d, 0x0d, 0x00,  //  00D3D at 288
+    0x36, 0x0f, 0x00,  //  00F36 at 320
+    0x38, 0x10, 0x20,  //  01038 at 353
+    0x3a, 0x19, 0x00,  //  0193A at 384
+    0xcb, 0x1a, 0x20,  //  01ACB at 417
+    0xd3, 0x1c, 0x00,  //  01CD3 at 448
+    0xcf, 0x1d, 0x00,  //  01DCF at 480
+    0xe2, 0x20, 0x00,  //  020E2 at 512
+    0x2e, 0x30, 0x20,  //  0302E at 545
+    0x2b, 0xa9, 0x20,  //  0A92B at 577
+    0xed, 0xab, 0x00,  //  0ABED at 608
+    0x39, 0x0a, 0x01,  //  10A39 at 640
+    0x4c, 0x0f, 0x01,  //  10F4C at 672
+    0x35, 0x11, 0x21,  //  11135 at 705
+    0x66, 0x13, 0x01,  //  11366 at 736
+    0x40, 0x16, 0x01,  //  11640 at 768
+    0x47, 0x1a, 0x01,  //  11A47 at 800
+    0xf0, 0x6a, 0x21,  //  16AF0 at 833
+    0x8a, 0xd1, 0x01,  //  1D18A at 864
+    0xec, 0xe4, 0x21,  //  1E4EC at 897
+    0x4b, 0xe9, 0x01,  //  1E94B at 928 (upper bound)
 };
 
-static const uint32_t unicode_decomp_table1[699] = {
+static const uint32_t unicode_decomp_table1[709] = {
     0x00280081, 0x002a0097, 0x002a8081, 0x002bc097,
     0x002c8115, 0x002d0097, 0x002d4081, 0x002e0097,
     0x002e4115, 0x002f0199, 0x00302016, 0x00400842,
@@ -832,42 +920,45 @@ static const uint32_t unicode_decomp_table1[699] = {
     0x3f9c01af, 0x3f9d0085, 0x3f9d852f, 0x3fa03aad,
     0x3fbd442f, 0x3fc06f1f, 0x3fd7c11f, 0x3fd85fad,
     0x3fe80081, 0x3fe84f1f, 0x3ff0831f, 0x3ff2831f,
-    0x3ff4831f, 0x3ff6819f, 0x3ff80783, 0x41e04d83,
-    0x41e70f91, 0x44268192, 0x442ac092, 0x444b8112,
-    0x44d2c112, 0x452ec212, 0x456e8112, 0x464e0092,
-    0x74578392, 0x746ec312, 0x75000d1f, 0x75068d1f,
-    0x750d0d1f, 0x7513839f, 0x7515891f, 0x751a0d1f,
-    0x75208d1f, 0x75271015, 0x752f439f, 0x7531459f,
-    0x75340d1f, 0x753a8d1f, 0x75410395, 0x7543441f,
-    0x7545839f, 0x75478d1f, 0x754e0795, 0x7552839f,
-    0x75548d1f, 0x755b0d1f, 0x75618d1f, 0x75680d1f,
-    0x756e8d1f, 0x75750d1f, 0x757b8d1f, 0x75820d1f,
-    0x75888d1f, 0x758f0d1f, 0x75958d1f, 0x759c0d1f,
-    0x75a28d1f, 0x75a90103, 0x75aa089f, 0x75ae4081,
-    0x75ae839f, 0x75b04081, 0x75b08c9f, 0x75b6c081,
-    0x75b7032d, 0x75b8889f, 0x75bcc081, 0x75bd039f,
-    0x75bec081, 0x75bf0c9f, 0x75c54081, 0x75c5832d,
-    0x75c7089f, 0x75cb4081, 0x75cb839f, 0x75cd4081,
-    0x75cd8c9f, 0x75d3c081, 0x75d4032d, 0x75d5889f,
-    0x75d9c081, 0x75da039f, 0x75dbc081, 0x75dc0c9f,
-    0x75e24081, 0x75e2832d, 0x75e4089f, 0x75e84081,
-    0x75e8839f, 0x75ea4081, 0x75ea8c9f, 0x75f0c081,
-    0x75f1042d, 0x75f3851f, 0x75f6051f, 0x75f8851f,
-    0x75fb051f, 0x75fd851f, 0x780c049f, 0x780e419f,
-    0x780f059f, 0x7811c203, 0x7812d0ad, 0x781b0103,
-    0x7b80022d, 0x7b814dad, 0x7b884203, 0x7b89c081,
-    0x7b8a452d, 0x7b8d0403, 0x7b908081, 0x7b91dc03,
-    0x7ba0052d, 0x7ba2c8ad, 0x7ba84483, 0x7baac8ad,
-    0x7c400097, 0x7c404521, 0x7c440d25, 0x7c4a8087,
-    0x7c4ac115, 0x7c4b4117, 0x7c4c0d1f, 0x7c528217,
-    0x7c538099, 0x7c53c097, 0x7c5a8197, 0x7c640097,
-    0x7c80012f, 0x7c808081, 0x7c841603, 0x7c9004c1,
-    0x7c940103, 0x7efc051f, 0xbe0001ac, 0xbe00d110,
-    0xbe0947ac, 0xbe0d3910, 0xbe29872c, 0xbe2d022c,
-    0xbe2e3790, 0xbe49ff90, 0xbe69bc10,
+    0x3ff4831f, 0x3ff6819f, 0x3ff80783, 0x41724092,
+    0x41790092, 0x41e04d83, 0x41e70f91, 0x44268192,
+    0x442ac092, 0x444b8112, 0x44d2c112, 0x44e0c192,
+    0x44e38092, 0x44e44092, 0x44f14212, 0x452ec212,
+    0x456e8112, 0x464e0092, 0x58484412, 0x5b5a0192,
+    0x73358d1f, 0x733c051f, 0x74578392, 0x746ec312,
+    0x75000d1f, 0x75068d1f, 0x750d0d1f, 0x7513839f,
+    0x7515891f, 0x751a0d1f, 0x75208d1f, 0x75271015,
+    0x752f439f, 0x7531459f, 0x75340d1f, 0x753a8d1f,
+    0x75410395, 0x7543441f, 0x7545839f, 0x75478d1f,
+    0x754e0795, 0x7552839f, 0x75548d1f, 0x755b0d1f,
+    0x75618d1f, 0x75680d1f, 0x756e8d1f, 0x75750d1f,
+    0x757b8d1f, 0x75820d1f, 0x75888d1f, 0x758f0d1f,
+    0x75958d1f, 0x759c0d1f, 0x75a28d1f, 0x75a90103,
+    0x75aa089f, 0x75ae4081, 0x75ae839f, 0x75b04081,
+    0x75b08c9f, 0x75b6c081, 0x75b7032d, 0x75b8889f,
+    0x75bcc081, 0x75bd039f, 0x75bec081, 0x75bf0c9f,
+    0x75c54081, 0x75c5832d, 0x75c7089f, 0x75cb4081,
+    0x75cb839f, 0x75cd4081, 0x75cd8c9f, 0x75d3c081,
+    0x75d4032d, 0x75d5889f, 0x75d9c081, 0x75da039f,
+    0x75dbc081, 0x75dc0c9f, 0x75e24081, 0x75e2832d,
+    0x75e4089f, 0x75e84081, 0x75e8839f, 0x75ea4081,
+    0x75ea8c9f, 0x75f0c081, 0x75f1042d, 0x75f3851f,
+    0x75f6051f, 0x75f8851f, 0x75fb051f, 0x75fd851f,
+    0x780c049f, 0x780e419f, 0x780f059f, 0x7811c203,
+    0x7812d0ad, 0x781b0103, 0x7b80022d, 0x7b814dad,
+    0x7b884203, 0x7b89c081, 0x7b8a452d, 0x7b8d0403,
+    0x7b908081, 0x7b91dc03, 0x7ba0052d, 0x7ba2c8ad,
+    0x7ba84483, 0x7baac8ad, 0x7c400097, 0x7c404521,
+    0x7c440d25, 0x7c4a8087, 0x7c4ac115, 0x7c4b4117,
+    0x7c4c0d1f, 0x7c528217, 0x7c538099, 0x7c53c097,
+    0x7c5a8197, 0x7c640097, 0x7c80012f, 0x7c808081,
+    0x7c841603, 0x7c9004c1, 0x7c940103, 0x7efc051f,
+    0xbe0001ac, 0xbe00d110, 0xbe0947ac, 0xbe0d3910,
+    0xbe29872c, 0xbe2d022c, 0xbe2e3790, 0xbe49ff90,
+    0xbe69bc10,
 };
 
-static const uint16_t unicode_decomp_table2[699] = {
+static const uint16_t unicode_decomp_table2[709] = {
     0x0020, 0x0000, 0x0061, 0x0002, 0x0004, 0x0006, 0x03bc, 0x0008,
     0x000a, 0x000c, 0x0015, 0x0095, 0x00a5, 0x00b9, 0x00c1, 0x00c3,
     0x00c7, 0x00cb, 0x00d1, 0x00d7, 0x00dd, 0x00e0, 0x00e6, 0x00f8,
@@ -939,26 +1030,27 @@ static const uint16_t unicode_decomp_table2[699] = {
     0x1a77, 0x1a7f, 0x1a9d, 0x1aa2, 0x1ab6, 0x1ac0, 0x1ac6, 0x1ada,
     0x1adf, 0x1ae5, 0x1af3, 0x1b23, 0x1b30, 0x1b38, 0x1b3c, 0x1b52,
     0x1bc9, 0x1bdb, 0x1bdd, 0x1bdf, 0x3164, 0x1c20, 0x1c22, 0x1c24,
-    0x1c26, 0x1c28, 0x1c2a, 0x1c48, 0x1c7e, 0x1cc4, 0x1cd2, 0x1cd7,
-    0x1ce0, 0x1ce9, 0x1cfb, 0x1d04, 0x1d09, 0x1d29, 0x1d44, 0x1d46,
-    0x1d48, 0x1d4a, 0x1d4c, 0x1d4e, 0x1d50, 0x1d52, 0x1d72, 0x1d74,
-    0x1d76, 0x1d78, 0x1d7a, 0x1d81, 0x1d83, 0x1d85, 0x1d87, 0x1d96,
-    0x1d98, 0x1d9a, 0x1d9c, 0x1d9e, 0x1da0, 0x1da2, 0x1da4, 0x1da6,
-    0x1da8, 0x1daa, 0x1dac, 0x1dae, 0x1db0, 0x1db2, 0x1db6, 0x03f4,
-    0x1db8, 0x2207, 0x1dba, 0x2202, 0x1dbc, 0x1dc4, 0x03f4, 0x1dc6,
-    0x2207, 0x1dc8, 0x2202, 0x1dca, 0x1dd2, 0x03f4, 0x1dd4, 0x2207,
-    0x1dd6, 0x2202, 0x1dd8, 0x1de0, 0x03f4, 0x1de2, 0x2207, 0x1de4,
-    0x2202, 0x1de6, 0x1dee, 0x03f4, 0x1df0, 0x2207, 0x1df2, 0x2202,
-    0x1df4, 0x1dfe, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 0x1e0a,
-    0x1e0c, 0x1e0e, 0x1e16, 0x1e39, 0x1e3d, 0x1e43, 0x1e60, 0x062d,
-    0x1e68, 0x1e74, 0x062c, 0x1e84, 0x1ef4, 0x1f00, 0x1f13, 0x1f25,
-    0x1f38, 0x1f3a, 0x1f3e, 0x1f44, 0x1f4a, 0x1f4c, 0x1f50, 0x1f52,
-    0x1f5a, 0x1f5d, 0x1f5f, 0x1f65, 0x1f67, 0x30b5, 0x1f6d, 0x1fc5,
-    0x1fdb, 0x1fdf, 0x1fe1, 0x1fe6, 0x2033, 0x2044, 0x2145, 0x2155,
-    0x215b, 0x2255, 0x2373,
+    0x1c26, 0x1c28, 0x1c2a, 0x1c48, 0x1c4d, 0x1c52, 0x1c88, 0x1cce,
+    0x1cdc, 0x1ce1, 0x1cea, 0x1cf3, 0x1d01, 0x1d06, 0x1d0b, 0x1d1d,
+    0x1d2f, 0x1d38, 0x1d3d, 0x1d61, 0x1d6f, 0x1d71, 0x1d73, 0x1d93,
+    0x1dae, 0x1db0, 0x1db2, 0x1db4, 0x1db6, 0x1db8, 0x1dba, 0x1dbc,
+    0x1ddc, 0x1dde, 0x1de0, 0x1de2, 0x1de4, 0x1deb, 0x1ded, 0x1def,
+    0x1df1, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 0x1e0a, 0x1e0c,
+    0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a, 0x1e1c,
+    0x1e20, 0x03f4, 0x1e22, 0x2207, 0x1e24, 0x2202, 0x1e26, 0x1e2e,
+    0x03f4, 0x1e30, 0x2207, 0x1e32, 0x2202, 0x1e34, 0x1e3c, 0x03f4,
+    0x1e3e, 0x2207, 0x1e40, 0x2202, 0x1e42, 0x1e4a, 0x03f4, 0x1e4c,
+    0x2207, 0x1e4e, 0x2202, 0x1e50, 0x1e58, 0x03f4, 0x1e5a, 0x2207,
+    0x1e5c, 0x2202, 0x1e5e, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70,
+    0x1e72, 0x1e74, 0x1e76, 0x1e78, 0x1e80, 0x1ea3, 0x1ea7, 0x1ead,
+    0x1eca, 0x062d, 0x1ed2, 0x1ede, 0x062c, 0x1eee, 0x1f5e, 0x1f6a,
+    0x1f7d, 0x1f8f, 0x1fa2, 0x1fa4, 0x1fa8, 0x1fae, 0x1fb4, 0x1fb6,
+    0x1fba, 0x1fbc, 0x1fc4, 0x1fc7, 0x1fc9, 0x1fcf, 0x1fd1, 0x30b5,
+    0x1fd7, 0x202f, 0x2045, 0x2049, 0x204b, 0x2050, 0x209d, 0x20ae,
+    0x21af, 0x21bf, 0x21c5, 0x22bf, 0x23dd,
 };
 
-static const uint8_t unicode_decomp_data[9345] = {
+static const uint8_t unicode_decomp_data[9451] = {
     0x20, 0x88, 0x20, 0x84, 0x32, 0x33, 0x20, 0x81,
     0x20, 0xa7, 0x31, 0x6f, 0x31, 0xd0, 0x34, 0x31,
     0xd0, 0x32, 0x33, 0xd0, 0x34, 0x41, 0x80, 0x41,
@@ -1864,273 +1956,286 @@ static const uint8_t unicode_decomp_data[9345] = {
     0xaf, 0x00, 0xa6, 0x00, 0xa5, 0x00, 0xa9, 0x20,
     0x00, 0x00, 0x02, 0x25, 0x90, 0x21, 0x91, 0x21,
     0x92, 0x21, 0x93, 0x21, 0xa0, 0x25, 0xcb, 0x25,
-    0xd0, 0x02, 0xd1, 0x02, 0xe6, 0x00, 0x99, 0x02,
-    0x53, 0x02, 0x00, 0x00, 0xa3, 0x02, 0x66, 0xab,
-    0xa5, 0x02, 0xa4, 0x02, 0x56, 0x02, 0x57, 0x02,
-    0x91, 0x1d, 0x58, 0x02, 0x5e, 0x02, 0xa9, 0x02,
-    0x64, 0x02, 0x62, 0x02, 0x60, 0x02, 0x9b, 0x02,
-    0x27, 0x01, 0x9c, 0x02, 0x67, 0x02, 0x84, 0x02,
-    0xaa, 0x02, 0xab, 0x02, 0x6c, 0x02, 0x04, 0xdf,
-    0x8e, 0xa7, 0x6e, 0x02, 0x05, 0xdf, 0x8e, 0x02,
-    0x06, 0xdf, 0xf8, 0x00, 0x76, 0x02, 0x77, 0x02,
-    0x71, 0x00, 0x7a, 0x02, 0x08, 0xdf, 0x7d, 0x02,
-    0x7e, 0x02, 0x80, 0x02, 0xa8, 0x02, 0xa6, 0x02,
-    0x67, 0xab, 0xa7, 0x02, 0x88, 0x02, 0x71, 0x2c,
-    0x00, 0x00, 0x8f, 0x02, 0xa1, 0x02, 0xa2, 0x02,
-    0x98, 0x02, 0xc0, 0x01, 0xc1, 0x01, 0xc2, 0x01,
-    0x0a, 0xdf, 0x1e, 0xdf, 0x41, 0x04, 0x40, 0x00,
-    0x00, 0x00, 0x00, 0x14, 0x99, 0x10, 0xba, 0x10,
-    0x00, 0x00, 0x00, 0x00, 0x9b, 0x10, 0xba, 0x10,
-    0x05, 0x05, 0xa5, 0x10, 0xba, 0x10, 0x05, 0x31,
-    0x11, 0x27, 0x11, 0x32, 0x11, 0x27, 0x11, 0x55,
-    0x47, 0x13, 0x3e, 0x13, 0x47, 0x13, 0x57, 0x13,
-    0x55, 0xb9, 0x14, 0xba, 0x14, 0xb9, 0x14, 0xb0,
-    0x14, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x14, 0xbd,
-    0x14, 0x55, 0x50, 0xb8, 0x15, 0xaf, 0x15, 0xb9,
-    0x15, 0xaf, 0x15, 0x55, 0x35, 0x19, 0x30, 0x19,
-    0x05, 0x57, 0xd1, 0x65, 0xd1, 0x58, 0xd1, 0x65,
-    0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f, 0xd1, 0x6f,
-    0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f, 0xd1, 0x71,
-    0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55, 0x55, 0x55,
-    0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba, 0xd1, 0x65,
-    0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc, 0xd1, 0x6e,
-    0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc, 0xd1, 0x6f,
-    0xd1, 0x55, 0x55, 0x55, 0x41, 0x00, 0x61, 0x00,
-    0x41, 0x00, 0x61, 0x00, 0x69, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x43, 0x44, 0x00, 0x00,
-    0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00, 0x00, 0x4e,
-    0x4f, 0x50, 0x51, 0x00, 0x53, 0x54, 0x55, 0x56,
-    0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
-    0x00, 0x66, 0x68, 0x00, 0x70, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x42, 0x00, 0x44, 0x45, 0x46,
-    0x47, 0x4a, 0x00, 0x53, 0x00, 0x61, 0x00, 0x41,
-    0x42, 0x00, 0x44, 0x45, 0x46, 0x47, 0x00, 0x49,
-    0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f, 0x53, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x41, 0x00,
-    0x61, 0x00, 0x31, 0x01, 0x37, 0x02, 0x91, 0x03,
+    0xd2, 0x05, 0x07, 0x03, 0x01, 0xda, 0x05, 0x07,
+    0x03, 0x01, 0xd0, 0x02, 0xd1, 0x02, 0xe6, 0x00,
+    0x99, 0x02, 0x53, 0x02, 0x00, 0x00, 0xa3, 0x02,
+    0x66, 0xab, 0xa5, 0x02, 0xa4, 0x02, 0x56, 0x02,
+    0x57, 0x02, 0x91, 0x1d, 0x58, 0x02, 0x5e, 0x02,
+    0xa9, 0x02, 0x64, 0x02, 0x62, 0x02, 0x60, 0x02,
+    0x9b, 0x02, 0x27, 0x01, 0x9c, 0x02, 0x67, 0x02,
+    0x84, 0x02, 0xaa, 0x02, 0xab, 0x02, 0x6c, 0x02,
+    0x04, 0xdf, 0x8e, 0xa7, 0x6e, 0x02, 0x05, 0xdf,
+    0x8e, 0x02, 0x06, 0xdf, 0xf8, 0x00, 0x76, 0x02,
+    0x77, 0x02, 0x71, 0x00, 0x7a, 0x02, 0x08, 0xdf,
+    0x7d, 0x02, 0x7e, 0x02, 0x80, 0x02, 0xa8, 0x02,
+    0xa6, 0x02, 0x67, 0xab, 0xa7, 0x02, 0x88, 0x02,
+    0x71, 0x2c, 0x00, 0x00, 0x8f, 0x02, 0xa1, 0x02,
+    0xa2, 0x02, 0x98, 0x02, 0xc0, 0x01, 0xc1, 0x01,
+    0xc2, 0x01, 0x0a, 0xdf, 0x1e, 0xdf, 0x41, 0x04,
+    0x40, 0x00, 0x00, 0x00, 0x00, 0x14, 0x99, 0x10,
+    0xba, 0x10, 0x00, 0x00, 0x00, 0x00, 0x9b, 0x10,
+    0xba, 0x10, 0x05, 0x05, 0xa5, 0x10, 0xba, 0x10,
+    0x05, 0x31, 0x11, 0x27, 0x11, 0x32, 0x11, 0x27,
+    0x11, 0x55, 0x47, 0x13, 0x3e, 0x13, 0x47, 0x13,
+    0x57, 0x13, 0x55, 0x82, 0x13, 0xc9, 0x13, 0x00,
+    0x00, 0x00, 0x00, 0x84, 0x13, 0xbb, 0x13, 0x05,
+    0x05, 0x8b, 0x13, 0xc2, 0x13, 0x05, 0x90, 0x13,
+    0xc9, 0x13, 0x05, 0xc2, 0x13, 0xc2, 0x13, 0x00,
+    0x00, 0x00, 0x00, 0xc2, 0x13, 0xb8, 0x13, 0xc2,
+    0x13, 0xc9, 0x13, 0x05, 0x55, 0xb9, 0x14, 0xba,
+    0x14, 0xb9, 0x14, 0xb0, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0xb9, 0x14, 0xbd, 0x14, 0x55, 0x50, 0xb8,
+    0x15, 0xaf, 0x15, 0xb9, 0x15, 0xaf, 0x15, 0x55,
+    0x35, 0x19, 0x30, 0x19, 0x05, 0x1e, 0x61, 0x1e,
+    0x61, 0x1e, 0x61, 0x29, 0x61, 0x1e, 0x61, 0x1f,
+    0x61, 0x29, 0x61, 0x1f, 0x61, 0x1e, 0x61, 0x20,
+    0x61, 0x21, 0x61, 0x1f, 0x61, 0x22, 0x61, 0x1f,
+    0x61, 0x21, 0x61, 0x20, 0x61, 0x55, 0x55, 0x55,
+    0x55, 0x67, 0x6d, 0x67, 0x6d, 0x63, 0x6d, 0x67,
+    0x6d, 0x69, 0x6d, 0x67, 0x6d, 0x55, 0x05, 0x41,
+    0x00, 0x30, 0x00, 0x57, 0xd1, 0x65, 0xd1, 0x58,
+    0xd1, 0x65, 0xd1, 0x5f, 0xd1, 0x6e, 0xd1, 0x5f,
+    0xd1, 0x6f, 0xd1, 0x5f, 0xd1, 0x70, 0xd1, 0x5f,
+    0xd1, 0x71, 0xd1, 0x5f, 0xd1, 0x72, 0xd1, 0x55,
+    0x55, 0x55, 0x05, 0xb9, 0xd1, 0x65, 0xd1, 0xba,
+    0xd1, 0x65, 0xd1, 0xbb, 0xd1, 0x6e, 0xd1, 0xbc,
+    0xd1, 0x6e, 0xd1, 0xbb, 0xd1, 0x6f, 0xd1, 0xbc,
+    0xd1, 0x6f, 0xd1, 0x55, 0x55, 0x55, 0x41, 0x00,
+    0x61, 0x00, 0x41, 0x00, 0x61, 0x00, 0x69, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x41, 0x00, 0x43, 0x44,
+    0x00, 0x00, 0x47, 0x00, 0x00, 0x4a, 0x4b, 0x00,
+    0x00, 0x4e, 0x4f, 0x50, 0x51, 0x00, 0x53, 0x54,
+    0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62,
+    0x63, 0x64, 0x00, 0x66, 0x68, 0x00, 0x70, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x41, 0x42, 0x00, 0x44,
+    0x45, 0x46, 0x47, 0x4a, 0x00, 0x53, 0x00, 0x61,
+    0x00, 0x41, 0x42, 0x00, 0x44, 0x45, 0x46, 0x47,
+    0x00, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x00, 0x4f,
+    0x53, 0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x41, 0x00, 0x61, 0x00,
+    0x41, 0x00, 0x61, 0x00, 0x31, 0x01, 0x37, 0x02,
+    0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
+    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
     0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
     0x1f, 0x04, 0x20, 0x05, 0x91, 0x03, 0xa3, 0x03,
     0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04,
     0x20, 0x05, 0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03,
     0xd1, 0x03, 0x24, 0x00, 0x1f, 0x04, 0x20, 0x05,
     0x91, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03,
-    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x91, 0x03,
-    0xa3, 0x03, 0xb1, 0x03, 0xd1, 0x03, 0x24, 0x00,
-    0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c, 0x30, 0x00,
+    0x24, 0x00, 0x1f, 0x04, 0x20, 0x05, 0x0b, 0x0c,
     0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00,
-    0x30, 0x04, 0x3a, 0x04, 0x3e, 0x04, 0x4b, 0x04,
-    0x4d, 0x04, 0x4e, 0x04, 0x89, 0xa6, 0x30, 0x04,
-    0xa9, 0x26, 0x28, 0xb9, 0x7f, 0x9f, 0x00, 0x01,
-    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a,
-    0x0b, 0x0e, 0x0f, 0x11, 0x13, 0x14, 0x15, 0x16,
-    0x17, 0x18, 0x1a, 0x1b, 0x61, 0x26, 0x25, 0x2f,
-    0x7b, 0x51, 0xa6, 0xb1, 0x04, 0x27, 0x06, 0x00,
-    0x01, 0x05, 0x08, 0x2a, 0x06, 0x1e, 0x08, 0x03,
-    0x0d, 0x20, 0x19, 0x1a, 0x1b, 0x1c, 0x09, 0x0f,
-    0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04,
-    0x06, 0x0c, 0x0e, 0x10, 0x44, 0x90, 0x77, 0x45,
-    0x28, 0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06,
-    0x33, 0x06, 0x17, 0x10, 0x11, 0x12, 0x13, 0x00,
-    0x06, 0x0e, 0x02, 0x0f, 0x34, 0x06, 0x2a, 0x06,
-    0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00, 0x36, 0x06,
-    0x00, 0x00, 0x3a, 0x06, 0x2d, 0x06, 0x00, 0x00,
-    0x4a, 0x06, 0x00, 0x00, 0x44, 0x06, 0x00, 0x00,
-    0x46, 0x06, 0x33, 0x06, 0x39, 0x06, 0x00, 0x00,
-    0x35, 0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06,
-    0x00, 0x00, 0x00, 0x00, 0x2e, 0x06, 0x00, 0x00,
-    0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x00, 0x00,
-    0xba, 0x06, 0x00, 0x00, 0x6f, 0x06, 0x00, 0x00,
-    0x28, 0x06, 0x2c, 0x06, 0x00, 0x00, 0x47, 0x06,
-    0x00, 0x00, 0x00, 0x00, 0x2d, 0x06, 0x37, 0x06,
-    0x4a, 0x06, 0x43, 0x06, 0x00, 0x00, 0x45, 0x06,
-    0x46, 0x06, 0x33, 0x06, 0x39, 0x06, 0x41, 0x06,
-    0x35, 0x06, 0x42, 0x06, 0x00, 0x00, 0x34, 0x06,
+    0x30, 0x00, 0x30, 0x04, 0x3a, 0x04, 0x3e, 0x04,
+    0x4b, 0x04, 0x4d, 0x04, 0x4e, 0x04, 0x89, 0xa6,
+    0x30, 0x04, 0xa9, 0x26, 0x28, 0xb9, 0x7f, 0x9f,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x0a, 0x0b, 0x0e, 0x0f, 0x11, 0x13, 0x14,
+    0x15, 0x16, 0x17, 0x18, 0x1a, 0x1b, 0x61, 0x26,
+    0x25, 0x2f, 0x7b, 0x51, 0xa6, 0xb1, 0x04, 0x27,
+    0x06, 0x00, 0x01, 0x05, 0x08, 0x2a, 0x06, 0x1e,
+    0x08, 0x03, 0x0d, 0x20, 0x19, 0x1a, 0x1b, 0x1c,
+    0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00,
+    0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10, 0x44, 0x90,
+    0x77, 0x45, 0x28, 0x06, 0x2c, 0x06, 0x00, 0x00,
+    0x47, 0x06, 0x33, 0x06, 0x17, 0x10, 0x11, 0x12,
+    0x13, 0x00, 0x06, 0x0e, 0x02, 0x0f, 0x34, 0x06,
     0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06, 0x00, 0x00,
-    0x36, 0x06, 0x38, 0x06, 0x3a, 0x06, 0x6e, 0x06,
-    0x00, 0x00, 0xa1, 0x06, 0x27, 0x06, 0x00, 0x01,
-    0x05, 0x08, 0x20, 0x21, 0x0b, 0x06, 0x10, 0x23,
-    0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17,
-    0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06,
-    0x0c, 0x0e, 0x10, 0x28, 0x06, 0x2c, 0x06, 0x2f,
-    0x06, 0x00, 0x00, 0x48, 0x06, 0x32, 0x06, 0x2d,
-    0x06, 0x37, 0x06, 0x4a, 0x06, 0x2a, 0x06, 0x1a,
-    0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b, 0x18, 0x07,
-    0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c, 0x0e, 0x10,
-    0x30, 0x2e, 0x30, 0x00, 0x2c, 0x00, 0x28, 0x00,
-    0x41, 0x00, 0x29, 0x00, 0x14, 0x30, 0x53, 0x00,
-    0x15, 0x30, 0x43, 0x52, 0x43, 0x44, 0x57, 0x5a,
-    0x41, 0x00, 0x48, 0x56, 0x4d, 0x56, 0x53, 0x44,
-    0x53, 0x53, 0x50, 0x50, 0x56, 0x57, 0x43, 0x4d,
-    0x43, 0x4d, 0x44, 0x4d, 0x52, 0x44, 0x4a, 0x4b,
-    0x30, 0x30, 0x00, 0x68, 0x68, 0x4b, 0x62, 0x57,
-    0x5b, 0xcc, 0x53, 0xc7, 0x30, 0x8c, 0x4e, 0x1a,
-    0x59, 0xe3, 0x89, 0x29, 0x59, 0xa4, 0x4e, 0x20,
-    0x66, 0x21, 0x71, 0x99, 0x65, 0x4d, 0x52, 0x8c,
-    0x5f, 0x8d, 0x51, 0xb0, 0x65, 0x1d, 0x52, 0x42,
-    0x7d, 0x1f, 0x75, 0xa9, 0x8c, 0xf0, 0x58, 0x39,
-    0x54, 0x14, 0x6f, 0x95, 0x62, 0x55, 0x63, 0x00,
-    0x4e, 0x09, 0x4e, 0x4a, 0x90, 0xe6, 0x5d, 0x2d,
-    0x4e, 0xf3, 0x53, 0x07, 0x63, 0x70, 0x8d, 0x53,
-    0x62, 0x81, 0x79, 0x7a, 0x7a, 0x08, 0x54, 0x80,
-    0x6e, 0x09, 0x67, 0x08, 0x67, 0x33, 0x75, 0x72,
-    0x52, 0xb6, 0x55, 0x4d, 0x91, 0x14, 0x30, 0x15,
-    0x30, 0x2c, 0x67, 0x09, 0x4e, 0x8c, 0x4e, 0x89,
-    0x5b, 0xb9, 0x70, 0x53, 0x62, 0xd7, 0x76, 0xdd,
-    0x52, 0x57, 0x65, 0x97, 0x5f, 0xef, 0x53, 0x30,
-    0x00, 0x38, 0x4e, 0x05, 0x00, 0x09, 0x22, 0x01,
-    0x60, 0x4f, 0xae, 0x4f, 0xbb, 0x4f, 0x02, 0x50,
-    0x7a, 0x50, 0x99, 0x50, 0xe7, 0x50, 0xcf, 0x50,
-    0x9e, 0x34, 0x3a, 0x06, 0x4d, 0x51, 0x54, 0x51,
-    0x64, 0x51, 0x77, 0x51, 0x1c, 0x05, 0xb9, 0x34,
-    0x67, 0x51, 0x8d, 0x51, 0x4b, 0x05, 0x97, 0x51,
-    0xa4, 0x51, 0xcc, 0x4e, 0xac, 0x51, 0xb5, 0x51,
-    0xdf, 0x91, 0xf5, 0x51, 0x03, 0x52, 0xdf, 0x34,
-    0x3b, 0x52, 0x46, 0x52, 0x72, 0x52, 0x77, 0x52,
-    0x15, 0x35, 0x02, 0x00, 0x20, 0x80, 0x80, 0x00,
-    0x08, 0x00, 0x00, 0xc7, 0x52, 0x00, 0x02, 0x1d,
-    0x33, 0x3e, 0x3f, 0x50, 0x82, 0x8a, 0x93, 0xac,
-    0xb6, 0xb8, 0xb8, 0xb8, 0x2c, 0x0a, 0x70, 0x70,
-    0xca, 0x53, 0xdf, 0x53, 0x63, 0x0b, 0xeb, 0x53,
-    0xf1, 0x53, 0x06, 0x54, 0x9e, 0x54, 0x38, 0x54,
-    0x48, 0x54, 0x68, 0x54, 0xa2, 0x54, 0xf6, 0x54,
-    0x10, 0x55, 0x53, 0x55, 0x63, 0x55, 0x84, 0x55,
-    0x84, 0x55, 0x99, 0x55, 0xab, 0x55, 0xb3, 0x55,
-    0xc2, 0x55, 0x16, 0x57, 0x06, 0x56, 0x17, 0x57,
-    0x51, 0x56, 0x74, 0x56, 0x07, 0x52, 0xee, 0x58,
-    0xce, 0x57, 0xf4, 0x57, 0x0d, 0x58, 0x8b, 0x57,
-    0x32, 0x58, 0x31, 0x58, 0xac, 0x58, 0xe4, 0x14,
-    0xf2, 0x58, 0xf7, 0x58, 0x06, 0x59, 0x1a, 0x59,
-    0x22, 0x59, 0x62, 0x59, 0xa8, 0x16, 0xea, 0x16,
-    0xec, 0x59, 0x1b, 0x5a, 0x27, 0x5a, 0xd8, 0x59,
-    0x66, 0x5a, 0xee, 0x36, 0xfc, 0x36, 0x08, 0x5b,
-    0x3e, 0x5b, 0x3e, 0x5b, 0xc8, 0x19, 0xc3, 0x5b,
-    0xd8, 0x5b, 0xe7, 0x5b, 0xf3, 0x5b, 0x18, 0x1b,
-    0xff, 0x5b, 0x06, 0x5c, 0x53, 0x5f, 0x22, 0x5c,
-    0x81, 0x37, 0x60, 0x5c, 0x6e, 0x5c, 0xc0, 0x5c,
-    0x8d, 0x5c, 0xe4, 0x1d, 0x43, 0x5d, 0xe6, 0x1d,
-    0x6e, 0x5d, 0x6b, 0x5d, 0x7c, 0x5d, 0xe1, 0x5d,
-    0xe2, 0x5d, 0x2f, 0x38, 0xfd, 0x5d, 0x28, 0x5e,
-    0x3d, 0x5e, 0x69, 0x5e, 0x62, 0x38, 0x83, 0x21,
-    0x7c, 0x38, 0xb0, 0x5e, 0xb3, 0x5e, 0xb6, 0x5e,
-    0xca, 0x5e, 0x92, 0xa3, 0xfe, 0x5e, 0x31, 0x23,
-    0x31, 0x23, 0x01, 0x82, 0x22, 0x5f, 0x22, 0x5f,
-    0xc7, 0x38, 0xb8, 0x32, 0xda, 0x61, 0x62, 0x5f,
-    0x6b, 0x5f, 0xe3, 0x38, 0x9a, 0x5f, 0xcd, 0x5f,
-    0xd7, 0x5f, 0xf9, 0x5f, 0x81, 0x60, 0x3a, 0x39,
-    0x1c, 0x39, 0x94, 0x60, 0xd4, 0x26, 0xc7, 0x60,
-    0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x08, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x08,
-    0x00, 0x80, 0x08, 0x00, 0x00, 0x08, 0x80, 0x28,
-    0x80, 0x02, 0x00, 0x00, 0x02, 0x48, 0x61, 0x00,
-    0x04, 0x06, 0x04, 0x32, 0x46, 0x6a, 0x5c, 0x67,
-    0x96, 0xaa, 0xae, 0xc8, 0xd3, 0x5d, 0x62, 0x00,
-    0x54, 0x77, 0xf3, 0x0c, 0x2b, 0x3d, 0x63, 0xfc,
-    0x62, 0x68, 0x63, 0x83, 0x63, 0xe4, 0x63, 0xf1,
-    0x2b, 0x22, 0x64, 0xc5, 0x63, 0xa9, 0x63, 0x2e,
-    0x3a, 0x69, 0x64, 0x7e, 0x64, 0x9d, 0x64, 0x77,
-    0x64, 0x6c, 0x3a, 0x4f, 0x65, 0x6c, 0x65, 0x0a,
-    0x30, 0xe3, 0x65, 0xf8, 0x66, 0x49, 0x66, 0x19,
-    0x3b, 0x91, 0x66, 0x08, 0x3b, 0xe4, 0x3a, 0x92,
-    0x51, 0x95, 0x51, 0x00, 0x67, 0x9c, 0x66, 0xad,
-    0x80, 0xd9, 0x43, 0x17, 0x67, 0x1b, 0x67, 0x21,
-    0x67, 0x5e, 0x67, 0x53, 0x67, 0xc3, 0x33, 0x49,
-    0x3b, 0xfa, 0x67, 0x85, 0x67, 0x52, 0x68, 0x85,
-    0x68, 0x6d, 0x34, 0x8e, 0x68, 0x1f, 0x68, 0x14,
-    0x69, 0x9d, 0x3b, 0x42, 0x69, 0xa3, 0x69, 0xea,
-    0x69, 0xa8, 0x6a, 0xa3, 0x36, 0xdb, 0x6a, 0x18,
-    0x3c, 0x21, 0x6b, 0xa7, 0x38, 0x54, 0x6b, 0x4e,
-    0x3c, 0x72, 0x6b, 0x9f, 0x6b, 0xba, 0x6b, 0xbb,
-    0x6b, 0x8d, 0x3a, 0x0b, 0x1d, 0xfa, 0x3a, 0x4e,
-    0x6c, 0xbc, 0x3c, 0xbf, 0x6c, 0xcd, 0x6c, 0x67,
-    0x6c, 0x16, 0x6d, 0x3e, 0x6d, 0x77, 0x6d, 0x41,
-    0x6d, 0x69, 0x6d, 0x78, 0x6d, 0x85, 0x6d, 0x1e,
-    0x3d, 0x34, 0x6d, 0x2f, 0x6e, 0x6e, 0x6e, 0x33,
-    0x3d, 0xcb, 0x6e, 0xc7, 0x6e, 0xd1, 0x3e, 0xf9,
-    0x6d, 0x6e, 0x6f, 0x5e, 0x3f, 0x8e, 0x3f, 0xc6,
-    0x6f, 0x39, 0x70, 0x1e, 0x70, 0x1b, 0x70, 0x96,
-    0x3d, 0x4a, 0x70, 0x7d, 0x70, 0x77, 0x70, 0xad,
-    0x70, 0x25, 0x05, 0x45, 0x71, 0x63, 0x42, 0x9c,
-    0x71, 0xab, 0x43, 0x28, 0x72, 0x35, 0x72, 0x50,
-    0x72, 0x08, 0x46, 0x80, 0x72, 0x95, 0x72, 0x35,
-    0x47, 0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00,
-    0x00, 0x00, 0x08, 0x80, 0x00, 0x00, 0x02, 0x02,
-    0x80, 0x8a, 0x00, 0x00, 0x20, 0x00, 0x08, 0x0a,
-    0x00, 0x80, 0x88, 0x80, 0x20, 0x14, 0x48, 0x7a,
-    0x73, 0x8b, 0x73, 0xac, 0x3e, 0xa5, 0x73, 0xb8,
-    0x3e, 0xb8, 0x3e, 0x47, 0x74, 0x5c, 0x74, 0x71,
-    0x74, 0x85, 0x74, 0xca, 0x74, 0x1b, 0x3f, 0x24,
-    0x75, 0x36, 0x4c, 0x3e, 0x75, 0x92, 0x4c, 0x70,
-    0x75, 0x9f, 0x21, 0x10, 0x76, 0xa1, 0x4f, 0xb8,
-    0x4f, 0x44, 0x50, 0xfc, 0x3f, 0x08, 0x40, 0xf4,
-    0x76, 0xf3, 0x50, 0xf2, 0x50, 0x19, 0x51, 0x33,
-    0x51, 0x1e, 0x77, 0x1f, 0x77, 0x1f, 0x77, 0x4a,
-    0x77, 0x39, 0x40, 0x8b, 0x77, 0x46, 0x40, 0x96,
-    0x40, 0x1d, 0x54, 0x4e, 0x78, 0x8c, 0x78, 0xcc,
-    0x78, 0xe3, 0x40, 0x26, 0x56, 0x56, 0x79, 0x9a,
-    0x56, 0xc5, 0x56, 0x8f, 0x79, 0xeb, 0x79, 0x2f,
-    0x41, 0x40, 0x7a, 0x4a, 0x7a, 0x4f, 0x7a, 0x7c,
-    0x59, 0xa7, 0x5a, 0xa7, 0x5a, 0xee, 0x7a, 0x02,
-    0x42, 0xab, 0x5b, 0xc6, 0x7b, 0xc9, 0x7b, 0x27,
-    0x42, 0x80, 0x5c, 0xd2, 0x7c, 0xa0, 0x42, 0xe8,
-    0x7c, 0xe3, 0x7c, 0x00, 0x7d, 0x86, 0x5f, 0x63,
-    0x7d, 0x01, 0x43, 0xc7, 0x7d, 0x02, 0x7e, 0x45,
-    0x7e, 0x34, 0x43, 0x28, 0x62, 0x47, 0x62, 0x59,
-    0x43, 0xd9, 0x62, 0x7a, 0x7f, 0x3e, 0x63, 0x95,
-    0x7f, 0xfa, 0x7f, 0x05, 0x80, 0xda, 0x64, 0x23,
-    0x65, 0x60, 0x80, 0xa8, 0x65, 0x70, 0x80, 0x5f,
-    0x33, 0xd5, 0x43, 0xb2, 0x80, 0x03, 0x81, 0x0b,
-    0x44, 0x3e, 0x81, 0xb5, 0x5a, 0xa7, 0x67, 0xb5,
-    0x67, 0x93, 0x33, 0x9c, 0x33, 0x01, 0x82, 0x04,
-    0x82, 0x9e, 0x8f, 0x6b, 0x44, 0x91, 0x82, 0x8b,
-    0x82, 0x9d, 0x82, 0xb3, 0x52, 0xb1, 0x82, 0xb3,
-    0x82, 0xbd, 0x82, 0xe6, 0x82, 0x3c, 0x6b, 0xe5,
-    0x82, 0x1d, 0x83, 0x63, 0x83, 0xad, 0x83, 0x23,
-    0x83, 0xbd, 0x83, 0xe7, 0x83, 0x57, 0x84, 0x53,
-    0x83, 0xca, 0x83, 0xcc, 0x83, 0xdc, 0x83, 0x36,
-    0x6c, 0x6b, 0x6d, 0x02, 0x00, 0x00, 0x20, 0x22,
-    0x2a, 0xa0, 0x0a, 0x00, 0x20, 0x80, 0x28, 0x00,
-    0xa8, 0x20, 0x20, 0x00, 0x02, 0x80, 0x22, 0x02,
-    0x8a, 0x08, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x02,
-    0x00, 0x00, 0x28, 0xd5, 0x6c, 0x2b, 0x45, 0xf1,
-    0x84, 0xf3, 0x84, 0x16, 0x85, 0xca, 0x73, 0x64,
-    0x85, 0x2c, 0x6f, 0x5d, 0x45, 0x61, 0x45, 0xb1,
-    0x6f, 0xd2, 0x70, 0x6b, 0x45, 0x50, 0x86, 0x5c,
-    0x86, 0x67, 0x86, 0x69, 0x86, 0xa9, 0x86, 0x88,
-    0x86, 0x0e, 0x87, 0xe2, 0x86, 0x79, 0x87, 0x28,
-    0x87, 0x6b, 0x87, 0x86, 0x87, 0xd7, 0x45, 0xe1,
-    0x87, 0x01, 0x88, 0xf9, 0x45, 0x60, 0x88, 0x63,
-    0x88, 0x67, 0x76, 0xd7, 0x88, 0xde, 0x88, 0x35,
-    0x46, 0xfa, 0x88, 0xbb, 0x34, 0xae, 0x78, 0x66,
-    0x79, 0xbe, 0x46, 0xc7, 0x46, 0xa0, 0x8a, 0xed,
-    0x8a, 0x8a, 0x8b, 0x55, 0x8c, 0xa8, 0x7c, 0xab,
-    0x8c, 0xc1, 0x8c, 0x1b, 0x8d, 0x77, 0x8d, 0x2f,
-    0x7f, 0x04, 0x08, 0xcb, 0x8d, 0xbc, 0x8d, 0xf0,
-    0x8d, 0xde, 0x08, 0xd4, 0x8e, 0x38, 0x8f, 0xd2,
-    0x85, 0xed, 0x85, 0x94, 0x90, 0xf1, 0x90, 0x11,
-    0x91, 0x2e, 0x87, 0x1b, 0x91, 0x38, 0x92, 0xd7,
-    0x92, 0xd8, 0x92, 0x7c, 0x92, 0xf9, 0x93, 0x15,
-    0x94, 0xfa, 0x8b, 0x8b, 0x95, 0x95, 0x49, 0xb7,
-    0x95, 0x77, 0x8d, 0xe6, 0x49, 0xc3, 0x96, 0xb2,
-    0x5d, 0x23, 0x97, 0x45, 0x91, 0x1a, 0x92, 0x6e,
-    0x4a, 0x76, 0x4a, 0xe0, 0x97, 0x0a, 0x94, 0xb2,
-    0x4a, 0x96, 0x94, 0x0b, 0x98, 0x0b, 0x98, 0x29,
-    0x98, 0xb6, 0x95, 0xe2, 0x98, 0x33, 0x4b, 0x29,
-    0x99, 0xa7, 0x99, 0xc2, 0x99, 0xfe, 0x99, 0xce,
-    0x4b, 0x30, 0x9b, 0x12, 0x9b, 0x40, 0x9c, 0xfd,
-    0x9c, 0xce, 0x4c, 0xed, 0x4c, 0x67, 0x9d, 0xce,
-    0xa0, 0xf8, 0x4c, 0x05, 0xa1, 0x0e, 0xa2, 0x91,
-    0xa2, 0xbb, 0x9e, 0x56, 0x4d, 0xf9, 0x9e, 0xfe,
-    0x9e, 0x05, 0x9f, 0x0f, 0x9f, 0x16, 0x9f, 0x3b,
-    0x9f, 0x00, 0xa6, 0x02, 0x88, 0xa0, 0x00, 0x00,
-    0x00, 0x00, 0x80, 0x00, 0x28, 0x00, 0x08, 0xa0,
-    0x80, 0xa0, 0x80, 0x00, 0x80, 0x80, 0x00, 0x0a,
-    0x88, 0x80, 0x00, 0x80, 0x00, 0x20, 0x2a, 0x00,
-    0x80,
+    0x36, 0x06, 0x00, 0x00, 0x3a, 0x06, 0x2d, 0x06,
+    0x00, 0x00, 0x4a, 0x06, 0x00, 0x00, 0x44, 0x06,
+    0x00, 0x00, 0x46, 0x06, 0x33, 0x06, 0x39, 0x06,
+    0x00, 0x00, 0x35, 0x06, 0x42, 0x06, 0x00, 0x00,
+    0x34, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x06,
+    0x00, 0x00, 0x36, 0x06, 0x00, 0x00, 0x3a, 0x06,
+    0x00, 0x00, 0xba, 0x06, 0x00, 0x00, 0x6f, 0x06,
+    0x00, 0x00, 0x28, 0x06, 0x2c, 0x06, 0x00, 0x00,
+    0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x06,
+    0x37, 0x06, 0x4a, 0x06, 0x43, 0x06, 0x00, 0x00,
+    0x45, 0x06, 0x46, 0x06, 0x33, 0x06, 0x39, 0x06,
+    0x41, 0x06, 0x35, 0x06, 0x42, 0x06, 0x00, 0x00,
+    0x34, 0x06, 0x2a, 0x06, 0x2b, 0x06, 0x2e, 0x06,
+    0x00, 0x00, 0x36, 0x06, 0x38, 0x06, 0x3a, 0x06,
+    0x6e, 0x06, 0x00, 0x00, 0xa1, 0x06, 0x27, 0x06,
+    0x00, 0x01, 0x05, 0x08, 0x20, 0x21, 0x0b, 0x06,
+    0x10, 0x23, 0x2a, 0x06, 0x1a, 0x1b, 0x1c, 0x09,
+    0x0f, 0x17, 0x0b, 0x18, 0x07, 0x0a, 0x00, 0x01,
+    0x04, 0x06, 0x0c, 0x0e, 0x10, 0x28, 0x06, 0x2c,
+    0x06, 0x2f, 0x06, 0x00, 0x00, 0x48, 0x06, 0x32,
+    0x06, 0x2d, 0x06, 0x37, 0x06, 0x4a, 0x06, 0x2a,
+    0x06, 0x1a, 0x1b, 0x1c, 0x09, 0x0f, 0x17, 0x0b,
+    0x18, 0x07, 0x0a, 0x00, 0x01, 0x04, 0x06, 0x0c,
+    0x0e, 0x10, 0x30, 0x2e, 0x30, 0x00, 0x2c, 0x00,
+    0x28, 0x00, 0x41, 0x00, 0x29, 0x00, 0x14, 0x30,
+    0x53, 0x00, 0x15, 0x30, 0x43, 0x52, 0x43, 0x44,
+    0x57, 0x5a, 0x41, 0x00, 0x48, 0x56, 0x4d, 0x56,
+    0x53, 0x44, 0x53, 0x53, 0x50, 0x50, 0x56, 0x57,
+    0x43, 0x4d, 0x43, 0x4d, 0x44, 0x4d, 0x52, 0x44,
+    0x4a, 0x4b, 0x30, 0x30, 0x00, 0x68, 0x68, 0x4b,
+    0x62, 0x57, 0x5b, 0xcc, 0x53, 0xc7, 0x30, 0x8c,
+    0x4e, 0x1a, 0x59, 0xe3, 0x89, 0x29, 0x59, 0xa4,
+    0x4e, 0x20, 0x66, 0x21, 0x71, 0x99, 0x65, 0x4d,
+    0x52, 0x8c, 0x5f, 0x8d, 0x51, 0xb0, 0x65, 0x1d,
+    0x52, 0x42, 0x7d, 0x1f, 0x75, 0xa9, 0x8c, 0xf0,
+    0x58, 0x39, 0x54, 0x14, 0x6f, 0x95, 0x62, 0x55,
+    0x63, 0x00, 0x4e, 0x09, 0x4e, 0x4a, 0x90, 0xe6,
+    0x5d, 0x2d, 0x4e, 0xf3, 0x53, 0x07, 0x63, 0x70,
+    0x8d, 0x53, 0x62, 0x81, 0x79, 0x7a, 0x7a, 0x08,
+    0x54, 0x80, 0x6e, 0x09, 0x67, 0x08, 0x67, 0x33,
+    0x75, 0x72, 0x52, 0xb6, 0x55, 0x4d, 0x91, 0x14,
+    0x30, 0x15, 0x30, 0x2c, 0x67, 0x09, 0x4e, 0x8c,
+    0x4e, 0x89, 0x5b, 0xb9, 0x70, 0x53, 0x62, 0xd7,
+    0x76, 0xdd, 0x52, 0x57, 0x65, 0x97, 0x5f, 0xef,
+    0x53, 0x30, 0x00, 0x38, 0x4e, 0x05, 0x00, 0x09,
+    0x22, 0x01, 0x60, 0x4f, 0xae, 0x4f, 0xbb, 0x4f,
+    0x02, 0x50, 0x7a, 0x50, 0x99, 0x50, 0xe7, 0x50,
+    0xcf, 0x50, 0x9e, 0x34, 0x3a, 0x06, 0x4d, 0x51,
+    0x54, 0x51, 0x64, 0x51, 0x77, 0x51, 0x1c, 0x05,
+    0xb9, 0x34, 0x67, 0x51, 0x8d, 0x51, 0x4b, 0x05,
+    0x97, 0x51, 0xa4, 0x51, 0xcc, 0x4e, 0xac, 0x51,
+    0xb5, 0x51, 0xdf, 0x91, 0xf5, 0x51, 0x03, 0x52,
+    0xdf, 0x34, 0x3b, 0x52, 0x46, 0x52, 0x72, 0x52,
+    0x77, 0x52, 0x15, 0x35, 0x02, 0x00, 0x20, 0x80,
+    0x80, 0x00, 0x08, 0x00, 0x00, 0xc7, 0x52, 0x00,
+    0x02, 0x1d, 0x33, 0x3e, 0x3f, 0x50, 0x82, 0x8a,
+    0x93, 0xac, 0xb6, 0xb8, 0xb8, 0xb8, 0x2c, 0x0a,
+    0x70, 0x70, 0xca, 0x53, 0xdf, 0x53, 0x63, 0x0b,
+    0xeb, 0x53, 0xf1, 0x53, 0x06, 0x54, 0x9e, 0x54,
+    0x38, 0x54, 0x48, 0x54, 0x68, 0x54, 0xa2, 0x54,
+    0xf6, 0x54, 0x10, 0x55, 0x53, 0x55, 0x63, 0x55,
+    0x84, 0x55, 0x84, 0x55, 0x99, 0x55, 0xab, 0x55,
+    0xb3, 0x55, 0xc2, 0x55, 0x16, 0x57, 0x06, 0x56,
+    0x17, 0x57, 0x51, 0x56, 0x74, 0x56, 0x07, 0x52,
+    0xee, 0x58, 0xce, 0x57, 0xf4, 0x57, 0x0d, 0x58,
+    0x8b, 0x57, 0x32, 0x58, 0x31, 0x58, 0xac, 0x58,
+    0xe4, 0x14, 0xf2, 0x58, 0xf7, 0x58, 0x06, 0x59,
+    0x1a, 0x59, 0x22, 0x59, 0x62, 0x59, 0xa8, 0x16,
+    0xea, 0x16, 0xec, 0x59, 0x1b, 0x5a, 0x27, 0x5a,
+    0xd8, 0x59, 0x66, 0x5a, 0xee, 0x36, 0xfc, 0x36,
+    0x08, 0x5b, 0x3e, 0x5b, 0x3e, 0x5b, 0xc8, 0x19,
+    0xc3, 0x5b, 0xd8, 0x5b, 0xe7, 0x5b, 0xf3, 0x5b,
+    0x18, 0x1b, 0xff, 0x5b, 0x06, 0x5c, 0x53, 0x5f,
+    0x22, 0x5c, 0x81, 0x37, 0x60, 0x5c, 0x6e, 0x5c,
+    0xc0, 0x5c, 0x8d, 0x5c, 0xe4, 0x1d, 0x43, 0x5d,
+    0xe6, 0x1d, 0x6e, 0x5d, 0x6b, 0x5d, 0x7c, 0x5d,
+    0xe1, 0x5d, 0xe2, 0x5d, 0x2f, 0x38, 0xfd, 0x5d,
+    0x28, 0x5e, 0x3d, 0x5e, 0x69, 0x5e, 0x62, 0x38,
+    0x83, 0x21, 0x7c, 0x38, 0xb0, 0x5e, 0xb3, 0x5e,
+    0xb6, 0x5e, 0xca, 0x5e, 0x92, 0xa3, 0xfe, 0x5e,
+    0x31, 0x23, 0x31, 0x23, 0x01, 0x82, 0x22, 0x5f,
+    0x22, 0x5f, 0xc7, 0x38, 0xb8, 0x32, 0xda, 0x61,
+    0x62, 0x5f, 0x6b, 0x5f, 0xe3, 0x38, 0x9a, 0x5f,
+    0xcd, 0x5f, 0xd7, 0x5f, 0xf9, 0x5f, 0x81, 0x60,
+    0x3a, 0x39, 0x1c, 0x39, 0x94, 0x60, 0xd4, 0x26,
+    0xc7, 0x60, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x00,
+    0x02, 0x08, 0x00, 0x80, 0x08, 0x00, 0x00, 0x08,
+    0x80, 0x28, 0x80, 0x02, 0x00, 0x00, 0x02, 0x48,
+    0x61, 0x00, 0x04, 0x06, 0x04, 0x32, 0x46, 0x6a,
+    0x5c, 0x67, 0x96, 0xaa, 0xae, 0xc8, 0xd3, 0x5d,
+    0x62, 0x00, 0x54, 0x77, 0xf3, 0x0c, 0x2b, 0x3d,
+    0x63, 0xfc, 0x62, 0x68, 0x63, 0x83, 0x63, 0xe4,
+    0x63, 0xf1, 0x2b, 0x22, 0x64, 0xc5, 0x63, 0xa9,
+    0x63, 0x2e, 0x3a, 0x69, 0x64, 0x7e, 0x64, 0x9d,
+    0x64, 0x77, 0x64, 0x6c, 0x3a, 0x4f, 0x65, 0x6c,
+    0x65, 0x0a, 0x30, 0xe3, 0x65, 0xf8, 0x66, 0x49,
+    0x66, 0x19, 0x3b, 0x91, 0x66, 0x08, 0x3b, 0xe4,
+    0x3a, 0x92, 0x51, 0x95, 0x51, 0x00, 0x67, 0x9c,
+    0x66, 0xad, 0x80, 0xd9, 0x43, 0x17, 0x67, 0x1b,
+    0x67, 0x21, 0x67, 0x5e, 0x67, 0x53, 0x67, 0xc3,
+    0x33, 0x49, 0x3b, 0xfa, 0x67, 0x85, 0x67, 0x52,
+    0x68, 0x85, 0x68, 0x6d, 0x34, 0x8e, 0x68, 0x1f,
+    0x68, 0x14, 0x69, 0x9d, 0x3b, 0x42, 0x69, 0xa3,
+    0x69, 0xea, 0x69, 0xa8, 0x6a, 0xa3, 0x36, 0xdb,
+    0x6a, 0x18, 0x3c, 0x21, 0x6b, 0xa7, 0x38, 0x54,
+    0x6b, 0x4e, 0x3c, 0x72, 0x6b, 0x9f, 0x6b, 0xba,
+    0x6b, 0xbb, 0x6b, 0x8d, 0x3a, 0x0b, 0x1d, 0xfa,
+    0x3a, 0x4e, 0x6c, 0xbc, 0x3c, 0xbf, 0x6c, 0xcd,
+    0x6c, 0x67, 0x6c, 0x16, 0x6d, 0x3e, 0x6d, 0x77,
+    0x6d, 0x41, 0x6d, 0x69, 0x6d, 0x78, 0x6d, 0x85,
+    0x6d, 0x1e, 0x3d, 0x34, 0x6d, 0x2f, 0x6e, 0x6e,
+    0x6e, 0x33, 0x3d, 0xcb, 0x6e, 0xc7, 0x6e, 0xd1,
+    0x3e, 0xf9, 0x6d, 0x6e, 0x6f, 0x5e, 0x3f, 0x8e,
+    0x3f, 0xc6, 0x6f, 0x39, 0x70, 0x1e, 0x70, 0x1b,
+    0x70, 0x96, 0x3d, 0x4a, 0x70, 0x7d, 0x70, 0x77,
+    0x70, 0xad, 0x70, 0x25, 0x05, 0x45, 0x71, 0x63,
+    0x42, 0x9c, 0x71, 0xab, 0x43, 0x28, 0x72, 0x35,
+    0x72, 0x50, 0x72, 0x08, 0x46, 0x80, 0x72, 0x95,
+    0x72, 0x35, 0x47, 0x02, 0x20, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x80, 0x00, 0x00,
+    0x02, 0x02, 0x80, 0x8a, 0x00, 0x00, 0x20, 0x00,
+    0x08, 0x0a, 0x00, 0x80, 0x88, 0x80, 0x20, 0x14,
+    0x48, 0x7a, 0x73, 0x8b, 0x73, 0xac, 0x3e, 0xa5,
+    0x73, 0xb8, 0x3e, 0xb8, 0x3e, 0x47, 0x74, 0x5c,
+    0x74, 0x71, 0x74, 0x85, 0x74, 0xca, 0x74, 0x1b,
+    0x3f, 0x24, 0x75, 0x36, 0x4c, 0x3e, 0x75, 0x92,
+    0x4c, 0x70, 0x75, 0x9f, 0x21, 0x10, 0x76, 0xa1,
+    0x4f, 0xb8, 0x4f, 0x44, 0x50, 0xfc, 0x3f, 0x08,
+    0x40, 0xf4, 0x76, 0xf3, 0x50, 0xf2, 0x50, 0x19,
+    0x51, 0x33, 0x51, 0x1e, 0x77, 0x1f, 0x77, 0x1f,
+    0x77, 0x4a, 0x77, 0x39, 0x40, 0x8b, 0x77, 0x46,
+    0x40, 0x96, 0x40, 0x1d, 0x54, 0x4e, 0x78, 0x8c,
+    0x78, 0xcc, 0x78, 0xe3, 0x40, 0x26, 0x56, 0x56,
+    0x79, 0x9a, 0x56, 0xc5, 0x56, 0x8f, 0x79, 0xeb,
+    0x79, 0x2f, 0x41, 0x40, 0x7a, 0x4a, 0x7a, 0x4f,
+    0x7a, 0x7c, 0x59, 0xa7, 0x5a, 0xa7, 0x5a, 0xee,
+    0x7a, 0x02, 0x42, 0xab, 0x5b, 0xc6, 0x7b, 0xc9,
+    0x7b, 0x27, 0x42, 0x80, 0x5c, 0xd2, 0x7c, 0xa0,
+    0x42, 0xe8, 0x7c, 0xe3, 0x7c, 0x00, 0x7d, 0x86,
+    0x5f, 0x63, 0x7d, 0x01, 0x43, 0xc7, 0x7d, 0x02,
+    0x7e, 0x45, 0x7e, 0x34, 0x43, 0x28, 0x62, 0x47,
+    0x62, 0x59, 0x43, 0xd9, 0x62, 0x7a, 0x7f, 0x3e,
+    0x63, 0x95, 0x7f, 0xfa, 0x7f, 0x05, 0x80, 0xda,
+    0x64, 0x23, 0x65, 0x60, 0x80, 0xa8, 0x65, 0x70,
+    0x80, 0x5f, 0x33, 0xd5, 0x43, 0xb2, 0x80, 0x03,
+    0x81, 0x0b, 0x44, 0x3e, 0x81, 0xb5, 0x5a, 0xa7,
+    0x67, 0xb5, 0x67, 0x93, 0x33, 0x9c, 0x33, 0x01,
+    0x82, 0x04, 0x82, 0x9e, 0x8f, 0x6b, 0x44, 0x91,
+    0x82, 0x8b, 0x82, 0x9d, 0x82, 0xb3, 0x52, 0xb1,
+    0x82, 0xb3, 0x82, 0xbd, 0x82, 0xe6, 0x82, 0x3c,
+    0x6b, 0xe5, 0x82, 0x1d, 0x83, 0x63, 0x83, 0xad,
+    0x83, 0x23, 0x83, 0xbd, 0x83, 0xe7, 0x83, 0x57,
+    0x84, 0x53, 0x83, 0xca, 0x83, 0xcc, 0x83, 0xdc,
+    0x83, 0x36, 0x6c, 0x6b, 0x6d, 0x02, 0x00, 0x00,
+    0x20, 0x22, 0x2a, 0xa0, 0x0a, 0x00, 0x20, 0x80,
+    0x28, 0x00, 0xa8, 0x20, 0x20, 0x00, 0x02, 0x80,
+    0x22, 0x02, 0x8a, 0x08, 0x00, 0xaa, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x28, 0xd5, 0x6c, 0x2b,
+    0x45, 0xf1, 0x84, 0xf3, 0x84, 0x16, 0x85, 0xca,
+    0x73, 0x64, 0x85, 0x2c, 0x6f, 0x5d, 0x45, 0x61,
+    0x45, 0xb1, 0x6f, 0xd2, 0x70, 0x6b, 0x45, 0x50,
+    0x86, 0x5c, 0x86, 0x67, 0x86, 0x69, 0x86, 0xa9,
+    0x86, 0x88, 0x86, 0x0e, 0x87, 0xe2, 0x86, 0x79,
+    0x87, 0x28, 0x87, 0x6b, 0x87, 0x86, 0x87, 0xd7,
+    0x45, 0xe1, 0x87, 0x01, 0x88, 0xf9, 0x45, 0x60,
+    0x88, 0x63, 0x88, 0x67, 0x76, 0xd7, 0x88, 0xde,
+    0x88, 0x35, 0x46, 0xfa, 0x88, 0xbb, 0x34, 0xae,
+    0x78, 0x66, 0x79, 0xbe, 0x46, 0xc7, 0x46, 0xa0,
+    0x8a, 0xed, 0x8a, 0x8a, 0x8b, 0x55, 0x8c, 0xa8,
+    0x7c, 0xab, 0x8c, 0xc1, 0x8c, 0x1b, 0x8d, 0x77,
+    0x8d, 0x2f, 0x7f, 0x04, 0x08, 0xcb, 0x8d, 0xbc,
+    0x8d, 0xf0, 0x8d, 0xde, 0x08, 0xd4, 0x8e, 0x38,
+    0x8f, 0xd2, 0x85, 0xed, 0x85, 0x94, 0x90, 0xf1,
+    0x90, 0x11, 0x91, 0x2e, 0x87, 0x1b, 0x91, 0x38,
+    0x92, 0xd7, 0x92, 0xd8, 0x92, 0x7c, 0x92, 0xf9,
+    0x93, 0x15, 0x94, 0xfa, 0x8b, 0x8b, 0x95, 0x95,
+    0x49, 0xb7, 0x95, 0x77, 0x8d, 0xe6, 0x49, 0xc3,
+    0x96, 0xb2, 0x5d, 0x23, 0x97, 0x45, 0x91, 0x1a,
+    0x92, 0x6e, 0x4a, 0x76, 0x4a, 0xe0, 0x97, 0x0a,
+    0x94, 0xb2, 0x4a, 0x96, 0x94, 0x0b, 0x98, 0x0b,
+    0x98, 0x29, 0x98, 0xb6, 0x95, 0xe2, 0x98, 0x33,
+    0x4b, 0x29, 0x99, 0xa7, 0x99, 0xc2, 0x99, 0xfe,
+    0x99, 0xce, 0x4b, 0x30, 0x9b, 0x12, 0x9b, 0x40,
+    0x9c, 0xfd, 0x9c, 0xce, 0x4c, 0xed, 0x4c, 0x67,
+    0x9d, 0xce, 0xa0, 0xf8, 0x4c, 0x05, 0xa1, 0x0e,
+    0xa2, 0x91, 0xa2, 0xbb, 0x9e, 0x56, 0x4d, 0xf9,
+    0x9e, 0xfe, 0x9e, 0x05, 0x9f, 0x0f, 0x9f, 0x16,
+    0x9f, 0x3b, 0x9f, 0x00, 0xa6, 0x02, 0x88, 0xa0,
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x28, 0x00,
+    0x08, 0xa0, 0x80, 0xa0, 0x80, 0x00, 0x80, 0x80,
+    0x00, 0x0a, 0x88, 0x80, 0x00, 0x80, 0x00, 0x20,
+    0x2a, 0x00, 0x80,
 };
 
-static const uint16_t unicode_comp_table[945] = {
+static const uint16_t unicode_comp_table[965] = {
     0x4a01, 0x49c0, 0x4a02, 0x0280, 0x0281, 0x0282, 0x0283, 0x02c0,
     0x02c2, 0x0a00, 0x0284, 0x2442, 0x0285, 0x07c0, 0x0980, 0x0982,
     0x2440, 0x2280, 0x02c4, 0x2282, 0x2284, 0x2286, 0x02c6, 0x02c8,
@@ -2247,9 +2352,11 @@ static const uint16_t unicode_comp_table[945] = {
     0x5704, 0x5706, 0x5708, 0x570a, 0x570c, 0x570e, 0x5710, 0x5712,
     0x5714, 0x5716, 0x5740, 0x5742, 0x5744, 0x5780, 0x5781, 0x57c0,
     0x57c1, 0x5800, 0x5801, 0x5840, 0x5841, 0x5880, 0x5881, 0x5900,
-    0x5901, 0x5902, 0x5903, 0x5940, 0x8f40, 0x8f42, 0x8f80, 0x8fc0,
-    0x8fc1, 0x9000, 0x9001, 0x9041, 0x9040, 0x9043, 0x9080, 0x9081,
-    0x90c0,
+    0x5901, 0x5902, 0x5903, 0x5940, 0x8ec0, 0x8f00, 0x8fc0, 0x8fc2,
+    0x9000, 0x9040, 0x9041, 0x9080, 0x9081, 0x90c0, 0x90c2, 0x9100,
+    0x9140, 0x9182, 0x9180, 0x9183, 0x91c1, 0x91c0, 0x91c3, 0x9200,
+    0x9201, 0x9240, 0x9280, 0x9282, 0x9284, 0x9281, 0x9285, 0x9287,
+    0x9286, 0x9283, 0x92c1, 0x92c0, 0x92c2,
 };
 
 typedef enum {
@@ -2335,7 +2442,7 @@ static const char unicode_gc_name_table[] =
     "C,Other"                  "\0"
 ;
 
-static const uint8_t unicode_gc_table[3948] = {
+static const uint8_t unicode_gc_table[4070] = {
     0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13,
     0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
     0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e,
@@ -2379,8 +2486,8 @@ static const uint8_t unicode_gc_table[3948] = {
     0x2d, 0xe5, 0x0e, 0x66, 0x04, 0xe6, 0x01, 0x04,
     0x46, 0x04, 0x86, 0x20, 0xf6, 0x07, 0x00, 0xe5,
     0x11, 0x46, 0x20, 0x16, 0x00, 0xe5, 0x03, 0x80,
-    0xe5, 0x10, 0x0e, 0xa5, 0x00, 0x3b, 0xa0, 0xe6,
-    0x00, 0xe5, 0x21, 0x04, 0xe6, 0x10, 0x1b, 0xe6,
+    0xe5, 0x10, 0x0e, 0xa5, 0x00, 0x3b, 0x80, 0xe6,
+    0x01, 0xe5, 0x21, 0x04, 0xe6, 0x10, 0x1b, 0xe6,
     0x18, 0x07, 0xe5, 0x2e, 0x06, 0x07, 0x06, 0x05,
     0x47, 0xe6, 0x00, 0x67, 0x06, 0x27, 0x05, 0xc6,
     0xe5, 0x02, 0x26, 0x36, 0xe9, 0x02, 0x16, 0x04,
@@ -2479,82 +2586,82 @@ static const uint8_t unicode_gc_table[3948] = {
     0xe9, 0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20, 0xe6,
     0x06, 0x08, 0xe6, 0x08, 0xe0, 0x29, 0x66, 0x07,
     0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87,
-    0x06, 0x27, 0xe5, 0x00, 0x40, 0xe9, 0x02, 0xd6,
-    0xef, 0x02, 0xe6, 0x01, 0xef, 0x01, 0x36, 0x00,
+    0x06, 0x27, 0xe5, 0x00, 0x00, 0x36, 0xe9, 0x02,
+    0xd6, 0xef, 0x02, 0xe6, 0x01, 0xef, 0x01, 0x56,
     0x26, 0x07, 0xe5, 0x16, 0x07, 0x66, 0x27, 0x26,
     0x07, 0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06,
     0x07, 0x26, 0x47, 0x06, 0x07, 0x46, 0x27, 0xe0,
     0x00, 0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00,
     0x27, 0x26, 0x40, 0x96, 0xe9, 0x02, 0x40, 0x45,
     0xe9, 0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01,
-    0xc0, 0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00, 0xe0,
-    0x00, 0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65,
-    0x06, 0xa5, 0x06, 0x25, 0x07, 0x26, 0x05, 0x80,
-    0xe2, 0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2,
-    0x1a, 0xe4, 0x1d, 0xe6, 0x38, 0xff, 0x80, 0x0e,
-    0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00,
-    0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1, 0x00,
-    0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20,
-    0xe2, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
-    0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20,
-    0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00,
-    0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61,
-    0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22, 0x61,
-    0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e,
-    0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42, 0x00, 0x22,
-    0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1,
-    0x36, 0x14, 0x15, 0x12, 0x34, 0x15, 0x12, 0x14,
-    0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01,
-    0x14, 0x15, 0x76, 0x30, 0x56, 0x0c, 0x12, 0x13,
-    0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17,
-    0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20, 0xab,
-    0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12,
-    0x13, 0x00, 0xe4, 0x05, 0x40, 0xed, 0x19, 0xe0,
-    0x07, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04,
-    0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f, 0x02,
-    0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c,
-    0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01, 0x0f,
-    0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f,
-    0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c, 0x2f,
-    0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a,
-    0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f, 0x0c,
-    0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17,
-    0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17, 0xec,
-    0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13,
-    0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef, 0x49,
-    0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac,
-    0xef, 0x3d, 0xe0, 0x11, 0xef, 0x03, 0xe0, 0x0d,
-    0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80,
-    0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e, 0xec,
-    0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef,
-    0x24, 0x8c, 0x12, 0x13, 0xec, 0x17, 0x12, 0x13,
+    0x3f, 0x80, 0xe1, 0x23, 0x20, 0x41, 0xf6, 0x00,
+    0xe0, 0x00, 0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6,
+    0x65, 0x06, 0xa5, 0x06, 0x25, 0x07, 0x26, 0x05,
+    0x80, 0xe2, 0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04,
+    0xe2, 0x1a, 0xe4, 0x1d, 0xe6, 0x38, 0xff, 0x80,
+    0x0e, 0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1,
+    0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0xe1,
+    0x00, 0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1,
+    0x20, 0xe2, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x01, 0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06,
+    0x20, 0xe2, 0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3,
+    0x00, 0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22,
+    0x61, 0x03, 0x0e, 0x02, 0x4e, 0x42, 0x00, 0x22,
+    0x61, 0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00,
+    0x4e, 0xe2, 0x00, 0x81, 0x4e, 0x20, 0x42, 0x00,
+    0x22, 0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b,
+    0xb1, 0x36, 0x14, 0x15, 0x12, 0x34, 0x15, 0x12,
+    0x14, 0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6,
+    0x01, 0x14, 0x15, 0x76, 0x30, 0x56, 0x0c, 0x12,
+    0x13, 0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02,
+    0x17, 0x9b, 0x00, 0xfb, 0x02, 0x0b, 0x04, 0x20,
+    0xab, 0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c,
+    0x12, 0x13, 0x00, 0xe4, 0x05, 0x40, 0xed, 0x19,
+    0xe0, 0x07, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6,
+    0x04, 0xe0, 0x07, 0x2f, 0x01, 0x6f, 0x01, 0x2f,
+    0x02, 0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f,
+    0x0c, 0x81, 0xaf, 0x01, 0x0f, 0x01, 0x0f, 0x01,
+    0x0f, 0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02,
+    0x2f, 0x22, 0x21, 0x8c, 0x3f, 0x42, 0x0f, 0x0c,
+    0x2f, 0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f,
+    0x6a, 0x0b, 0x2f, 0x60, 0x8c, 0x8f, 0x2c, 0x6f,
+    0x0c, 0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef,
+    0x17, 0x2c, 0x2f, 0x0c, 0x0f, 0x0c, 0xef, 0x17,
+    0xec, 0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12,
+    0x13, 0xef, 0x0c, 0x2c, 0xcf, 0x12, 0x13, 0xef,
+    0x49, 0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20,
+    0xac, 0xef, 0x40, 0xe0, 0x0e, 0xef, 0x03, 0xe0,
+    0x0d, 0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef,
+    0x80, 0x2f, 0x0c, 0xef, 0x01, 0x0c, 0xef, 0x2e,
+    0xec, 0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0xec, 0x08, 0xef, 0x80, 0x78, 0xec, 0x7b, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16,
+    0xef, 0x24, 0x8c, 0x12, 0x13, 0xec, 0x17, 0x12,
     0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12,
-    0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13, 0xec,
-    0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac,
-    0xef, 0x1f, 0x20, 0xef, 0x18, 0x00, 0xef, 0x61,
-    0xe1, 0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22, 0xdf,
-    0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24, 0x41,
-    0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f,
-    0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00, 0x02,
-    0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16,
-    0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01, 0xc5,
-    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5,
-    0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xe6,
-    0x18, 0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14,
-    0x15, 0x16, 0x14, 0x15, 0xf6, 0x01, 0x11, 0x36,
-    0x11, 0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12,
-    0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x96,
-    0x04, 0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12,
-    0xf6, 0x05, 0x2f, 0x56, 0x12, 0x13, 0x12, 0x13,
-    0x12, 0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a, 0xef,
-    0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef, 0x80,
-    0x4e, 0xe0, 0x12, 0xef, 0x04, 0x60, 0x17, 0x56,
+    0x13, 0xec, 0x08, 0xef, 0x80, 0x78, 0xec, 0x7b,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37,
+    0x12, 0x13, 0x12, 0x13, 0xec, 0x18, 0x12, 0x13,
+    0xec, 0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f,
+    0xac, 0xef, 0x1f, 0x20, 0xef, 0x18, 0x00, 0xef,
+    0x61, 0xe1, 0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22,
+    0xdf, 0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24,
+    0x41, 0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46,
+    0x3f, 0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00,
+    0x02, 0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04,
+    0x16, 0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01,
+    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00,
+    0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00,
+    0xe6, 0x18, 0x36, 0x14, 0x15, 0x14, 0x15, 0x56,
+    0x14, 0x15, 0x16, 0x14, 0x15, 0xf6, 0x01, 0x11,
+    0x36, 0x11, 0x16, 0x14, 0x15, 0x36, 0x14, 0x15,
+    0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+    0x96, 0x04, 0xf6, 0x02, 0x31, 0x76, 0x11, 0x16,
+    0x12, 0xf6, 0x05, 0x2f, 0x56, 0x12, 0x13, 0x12,
+    0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a,
+    0xef, 0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef,
+    0x80, 0x4e, 0xe0, 0x12, 0xef, 0x08, 0x17, 0x56,
     0x0f, 0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13,
     0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12,
     0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11,
@@ -2563,146 +2670,154 @@ static const uint8_t unicode_gc_table[3948] = {
     0xe5, 0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11,
     0xe5, 0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23,
     0x00, 0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02,
-    0xe5, 0x18, 0xef, 0x1c, 0xe0, 0x04, 0xe5, 0x08,
-    0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb,
-    0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb, 0x02,
-    0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5,
-    0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11, 0x8d,
-    0x04, 0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0,
-    0x01, 0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80, 0x84,
-    0x04, 0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0,
-    0x0c, 0xff, 0x26, 0x05, 0x06, 0x48, 0x16, 0xe6,
-    0x02, 0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5,
-    0x3e, 0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00, 0xee,
-    0x0f, 0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff,
-    0x36, 0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02, 0x04,
-    0x2e, 0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61,
-    0x02, 0x81, 0x02, 0xff, 0x07, 0x41, 0x02, 0x3f,
-    0x80, 0x3f, 0x00, 0x02, 0x00, 0x02, 0x7f, 0xe0,
-    0x10, 0x44, 0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06,
-    0x45, 0x06, 0x65, 0x06, 0xe5, 0x0f, 0x27, 0x26,
-    0x07, 0x6f, 0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f,
-    0xa0, 0xe5, 0x2c, 0x76, 0xe0, 0x00, 0x27, 0xe5,
-    0x2a, 0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9,
-    0x02, 0xa0, 0xe6, 0x0a, 0xa5, 0x56, 0x05, 0x16,
-    0x25, 0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00,
-    0x36, 0xe5, 0x0f, 0xe6, 0x03, 0x27, 0xe0, 0x03,
-    0x16, 0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5, 0x27,
-    0x06, 0x27, 0x66, 0x27, 0x26, 0x47, 0xf6, 0x05,
-    0x00, 0x04, 0xe9, 0x02, 0x60, 0x36, 0x85, 0x06,
-    0x04, 0xe5, 0x01, 0xe9, 0x02, 0x85, 0x00, 0xe5,
-    0x21, 0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0, 0x01,
-    0x45, 0x06, 0xe5, 0x00, 0x06, 0x07, 0x20, 0xe9,
-    0x02, 0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f,
-    0x05, 0x07, 0x06, 0x07, 0xe5, 0x2a, 0x06, 0x05,
-    0x46, 0x25, 0x26, 0x85, 0x26, 0x05, 0x06, 0x05,
-    0xe0, 0x10, 0x25, 0x04, 0x36, 0xe5, 0x03, 0x07,
-    0x26, 0x27, 0x36, 0x05, 0x24, 0x07, 0x06, 0xe0,
-    0x02, 0xa5, 0x20, 0xa5, 0x20, 0xa5, 0xe0, 0x01,
-    0xc5, 0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64,
-    0xe2, 0x01, 0x04, 0x2e, 0x60, 0xe2, 0x48, 0xe5,
-    0x1b, 0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07,
-    0x06, 0x20, 0xe9, 0x02, 0xa0, 0xe5, 0xab, 0x1c,
-    0xe0, 0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60,
-    0xfc, 0x87, 0x78, 0xfd, 0x98, 0x78, 0xe5, 0x80,
-    0xe6, 0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0,
-    0x04, 0x82, 0x80, 0x05, 0x06, 0xe5, 0x02, 0x0c,
-    0xe5, 0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25,
-    0x00, 0x25, 0x00, 0xe5, 0x64, 0xee, 0x09, 0xe0,
-    0x08, 0xe5, 0x80, 0xe3, 0x13, 0x12, 0xef, 0x08,
-    0xe5, 0x38, 0x20, 0xe5, 0x2e, 0xc0, 0x0f, 0xe0,
-    0x18, 0xe5, 0x04, 0x0d, 0x4f, 0xe6, 0x08, 0xd6,
-    0x12, 0x13, 0x16, 0xa0, 0xe6, 0x08, 0x16, 0x31,
-    0x30, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+    0xe5, 0x18, 0xef, 0x1e, 0xe0, 0x01, 0x0f, 0xe5,
+    0x08, 0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16,
+    0xeb, 0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb,
+    0x02, 0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8,
+    0xe5, 0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11,
+    0x8d, 0x04, 0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f,
+    0xe0, 0x01, 0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80,
+    0x84, 0x04, 0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25,
+    0xe0, 0x0c, 0xff, 0x26, 0x05, 0x06, 0x48, 0x16,
+    0xe6, 0x02, 0x16, 0x04, 0xff, 0x14, 0x24, 0x26,
+    0xe5, 0x3e, 0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00,
+    0xee, 0x0f, 0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22,
+    0xff, 0x36, 0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02,
+    0x04, 0x2e, 0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d,
+    0x61, 0x02, 0x81, 0x02, 0xff, 0x07, 0x41, 0x02,
+    0x5f, 0x3f, 0x20, 0x3f, 0x00, 0x02, 0x00, 0x02,
+    0xdf, 0xe0, 0x0d, 0x44, 0x3f, 0x05, 0x24, 0x02,
+    0xc5, 0x06, 0x45, 0x06, 0x65, 0x06, 0xe5, 0x0f,
+    0x27, 0x26, 0x07, 0x6f, 0x06, 0x40, 0xab, 0x2f,
+    0x0d, 0x0f, 0xa0, 0xe5, 0x2c, 0x76, 0xe0, 0x00,
+    0x27, 0xe5, 0x2a, 0xe7, 0x08, 0x26, 0xe0, 0x00,
+    0x36, 0xe9, 0x02, 0xa0, 0xe6, 0x0a, 0xa5, 0x56,
+    0x05, 0x16, 0x25, 0x06, 0xe9, 0x02, 0xe5, 0x14,
+    0xe6, 0x00, 0x36, 0xe5, 0x0f, 0xe6, 0x03, 0x27,
+    0xe0, 0x03, 0x16, 0xe5, 0x15, 0x40, 0x46, 0x07,
+    0xe5, 0x27, 0x06, 0x27, 0x66, 0x27, 0x26, 0x47,
+    0xf6, 0x05, 0x00, 0x04, 0xe9, 0x02, 0x60, 0x36,
+    0x85, 0x06, 0x04, 0xe5, 0x01, 0xe9, 0x02, 0x85,
+    0x00, 0xe5, 0x21, 0xa6, 0x27, 0x26, 0x27, 0x26,
+    0xe0, 0x01, 0x45, 0x06, 0xe5, 0x00, 0x06, 0x07,
+    0x20, 0xe9, 0x02, 0x20, 0x76, 0xe5, 0x08, 0x04,
+    0xa5, 0x4f, 0x05, 0x07, 0x06, 0x07, 0xe5, 0x2a,
+    0x06, 0x05, 0x46, 0x25, 0x26, 0x85, 0x26, 0x05,
+    0x06, 0x05, 0xe0, 0x10, 0x25, 0x04, 0x36, 0xe5,
+    0x03, 0x07, 0x26, 0x27, 0x36, 0x05, 0x24, 0x07,
+    0x06, 0xe0, 0x02, 0xa5, 0x20, 0xa5, 0x20, 0xa5,
+    0xe0, 0x01, 0xc5, 0x00, 0xc5, 0x00, 0xe2, 0x23,
+    0x0e, 0x64, 0xe2, 0x01, 0x04, 0x2e, 0x60, 0xe2,
+    0x48, 0xe5, 0x1b, 0x27, 0x06, 0x27, 0x06, 0x27,
+    0x16, 0x07, 0x06, 0x20, 0xe9, 0x02, 0xa0, 0xe5,
+    0xab, 0x1c, 0xe0, 0x04, 0xe5, 0x0f, 0x60, 0xe5,
+    0x29, 0x60, 0xfc, 0x87, 0x78, 0xfd, 0x98, 0x78,
+    0xe5, 0x80, 0xe6, 0x20, 0xe5, 0x62, 0xe0, 0x1e,
+    0xc2, 0xe0, 0x04, 0x82, 0x80, 0x05, 0x06, 0xe5,
+    0x02, 0x0c, 0xe5, 0x05, 0x00, 0x85, 0x00, 0x05,
+    0x00, 0x25, 0x00, 0x25, 0x00, 0xe5, 0x64, 0xee,
+    0x09, 0xe0, 0x08, 0xe5, 0x80, 0xe3, 0x13, 0x12,
+    0xef, 0x08, 0xe5, 0x38, 0x20, 0xe5, 0x2e, 0xc0,
+    0x0f, 0xe0, 0x18, 0xe5, 0x04, 0x0d, 0x4f, 0xe6,
+    0x08, 0xd6, 0x12, 0x13, 0x16, 0xa0, 0xe6, 0x08,
+    0x16, 0x31, 0x30, 0x12, 0x13, 0x12, 0x13, 0x12,
     0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
-    0x13, 0x36, 0x12, 0x13, 0x76, 0x50, 0x56, 0x00,
-    0x76, 0x11, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
-    0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36,
-    0x60, 0x85, 0x00, 0xe5, 0x7f, 0x20, 0x1b, 0x00,
-    0x56, 0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16,
-    0x11, 0x36, 0xe9, 0x02, 0x36, 0x4c, 0x36, 0xe1,
-    0x12, 0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2,
-    0x12, 0x12, 0x0c, 0x13, 0x0c, 0x12, 0x13, 0x16,
-    0x12, 0x13, 0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25,
-    0x24, 0xe5, 0x17, 0x40, 0xa5, 0x20, 0xa5, 0x20,
-    0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f,
-    0x2d, 0x00, 0x0f, 0x6c, 0x2f, 0xe0, 0x02, 0x5b,
-    0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00,
-    0xe5, 0x0b, 0x00, 0x25, 0x00, 0xe5, 0x07, 0x20,
-    0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56,
-    0x60, 0xeb, 0x25, 0x40, 0xef, 0x01, 0xea, 0x2d,
-    0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00, 0xef, 0x05,
-    0x40, 0x0f, 0xe0, 0x27, 0xef, 0x25, 0x06, 0xe0,
-    0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07,
-    0x06, 0xeb, 0x13, 0x60, 0xe5, 0x18, 0x6b, 0xe0,
-    0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80,
-    0xe5, 0x1e, 0x86, 0x80, 0xe5, 0x16, 0x00, 0x16,
-    0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0,
-    0x22, 0xe1, 0x20, 0xe2, 0x20, 0xe5, 0x46, 0x20,
-    0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c,
-    0x60, 0xe5, 0x20, 0xe0, 0x00, 0xe5, 0x2c, 0xe0,
-    0x03, 0x16, 0xe1, 0x03, 0x00, 0xe1, 0x07, 0x00,
-    0xc1, 0x00, 0x21, 0x00, 0xe2, 0x03, 0x00, 0xe2,
-    0x07, 0x00, 0xc2, 0x00, 0x22, 0xe0, 0x3b, 0xe5,
-    0x80, 0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02,
-    0xe5, 0x00, 0xe0, 0x10, 0xa4, 0x00, 0xe4, 0x22,
-    0x00, 0xe4, 0x01, 0xe0, 0x3d, 0xa5, 0x20, 0x05,
-    0x00, 0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20,
-    0xe5, 0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f,
-    0x2f, 0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01,
-    0xe0, 0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b,
-    0xe5, 0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80,
-    0x16, 0xe0, 0x38, 0xe5, 0x30, 0x60, 0x2b, 0x25,
-    0xeb, 0x08, 0x20, 0xeb, 0x26, 0x05, 0x46, 0x00,
-    0x26, 0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5,
-    0x15, 0x20, 0x46, 0x60, 0x06, 0xeb, 0x01, 0xc0,
-    0xf6, 0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5,
-    0x15, 0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f, 0xe5,
-    0x14, 0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5,
-    0x2e, 0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb, 0x00,
-    0xe5, 0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0,
-    0x76, 0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5, 0x41,
-    0xe0, 0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b,
-    0xc0, 0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00, 0xe9,
-    0x02, 0xe0, 0x80, 0x9e, 0xeb, 0x17, 0x00, 0xe5,
-    0x22, 0x00, 0x26, 0x11, 0x20, 0x25, 0xe0, 0x43,
-    0x46, 0xe5, 0x15, 0xeb, 0x02, 0x05, 0xe0, 0x00,
-    0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x0e,
-    0xe5, 0x0a, 0x66, 0x76, 0xe0, 0x1e, 0xe5, 0x0d,
-    0xcb, 0xe0, 0x0c, 0xe5, 0x0f, 0xe0, 0x01, 0x07,
-    0x06, 0x07, 0xe5, 0x2d, 0xe6, 0x07, 0xd6, 0x60,
-    0xeb, 0x0c, 0xe9, 0x02, 0x06, 0x25, 0x26, 0x05,
-    0xe0, 0x01, 0x46, 0x07, 0xe5, 0x25, 0x47, 0x66,
-    0x27, 0x26, 0x36, 0x1b, 0x76, 0x06, 0xe0, 0x02,
-    0x1b, 0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02, 0xa0,
-    0x46, 0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00,
-    0xe9, 0x02, 0x76, 0x05, 0x27, 0x05, 0xe0, 0x00,
-    0xe5, 0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26,
-    0x07, 0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27, 0x65,
-    0x76, 0x66, 0x16, 0x07, 0x06, 0xe9, 0x02, 0x05,
-    0x16, 0x05, 0x56, 0x00, 0xeb, 0x0c, 0xe0, 0x03,
-    0xe5, 0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46, 0x27,
-    0x06, 0x07, 0x26, 0xb6, 0x06, 0x25, 0x06, 0xe0,
-    0x36, 0xc5, 0x00, 0x05, 0x00, 0x65, 0x00, 0xe5,
-    0x07, 0x00, 0xe5, 0x02, 0x16, 0xa0, 0xe5, 0x27,
-    0x06, 0x47, 0xe6, 0x00, 0x80, 0xe9, 0x02, 0xa0,
-    0x26, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25, 0x20,
-    0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x85,
-    0x00, 0x26, 0x05, 0x27, 0x06, 0x67, 0x20, 0x27,
-    0x20, 0x47, 0x20, 0x05, 0xa0, 0x07, 0x80, 0x85,
-    0x27, 0x20, 0xc6, 0x40, 0x86, 0xe0, 0x80, 0x03,
-    0xe5, 0x2d, 0x47, 0xe6, 0x00, 0x27, 0x46, 0x07,
-    0x06, 0x65, 0x96, 0xe9, 0x02, 0x36, 0x00, 0x16,
-    0x06, 0x45, 0xe0, 0x16, 0xe5, 0x28, 0x47, 0xa6,
-    0x07, 0x06, 0x67, 0x26, 0x07, 0x26, 0x25, 0x16,
-    0x05, 0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x1e,
-    0xe5, 0x27, 0x47, 0x66, 0x20, 0x67, 0x26, 0x07,
-    0x26, 0xf6, 0x0f, 0x65, 0x26, 0xe0, 0x1a, 0xe5,
-    0x28, 0x47, 0xe6, 0x00, 0x27, 0x06, 0x07, 0x26,
-    0x56, 0x05, 0xe0, 0x03, 0xe9, 0x02, 0xa0, 0xf6,
-    0x05, 0xe0, 0x0b, 0xe5, 0x23, 0x06, 0x07, 0x06,
-    0x27, 0xa6, 0x07, 0x06, 0x05, 0x16, 0xa0, 0xe9,
-    0x02, 0xe0, 0x2e, 0xe5, 0x13, 0x20, 0x46, 0x27,
+    0x13, 0x12, 0x13, 0x36, 0x12, 0x13, 0x76, 0x50,
+    0x56, 0x00, 0x76, 0x11, 0x12, 0x13, 0x12, 0x13,
+    0x12, 0x13, 0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16,
+    0x0d, 0x36, 0x60, 0x85, 0x00, 0xe5, 0x7f, 0x20,
+    0x1b, 0x00, 0x56, 0x0d, 0x56, 0x12, 0x13, 0x16,
+    0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36, 0x4c,
+    0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e, 0x10,
+    0x0e, 0xe2, 0x12, 0x12, 0x0c, 0x13, 0x0c, 0x12,
+    0x13, 0x16, 0x12, 0x13, 0x36, 0xe5, 0x02, 0x04,
+    0xe5, 0x25, 0x24, 0xe5, 0x17, 0x40, 0xa5, 0x20,
+    0xa5, 0x20, 0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c,
+    0x0e, 0x0f, 0x2d, 0x00, 0x0f, 0x6c, 0x2f, 0xe0,
+    0x02, 0x5b, 0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5,
+    0x12, 0x00, 0xe5, 0x0b, 0x00, 0x25, 0x00, 0xe5,
+    0x07, 0x20, 0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73,
+    0x80, 0x56, 0x60, 0xeb, 0x25, 0x40, 0xef, 0x01,
+    0xea, 0x2d, 0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00,
+    0xef, 0x05, 0x40, 0x0f, 0xe0, 0x27, 0xef, 0x25,
+    0x06, 0xe0, 0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29,
+    0xe0, 0x07, 0x06, 0xeb, 0x13, 0x60, 0xe5, 0x18,
+    0x6b, 0xe0, 0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00,
+    0x0a, 0x80, 0xe5, 0x1e, 0x86, 0x80, 0xe5, 0x16,
+    0x00, 0x16, 0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16,
+    0x8a, 0xe0, 0x22, 0xe1, 0x20, 0xe2, 0x20, 0xe5,
+    0x46, 0x20, 0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60,
+    0xe2, 0x1c, 0x60, 0xe5, 0x20, 0xe0, 0x00, 0xe5,
+    0x2c, 0xe0, 0x03, 0x16, 0xe1, 0x03, 0x00, 0xe1,
+    0x07, 0x00, 0xc1, 0x00, 0x21, 0x00, 0xe2, 0x03,
+    0x00, 0xe2, 0x07, 0x00, 0xc2, 0x00, 0x22, 0x40,
+    0xe5, 0x2c, 0xe0, 0x04, 0xe5, 0x80, 0xaf, 0xe0,
+    0x01, 0xe5, 0x0e, 0xe0, 0x02, 0xe5, 0x00, 0xe0,
+    0x10, 0xa4, 0x00, 0xe4, 0x22, 0x00, 0xe4, 0x01,
+    0xe0, 0x3d, 0xa5, 0x20, 0x05, 0x00, 0xe5, 0x24,
+    0x00, 0x25, 0x40, 0x05, 0x20, 0xe5, 0x0f, 0x00,
+    0x16, 0xeb, 0x00, 0xe5, 0x0f, 0x2f, 0xcb, 0xe5,
+    0x17, 0xe0, 0x00, 0xeb, 0x01, 0xe0, 0x28, 0xe5,
+    0x0b, 0x00, 0x25, 0x80, 0x8b, 0xe5, 0x0e, 0xab,
+    0x40, 0x16, 0xe5, 0x12, 0x80, 0x16, 0xe0, 0x38,
+    0xe5, 0x30, 0x60, 0x2b, 0x25, 0xeb, 0x08, 0x20,
+    0xeb, 0x26, 0x05, 0x46, 0x00, 0x26, 0x80, 0x66,
+    0x65, 0x00, 0x45, 0x00, 0xe5, 0x15, 0x20, 0x46,
+    0x60, 0x06, 0xeb, 0x01, 0xc0, 0xf6, 0x01, 0xc0,
+    0xe5, 0x15, 0x2b, 0x16, 0xe5, 0x15, 0x4b, 0xe0,
+    0x18, 0xe5, 0x00, 0x0f, 0xe5, 0x14, 0x26, 0x60,
+    0x8b, 0xd6, 0xe0, 0x01, 0xe5, 0x2e, 0x40, 0xd6,
+    0xe5, 0x0e, 0x20, 0xeb, 0x00, 0xe5, 0x0b, 0x80,
+    0xeb, 0x00, 0xe5, 0x0a, 0xc0, 0x76, 0xe0, 0x04,
+    0xcb, 0xe0, 0x48, 0xe5, 0x41, 0xe0, 0x2f, 0xe1,
+    0x2b, 0xe0, 0x05, 0xe2, 0x2b, 0xc0, 0xab, 0xe5,
+    0x1c, 0x66, 0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xe9,
+    0x02, 0x65, 0x04, 0x05, 0xe1, 0x0e, 0x40, 0x86,
+    0x11, 0x04, 0xe2, 0x0e, 0xe0, 0x00, 0x2c, 0xe0,
+    0x80, 0x48, 0xeb, 0x17, 0x00, 0xe5, 0x22, 0x00,
+    0x26, 0x11, 0x20, 0x25, 0xe0, 0x08, 0x45, 0xe0,
+    0x2f, 0x66, 0xe5, 0x15, 0xeb, 0x02, 0x05, 0xe0,
+    0x00, 0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0,
+    0x0e, 0xe5, 0x0a, 0x66, 0x76, 0xe0, 0x1e, 0xe5,
+    0x0d, 0xcb, 0xe0, 0x0c, 0xe5, 0x0f, 0xe0, 0x01,
+    0x07, 0x06, 0x07, 0xe5, 0x2d, 0xe6, 0x07, 0xd6,
+    0x60, 0xeb, 0x0c, 0xe9, 0x02, 0x06, 0x25, 0x26,
+    0x05, 0xe0, 0x01, 0x46, 0x07, 0xe5, 0x25, 0x47,
+    0x66, 0x27, 0x26, 0x36, 0x1b, 0x76, 0x06, 0xe0,
+    0x02, 0x1b, 0x20, 0xe5, 0x11, 0xc0, 0xe9, 0x02,
+    0xa0, 0x46, 0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00,
+    0x00, 0xe9, 0x02, 0x76, 0x05, 0x27, 0x05, 0xe0,
+    0x00, 0xe5, 0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01,
+    0x26, 0x07, 0xe5, 0x28, 0x47, 0xe6, 0x01, 0x27,
+    0x65, 0x76, 0x66, 0x16, 0x07, 0x06, 0xe9, 0x02,
+    0x05, 0x16, 0x05, 0x56, 0x00, 0xeb, 0x0c, 0xe0,
+    0x03, 0xe5, 0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46,
+    0x27, 0x06, 0x07, 0x26, 0xb6, 0x06, 0x25, 0x06,
+    0xe0, 0x36, 0xc5, 0x00, 0x05, 0x00, 0x65, 0x00,
+    0xe5, 0x07, 0x00, 0xe5, 0x02, 0x16, 0xa0, 0xe5,
+    0x27, 0x06, 0x47, 0xe6, 0x00, 0x80, 0xe9, 0x02,
+    0xa0, 0x26, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25,
+    0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00,
+    0x85, 0x00, 0x26, 0x05, 0x27, 0x06, 0x67, 0x20,
+    0x27, 0x20, 0x47, 0x20, 0x05, 0xa0, 0x07, 0x80,
+    0x85, 0x27, 0x20, 0xc6, 0x40, 0x86, 0xe0, 0x03,
+    0xe5, 0x02, 0x00, 0x05, 0x20, 0x05, 0x00, 0xe5,
+    0x1e, 0x00, 0x05, 0x47, 0xa6, 0x00, 0x07, 0x20,
+    0x07, 0x00, 0x67, 0x00, 0x27, 0x06, 0x07, 0x06,
+    0x05, 0x06, 0x05, 0x36, 0x00, 0x36, 0xe0, 0x00,
+    0x26, 0xe0, 0x15, 0xe5, 0x2d, 0x47, 0xe6, 0x00,
+    0x27, 0x46, 0x07, 0x06, 0x65, 0x96, 0xe9, 0x02,
+    0x36, 0x00, 0x16, 0x06, 0x45, 0xe0, 0x16, 0xe5,
+    0x28, 0x47, 0xa6, 0x07, 0x06, 0x67, 0x26, 0x07,
+    0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9, 0x02,
+    0xe0, 0x80, 0x1e, 0xe5, 0x27, 0x47, 0x66, 0x20,
+    0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f, 0x65, 0x26,
+    0xe0, 0x1a, 0xe5, 0x28, 0x47, 0xe6, 0x00, 0x27,
+    0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03, 0xe9,
+    0x02, 0xa0, 0xf6, 0x05, 0xe0, 0x0b, 0xe5, 0x23,
+    0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06, 0x05,
+    0x16, 0xa0, 0xe9, 0x02, 0xa0, 0xe9, 0x0c, 0xe0,
+    0x14, 0xe5, 0x13, 0x20, 0x06, 0x07, 0x06, 0x27,
     0x66, 0x07, 0x86, 0x60, 0xe9, 0x02, 0x2b, 0x56,
     0x0f, 0xc5, 0xe0, 0x80, 0x31, 0xe5, 0x24, 0x47,
     0xe6, 0x01, 0x07, 0x26, 0x16, 0xe0, 0x5c, 0xe1,
@@ -2717,7 +2832,8 @@ static const uint8_t unicode_gc_table[3948] = {
     0x05, 0x66, 0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05,
     0xa6, 0x27, 0x46, 0xe5, 0x26, 0xe6, 0x05, 0x07,
     0x26, 0x56, 0x05, 0x96, 0xe0, 0x05, 0xe5, 0x41,
-    0xc0, 0xf6, 0x02, 0xe0, 0x80, 0x6e, 0xe5, 0x01,
+    0xc0, 0xf6, 0x02, 0xe0, 0x80, 0x2e, 0xe5, 0x19,
+    0x16, 0xe0, 0x06, 0xe9, 0x02, 0xa0, 0xe5, 0x01,
     0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6, 0x07,
     0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9, 0x02, 0xeb,
     0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6, 0x0e,
@@ -2730,106 +2846,112 @@ static const uint8_t unicode_gc_table[3948] = {
     0x80, 0xae, 0xe5, 0x0b, 0x26, 0x27, 0x36, 0xc0,
     0x26, 0x05, 0x07, 0xe5, 0x05, 0x00, 0xe5, 0x1a,
     0x27, 0x86, 0x40, 0x27, 0x06, 0x07, 0x06, 0xf6,
-    0x05, 0xe9, 0x02, 0xe0, 0x4e, 0x05, 0xe0, 0x07,
-    0xeb, 0x0d, 0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0,
-    0x05, 0x16, 0xe5, 0x83, 0x12, 0xe0, 0x5e, 0xea,
-    0x67, 0x00, 0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c,
-    0xe0, 0x89, 0xc4, 0xe5, 0x59, 0x36, 0xe0, 0x05,
-    0xe5, 0x83, 0xa8, 0xfb, 0x08, 0x06, 0xa5, 0xe6,
-    0x07, 0xe0, 0x8f, 0x22, 0xe5, 0x81, 0xbf, 0xe0,
-    0xa1, 0x31, 0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17,
-    0x00, 0xe9, 0x02, 0x60, 0x36, 0xe5, 0x47, 0x00,
-    0xe9, 0x02, 0xa0, 0xe5, 0x16, 0x20, 0x86, 0x16,
-    0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f, 0x64,
-    0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00, 0xcb,
-    0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0, 0x82,
-    0x28, 0xe1, 0x18, 0xe2, 0x18, 0xeb, 0x0f, 0x76,
-    0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06, 0x05, 0xe7,
-    0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38, 0x24,
-    0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0xe0, 0x06,
-    0xe5, 0x97, 0x70, 0xe0, 0x00, 0xe5, 0x84, 0x4e,
-    0xe0, 0x22, 0xe5, 0x01, 0xe0, 0xa2, 0x5f, 0x64,
-    0x00, 0xc4, 0x00, 0x24, 0x00, 0xe5, 0x80, 0x9b,
-    0xe0, 0x07, 0x05, 0xe0, 0x15, 0x45, 0x20, 0x05,
-    0xe0, 0x06, 0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04,
-    0xe0, 0x88, 0x7c, 0xe5, 0x63, 0x80, 0xe5, 0x05,
-    0x40, 0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f,
-    0x26, 0x16, 0x7b, 0xe0, 0x91, 0xd4, 0xe6, 0x26,
-    0x20, 0xe6, 0x0f, 0xe0, 0x01, 0xef, 0x6c, 0xe0,
-    0x34, 0xef, 0x80, 0x6e, 0xe0, 0x02, 0xef, 0x1f,
-    0x20, 0xef, 0x34, 0x27, 0x46, 0x4f, 0xa7, 0xfb,
-    0x00, 0xe6, 0x00, 0x2f, 0xc6, 0xef, 0x16, 0x66,
-    0xef, 0x35, 0xe0, 0x0d, 0xef, 0x3a, 0x46, 0x0f,
-    0xe0, 0x72, 0xeb, 0x0c, 0xe0, 0x04, 0xeb, 0x0c,
-    0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11,
-    0xe0, 0x7f, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12,
-    0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12,
-    0x01, 0x00, 0x21, 0x20, 0x01, 0x20, 0x21, 0x20,
-    0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02, 0x00,
-    0xc2, 0x00, 0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12,
-    0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1,
-    0x00, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x00, 0x81,
-    0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1,
+    0x05, 0xe9, 0x02, 0x06, 0xe0, 0x4d, 0x05, 0xe0,
+    0x07, 0xeb, 0x0d, 0xef, 0x00, 0x6d, 0xef, 0x09,
+    0xe0, 0x05, 0x16, 0xe5, 0x83, 0x12, 0xe0, 0x5e,
+    0xea, 0x67, 0x00, 0x96, 0xe0, 0x03, 0xe5, 0x80,
+    0x3c, 0xe0, 0x89, 0xc4, 0xe5, 0x59, 0x36, 0xe0,
+    0x05, 0xe5, 0x83, 0xa8, 0xfb, 0x08, 0x06, 0xa5,
+    0xe6, 0x07, 0xe0, 0x02, 0xe5, 0x8f, 0x13, 0x80,
+    0xe5, 0x81, 0xbf, 0xe0, 0x9a, 0x31, 0xe5, 0x16,
+    0xe6, 0x04, 0x47, 0x46, 0xe9, 0x02, 0xe0, 0x86,
+    0x3e, 0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00,
+    0xe9, 0x02, 0x60, 0x36, 0xe5, 0x47, 0x00, 0xe9,
+    0x02, 0xa0, 0xe5, 0x16, 0x20, 0x86, 0x16, 0xe0,
+    0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f, 0x64, 0x16,
+    0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00, 0xcb, 0x00,
+    0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0, 0x81, 0x28,
+    0x44, 0xe5, 0x20, 0x24, 0x56, 0xe9, 0x02, 0xe0,
+    0x80, 0x3e, 0xe1, 0x18, 0xe2, 0x18, 0xeb, 0x0f,
+    0x76, 0xe0, 0x5d, 0xe5, 0x43, 0x60, 0x06, 0x05,
+    0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38,
+    0x24, 0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0xe0,
+    0x06, 0xe5, 0x97, 0x70, 0xe0, 0x00, 0xe5, 0x84,
+    0x4e, 0xe0, 0x21, 0xe5, 0x02, 0xe0, 0xa2, 0x5f,
+    0x64, 0x00, 0xc4, 0x00, 0x24, 0x00, 0xe5, 0x80,
+    0x9b, 0xe0, 0x07, 0x05, 0xe0, 0x15, 0x45, 0x20,
+    0x05, 0xe0, 0x06, 0x65, 0xe0, 0x00, 0xe5, 0x81,
+    0x04, 0xe0, 0x88, 0x7c, 0xe5, 0x63, 0x80, 0xe5,
+    0x05, 0x40, 0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20,
+    0x0f, 0x26, 0x16, 0x7b, 0xe0, 0x8e, 0xd4, 0xef,
+    0x80, 0x68, 0xe9, 0x02, 0xa0, 0xef, 0x81, 0x2c,
+    0xe0, 0x44, 0xe6, 0x26, 0x20, 0xe6, 0x0f, 0xe0,
+    0x01, 0xef, 0x6c, 0xe0, 0x34, 0xef, 0x80, 0x6e,
+    0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27,
+    0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6, 0x00, 0x2f,
+    0xc6, 0xef, 0x16, 0x66, 0xef, 0x35, 0xe0, 0x0d,
+    0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x72, 0xeb, 0x0c,
+    0xe0, 0x04, 0xeb, 0x0c, 0xe0, 0x04, 0xef, 0x4f,
+    0xe0, 0x01, 0xeb, 0x11, 0xe0, 0x7f, 0xe1, 0x12,
+    0xe2, 0x12, 0xe1, 0x12, 0xc2, 0x00, 0xe2, 0x0a,
+    0xe1, 0x12, 0xe2, 0x12, 0x01, 0x00, 0x21, 0x20,
+    0x01, 0x20, 0x21, 0x20, 0x61, 0x00, 0xe1, 0x00,
+    0x62, 0x00, 0x02, 0x00, 0xc2, 0x00, 0xe2, 0x03,
+    0xe1, 0x12, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x20,
+    0xe1, 0x00, 0x00, 0xc1, 0x00, 0xe2, 0x12, 0x21,
+    0x00, 0x61, 0x00, 0x81, 0x00, 0x01, 0x40, 0xc1,
+    0x00, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
     0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
     0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1,
-    0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20,
-    0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1,
-    0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11,
-    0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
-    0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2,
-    0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef,
-    0x81, 0x78, 0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef,
-    0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0,
-    0x07, 0x86, 0x00, 0xe6, 0x07, 0xe0, 0x83, 0xc8,
-    0xe2, 0x02, 0x05, 0xe2, 0x0c, 0xa0, 0xa2, 0xe0,
-    0x80, 0x4d, 0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6,
-    0x00, 0x26, 0x00, 0x86, 0x80, 0xe4, 0x36, 0xe0,
-    0x19, 0x06, 0xe0, 0x68, 0xe5, 0x25, 0x40, 0xc6,
-    0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05, 0x0f, 0xe0,
-    0x80, 0xb8, 0xe5, 0x16, 0x06, 0xe0, 0x09, 0xe5,
-    0x24, 0x66, 0xe9, 0x02, 0x80, 0x0d, 0xe0, 0x81,
-    0x48, 0xe5, 0x13, 0x04, 0x66, 0xe9, 0x02, 0xe0,
-    0x82, 0x5e, 0xc5, 0x00, 0x65, 0x00, 0x25, 0x00,
-    0xe5, 0x07, 0x00, 0xe5, 0x80, 0x3d, 0x20, 0xeb,
-    0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a, 0xe2, 0x1a,
-    0xc6, 0x04, 0x60, 0xe9, 0x02, 0x60, 0x36, 0xe0,
-    0x82, 0x89, 0xeb, 0x33, 0x0f, 0x4b, 0x0d, 0x6b,
-    0xe0, 0x44, 0xeb, 0x25, 0x0f, 0xeb, 0x07, 0xe0,
-    0x80, 0x3a, 0x65, 0x00, 0xe5, 0x13, 0x00, 0x25,
-    0x00, 0x05, 0x20, 0x05, 0x00, 0xe5, 0x02, 0x00,
-    0x65, 0x00, 0x05, 0x00, 0x05, 0xa0, 0x05, 0x60,
-    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x45, 0x00,
-    0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0x05, 0x00,
-    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x25, 0x00,
-    0x05, 0x20, 0x65, 0x00, 0xc5, 0x00, 0x65, 0x00,
-    0x65, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x00, 0xe5,
-    0x09, 0x80, 0x45, 0x00, 0x85, 0x00, 0xe5, 0x09,
-    0xe0, 0x2c, 0x2c, 0xe0, 0x80, 0x86, 0xef, 0x24,
-    0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef, 0x07, 0x20,
-    0xef, 0x07, 0x00, 0xef, 0x07, 0x00, 0xef, 0x1d,
-    0xe0, 0x02, 0xeb, 0x05, 0xef, 0x80, 0x19, 0xe0,
-    0x30, 0xef, 0x15, 0xe0, 0x05, 0xef, 0x24, 0x60,
-    0xef, 0x01, 0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0,
-    0x80, 0x12, 0xef, 0x80, 0x73, 0x8e, 0xef, 0x82,
-    0x50, 0x60, 0xef, 0x09, 0x40, 0xef, 0x05, 0x40,
-    0xef, 0x6f, 0x60, 0xef, 0x57, 0xa0, 0xef, 0x04,
-    0x60, 0x0f, 0xe0, 0x07, 0xef, 0x04, 0x60, 0xef,
-    0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0, 0xef, 0x20,
-    0xe0, 0x00, 0xef, 0x16, 0x20, 0x2f, 0xe0, 0x46,
-    0xef, 0x80, 0xcc, 0xe0, 0x04, 0xef, 0x06, 0x20,
-    0xef, 0x05, 0x40, 0xef, 0x01, 0xc0, 0xef, 0x26,
-    0x00, 0xcf, 0xe0, 0x00, 0xef, 0x06, 0x60, 0xef,
-    0x01, 0xc0, 0xef, 0x01, 0xc0, 0xef, 0x80, 0x0b,
-    0x00, 0xef, 0x2f, 0xe0, 0x1d, 0xe9, 0x02, 0xe0,
-    0x83, 0x7e, 0xe5, 0xc0, 0x66, 0x58, 0xe0, 0x18,
-    0xe5, 0x8f, 0xb2, 0xa0, 0xe5, 0x80, 0x56, 0x20,
-    0xe5, 0x95, 0xfa, 0xe0, 0x06, 0xe5, 0x9c, 0xa9,
-    0xe0, 0x8b, 0x97, 0xe5, 0x81, 0x96, 0xe0, 0x85,
-    0x5a, 0xe5, 0x92, 0xc3, 0x80, 0xe5, 0x8f, 0xd8,
-    0xe0, 0xca, 0x9b, 0xc9, 0x1b, 0xe0, 0x16, 0xfb,
-    0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68, 0xe0, 0xc0,
-    0xbd, 0x88, 0xfd, 0xc0, 0xbf, 0x76, 0x20, 0xfd,
-    0xc0, 0xbf, 0x76, 0x20,
+    0x12, 0xe2, 0x14, 0x20, 0xe1, 0x11, 0x0c, 0xe2,
+    0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11,
+    0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c,
+    0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2,
+    0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0x3f,
+    0x20, 0xe9, 0x2a, 0xef, 0x81, 0x78, 0xe6, 0x2f,
+    0x6f, 0xe6, 0x2a, 0xef, 0x00, 0x06, 0xef, 0x06,
+    0x06, 0x2f, 0x96, 0xe0, 0x07, 0x86, 0x00, 0xe6,
+    0x07, 0xe0, 0x83, 0xc8, 0xe2, 0x02, 0x05, 0xe2,
+    0x0c, 0xa0, 0xa2, 0xe0, 0x80, 0x4d, 0xc6, 0x00,
+    0xe6, 0x09, 0x20, 0xc6, 0x00, 0x26, 0x00, 0x86,
+    0x80, 0xe4, 0x36, 0xe0, 0x19, 0x06, 0xe0, 0x68,
+    0xe5, 0x25, 0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02,
+    0x60, 0x05, 0x0f, 0xe0, 0x80, 0xb8, 0xe5, 0x16,
+    0x06, 0xe0, 0x09, 0xe5, 0x24, 0x66, 0xe9, 0x02,
+    0x80, 0x0d, 0xe0, 0x81, 0x48, 0xe5, 0x13, 0x04,
+    0x66, 0xe9, 0x02, 0xe0, 0x80, 0x4e, 0xe5, 0x16,
+    0x26, 0x05, 0xe9, 0x02, 0x60, 0x16, 0xe0, 0x81,
+    0x58, 0xc5, 0x00, 0x65, 0x00, 0x25, 0x00, 0xe5,
+    0x07, 0x00, 0xe5, 0x80, 0x3d, 0x20, 0xeb, 0x01,
+    0xc6, 0xe0, 0x21, 0xe1, 0x1a, 0xe2, 0x1a, 0xc6,
+    0x04, 0x60, 0xe9, 0x02, 0x60, 0x36, 0xe0, 0x82,
+    0x89, 0xeb, 0x33, 0x0f, 0x4b, 0x0d, 0x6b, 0xe0,
+    0x44, 0xeb, 0x25, 0x0f, 0xeb, 0x07, 0xe0, 0x80,
+    0x3a, 0x65, 0x00, 0xe5, 0x13, 0x00, 0x25, 0x00,
+    0x05, 0x20, 0x05, 0x00, 0xe5, 0x02, 0x00, 0x65,
+    0x00, 0x05, 0x00, 0x05, 0xa0, 0x05, 0x60, 0x05,
+    0x00, 0x05, 0x00, 0x05, 0x00, 0x45, 0x00, 0x25,
+    0x00, 0x05, 0x20, 0x05, 0x00, 0x05, 0x00, 0x05,
+    0x00, 0x05, 0x00, 0x05, 0x00, 0x25, 0x00, 0x05,
+    0x20, 0x65, 0x00, 0xc5, 0x00, 0x65, 0x00, 0x65,
+    0x00, 0x05, 0x00, 0xe5, 0x02, 0x00, 0xe5, 0x09,
+    0x80, 0x45, 0x00, 0x85, 0x00, 0xe5, 0x09, 0xe0,
+    0x2c, 0x2c, 0xe0, 0x80, 0x86, 0xef, 0x24, 0x60,
+    0xef, 0x5c, 0xe0, 0x04, 0xef, 0x07, 0x20, 0xef,
+    0x07, 0x00, 0xef, 0x07, 0x00, 0xef, 0x1d, 0xe0,
+    0x02, 0xeb, 0x05, 0xef, 0x80, 0x19, 0xe0, 0x30,
+    0xef, 0x15, 0xe0, 0x05, 0xef, 0x24, 0x60, 0xef,
+    0x01, 0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0, 0x80,
+    0x12, 0xef, 0x80, 0x73, 0x8e, 0xef, 0x82, 0x50,
+    0x60, 0xef, 0x09, 0x40, 0xef, 0x05, 0x40, 0xef,
+    0x6f, 0x60, 0xef, 0x57, 0xa0, 0xef, 0x04, 0x60,
+    0x0f, 0xe0, 0x07, 0xef, 0x04, 0x60, 0xef, 0x30,
+    0xe0, 0x00, 0xef, 0x02, 0xa0, 0xef, 0x20, 0xe0,
+    0x00, 0xef, 0x16, 0x20, 0xef, 0x04, 0x60, 0x2f,
+    0xe0, 0x36, 0xef, 0x80, 0xcc, 0xe0, 0x04, 0xef,
+    0x06, 0x20, 0xef, 0x05, 0x40, 0xef, 0x02, 0x80,
+    0xef, 0x30, 0xc0, 0xef, 0x07, 0x20, 0xef, 0x03,
+    0xa0, 0xef, 0x01, 0xc0, 0xef, 0x80, 0x0b, 0x00,
+    0xef, 0x54, 0xe9, 0x02, 0xe0, 0x83, 0x7e, 0xe5,
+    0xc0, 0x66, 0x58, 0xe0, 0x18, 0xe5, 0x8f, 0xb2,
+    0xa0, 0xe5, 0x80, 0x56, 0x20, 0xe5, 0x95, 0xfa,
+    0xe0, 0x06, 0xe5, 0x9c, 0xa9, 0xe0, 0x07, 0xe5,
+    0x81, 0xe6, 0xe0, 0x89, 0x1a, 0xe5, 0x81, 0x96,
+    0xe0, 0x85, 0x5a, 0xe5, 0x92, 0xc3, 0x80, 0xe5,
+    0x8f, 0xd8, 0xe0, 0xca, 0x9b, 0xc9, 0x1b, 0xe0,
+    0x16, 0xfb, 0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68,
+    0xe0, 0xc0, 0xbd, 0x88, 0xfd, 0xc0, 0xbf, 0x76,
+    0x20, 0xfd, 0xc0, 0xbf, 0x76, 0x20,
 };
 
 typedef enum {
@@ -2873,6 +2995,7 @@ typedef enum {
     UNICODE_SCRIPT_Elbasan,
     UNICODE_SCRIPT_Elymaic,
     UNICODE_SCRIPT_Ethiopic,
+    UNICODE_SCRIPT_Garay,
     UNICODE_SCRIPT_Georgian,
     UNICODE_SCRIPT_Glagolitic,
     UNICODE_SCRIPT_Gothic,
@@ -2881,6 +3004,7 @@ typedef enum {
     UNICODE_SCRIPT_Gujarati,
     UNICODE_SCRIPT_Gunjala_Gondi,
     UNICODE_SCRIPT_Gurmukhi,
+    UNICODE_SCRIPT_Gurung_Khema,
     UNICODE_SCRIPT_Han,
     UNICODE_SCRIPT_Hangul,
     UNICODE_SCRIPT_Hanifi_Rohingya,
@@ -2903,6 +3027,7 @@ typedef enum {
     UNICODE_SCRIPT_Khojki,
     UNICODE_SCRIPT_Khitan_Small_Script,
     UNICODE_SCRIPT_Khudawadi,
+    UNICODE_SCRIPT_Kirat_Rai,
     UNICODE_SCRIPT_Lao,
     UNICODE_SCRIPT_Latin,
     UNICODE_SCRIPT_Lepcha,
@@ -2940,6 +3065,7 @@ typedef enum {
     UNICODE_SCRIPT_Nyiakeng_Puachue_Hmong,
     UNICODE_SCRIPT_Ogham,
     UNICODE_SCRIPT_Ol_Chiki,
+    UNICODE_SCRIPT_Ol_Onal,
     UNICODE_SCRIPT_Old_Hungarian,
     UNICODE_SCRIPT_Old_Italic,
     UNICODE_SCRIPT_Old_North_Arabian,
@@ -2971,6 +3097,7 @@ typedef enum {
     UNICODE_SCRIPT_Sora_Sompeng,
     UNICODE_SCRIPT_Soyombo,
     UNICODE_SCRIPT_Sundanese,
+    UNICODE_SCRIPT_Sunuwar,
     UNICODE_SCRIPT_Syloti_Nagri,
     UNICODE_SCRIPT_Syriac,
     UNICODE_SCRIPT_Tagalog,
@@ -2988,7 +3115,9 @@ typedef enum {
     UNICODE_SCRIPT_Tifinagh,
     UNICODE_SCRIPT_Tirhuta,
     UNICODE_SCRIPT_Tangsa,
+    UNICODE_SCRIPT_Todhri,
     UNICODE_SCRIPT_Toto,
+    UNICODE_SCRIPT_Tulu_Tigalari,
     UNICODE_SCRIPT_Ugaritic,
     UNICODE_SCRIPT_Vai,
     UNICODE_SCRIPT_Vithkuqi,
@@ -3001,6 +3130,7 @@ typedef enum {
 } UnicodeScriptEnum;
 
 static const char unicode_script_name_table[] =
+    "Unknown,Zzzz"                "\0"
     "Adlam,Adlm"                  "\0"
     "Ahom,Ahom"                   "\0"
     "Anatolian_Hieroglyphs,Hluw"  "\0"
@@ -3040,6 +3170,7 @@ static const char unicode_script_name_table[] =
     "Elbasan,Elba"                "\0"
     "Elymaic,Elym"                "\0"
     "Ethiopic,Ethi"               "\0"
+    "Garay,Gara"                  "\0"
     "Georgian,Geor"               "\0"
     "Glagolitic,Glag"             "\0"
     "Gothic,Goth"                 "\0"
@@ -3048,6 +3179,7 @@ static const char unicode_script_name_table[] =
     "Gujarati,Gujr"               "\0"
     "Gunjala_Gondi,Gong"          "\0"
     "Gurmukhi,Guru"               "\0"
+    "Gurung_Khema,Gukh"           "\0"
     "Han,Hani"                    "\0"
     "Hangul,Hang"                 "\0"
     "Hanifi_Rohingya,Rohg"        "\0"
@@ -3070,6 +3202,7 @@ static const char unicode_script_name_table[] =
     "Khojki,Khoj"                 "\0"
     "Khitan_Small_Script,Kits"    "\0"
     "Khudawadi,Sind"              "\0"
+    "Kirat_Rai,Krai"              "\0"
     "Lao,Laoo"                    "\0"
     "Latin,Latn"                  "\0"
     "Lepcha,Lepc"                 "\0"
@@ -3107,6 +3240,7 @@ static const char unicode_script_name_table[] =
     "Nyiakeng_Puachue_Hmong,Hmnp" "\0"
     "Ogham,Ogam"                  "\0"
     "Ol_Chiki,Olck"               "\0"
+    "Ol_Onal,Onao"                "\0"
     "Old_Hungarian,Hung"          "\0"
     "Old_Italic,Ital"             "\0"
     "Old_North_Arabian,Narb"      "\0"
@@ -3138,6 +3272,7 @@ static const char unicode_script_name_table[] =
     "Sora_Sompeng,Sora"           "\0"
     "Soyombo,Soyo"                "\0"
     "Sundanese,Sund"              "\0"
+    "Sunuwar,Sunu"                "\0"
     "Syloti_Nagri,Sylo"           "\0"
     "Syriac,Syrc"                 "\0"
     "Tagalog,Tglg"                "\0"
@@ -3155,7 +3290,9 @@ static const char unicode_script_name_table[] =
     "Tifinagh,Tfng"               "\0"
     "Tirhuta,Tirh"                "\0"
     "Tangsa,Tnsa"                 "\0"
+    "Todhri,Todr"                 "\0"
     "Toto,Toto"                   "\0"
+    "Tulu_Tigalari,Tutg"          "\0"
     "Ugaritic,Ugar"               "\0"
     "Vai,Vaii"                    "\0"
     "Vithkuqi,Vith"               "\0"
@@ -3166,87 +3303,87 @@ static const char unicode_script_name_table[] =
     "Zanabazar_Square,Zanb"       "\0"
 ;
 
-static const uint8_t unicode_script_table[2720] = {
-    0xc0, 0x19, 0x99, 0x47, 0x85, 0x19, 0x99, 0x47,
-    0xae, 0x19, 0x80, 0x47, 0x8e, 0x19, 0x80, 0x47,
-    0x84, 0x19, 0x96, 0x47, 0x80, 0x19, 0x9e, 0x47,
-    0x80, 0x19, 0xe1, 0x60, 0x47, 0xa6, 0x19, 0x84,
-    0x47, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
-    0x0f, 0x38, 0x83, 0x2c, 0x80, 0x19, 0x82, 0x2c,
-    0x01, 0x83, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x03,
-    0x80, 0x2c, 0x80, 0x19, 0x80, 0x2c, 0x80, 0x19,
-    0x82, 0x2c, 0x00, 0x80, 0x2c, 0x00, 0x93, 0x2c,
-    0x00, 0xbe, 0x2c, 0x8d, 0x1a, 0x8f, 0x2c, 0xe0,
-    0x24, 0x1d, 0x81, 0x38, 0xe0, 0x48, 0x1d, 0x00,
+static const uint8_t unicode_script_table[2803] = {
+    0xc0, 0x19, 0x99, 0x4a, 0x85, 0x19, 0x99, 0x4a,
+    0xae, 0x19, 0x80, 0x4a, 0x8e, 0x19, 0x80, 0x4a,
+    0x84, 0x19, 0x96, 0x4a, 0x80, 0x19, 0x9e, 0x4a,
+    0x80, 0x19, 0xe1, 0x60, 0x4a, 0xa6, 0x19, 0x84,
+    0x4a, 0x84, 0x19, 0x81, 0x0d, 0x93, 0x19, 0xe0,
+    0x0f, 0x3a, 0x83, 0x2d, 0x80, 0x19, 0x82, 0x2d,
+    0x01, 0x83, 0x2d, 0x80, 0x19, 0x80, 0x2d, 0x03,
+    0x80, 0x2d, 0x80, 0x19, 0x80, 0x2d, 0x80, 0x19,
+    0x82, 0x2d, 0x00, 0x80, 0x2d, 0x00, 0x93, 0x2d,
+    0x00, 0xbe, 0x2d, 0x8d, 0x1a, 0x8f, 0x2d, 0xe0,
+    0x24, 0x1d, 0x81, 0x3a, 0xe0, 0x48, 0x1d, 0x00,
     0xa5, 0x05, 0x01, 0xb1, 0x05, 0x01, 0x82, 0x05,
-    0x00, 0xb6, 0x35, 0x07, 0x9a, 0x35, 0x03, 0x85,
-    0x35, 0x0a, 0x84, 0x04, 0x80, 0x19, 0x85, 0x04,
+    0x00, 0xb6, 0x37, 0x07, 0x9a, 0x37, 0x03, 0x85,
+    0x37, 0x0a, 0x84, 0x04, 0x80, 0x19, 0x85, 0x04,
     0x80, 0x19, 0x8d, 0x04, 0x80, 0x19, 0x82, 0x04,
     0x80, 0x19, 0x9f, 0x04, 0x80, 0x19, 0x89, 0x04,
-    0x8a, 0x38, 0x99, 0x04, 0x80, 0x38, 0xe0, 0x0b,
-    0x04, 0x80, 0x19, 0xa1, 0x04, 0x8d, 0x8b, 0x00,
-    0xbb, 0x8b, 0x01, 0x82, 0x8b, 0xaf, 0x04, 0xb1,
-    0x95, 0x0d, 0xba, 0x66, 0x01, 0x82, 0x66, 0xad,
-    0x7f, 0x01, 0x8e, 0x7f, 0x00, 0x9b, 0x52, 0x01,
-    0x80, 0x52, 0x00, 0x8a, 0x8b, 0x04, 0x9e, 0x04,
-    0x00, 0x81, 0x04, 0x05, 0xc9, 0x04, 0x80, 0x19,
-    0x9c, 0x04, 0xd0, 0x20, 0x83, 0x38, 0x8e, 0x20,
+    0x8a, 0x3a, 0x99, 0x04, 0x80, 0x3a, 0xe0, 0x0b,
+    0x04, 0x80, 0x19, 0xa1, 0x04, 0x8d, 0x90, 0x00,
+    0xbb, 0x90, 0x01, 0x82, 0x90, 0xaf, 0x04, 0xb1,
+    0x9a, 0x0d, 0xba, 0x69, 0x01, 0x82, 0x69, 0xad,
+    0x83, 0x01, 0x8e, 0x83, 0x00, 0x9b, 0x55, 0x01,
+    0x80, 0x55, 0x00, 0x8a, 0x90, 0x04, 0x9e, 0x04,
+    0x00, 0x81, 0x04, 0x04, 0xca, 0x04, 0x80, 0x19,
+    0x9c, 0x04, 0xd0, 0x20, 0x83, 0x3a, 0x8e, 0x20,
     0x81, 0x19, 0x99, 0x20, 0x83, 0x0b, 0x00, 0x87,
     0x0b, 0x01, 0x81, 0x0b, 0x01, 0x95, 0x0b, 0x00,
     0x86, 0x0b, 0x00, 0x80, 0x0b, 0x02, 0x83, 0x0b,
     0x01, 0x88, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x83,
     0x0b, 0x07, 0x80, 0x0b, 0x03, 0x81, 0x0b, 0x00,
-    0x84, 0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x2f,
-    0x00, 0x85, 0x2f, 0x03, 0x81, 0x2f, 0x01, 0x95,
-    0x2f, 0x00, 0x86, 0x2f, 0x00, 0x81, 0x2f, 0x00,
-    0x81, 0x2f, 0x00, 0x81, 0x2f, 0x01, 0x80, 0x2f,
-    0x00, 0x84, 0x2f, 0x03, 0x81, 0x2f, 0x01, 0x82,
-    0x2f, 0x02, 0x80, 0x2f, 0x06, 0x83, 0x2f, 0x00,
-    0x80, 0x2f, 0x06, 0x90, 0x2f, 0x09, 0x82, 0x2d,
-    0x00, 0x88, 0x2d, 0x00, 0x82, 0x2d, 0x00, 0x95,
-    0x2d, 0x00, 0x86, 0x2d, 0x00, 0x81, 0x2d, 0x00,
-    0x84, 0x2d, 0x01, 0x89, 0x2d, 0x00, 0x82, 0x2d,
-    0x00, 0x82, 0x2d, 0x01, 0x80, 0x2d, 0x0e, 0x83,
-    0x2d, 0x01, 0x8b, 0x2d, 0x06, 0x86, 0x2d, 0x00,
-    0x82, 0x74, 0x00, 0x87, 0x74, 0x01, 0x81, 0x74,
-    0x01, 0x95, 0x74, 0x00, 0x86, 0x74, 0x00, 0x81,
-    0x74, 0x00, 0x84, 0x74, 0x01, 0x88, 0x74, 0x01,
-    0x81, 0x74, 0x01, 0x82, 0x74, 0x06, 0x82, 0x74,
-    0x03, 0x81, 0x74, 0x00, 0x84, 0x74, 0x01, 0x91,
-    0x74, 0x09, 0x81, 0x92, 0x00, 0x85, 0x92, 0x02,
-    0x82, 0x92, 0x00, 0x83, 0x92, 0x02, 0x81, 0x92,
-    0x00, 0x80, 0x92, 0x00, 0x81, 0x92, 0x02, 0x81,
-    0x92, 0x02, 0x82, 0x92, 0x02, 0x8b, 0x92, 0x03,
-    0x84, 0x92, 0x02, 0x82, 0x92, 0x00, 0x83, 0x92,
-    0x01, 0x80, 0x92, 0x05, 0x80, 0x92, 0x0d, 0x94,
-    0x92, 0x04, 0x8c, 0x94, 0x00, 0x82, 0x94, 0x00,
-    0x96, 0x94, 0x00, 0x8f, 0x94, 0x01, 0x88, 0x94,
-    0x00, 0x82, 0x94, 0x00, 0x83, 0x94, 0x06, 0x81,
-    0x94, 0x00, 0x82, 0x94, 0x01, 0x80, 0x94, 0x01,
-    0x83, 0x94, 0x01, 0x89, 0x94, 0x06, 0x88, 0x94,
-    0x8c, 0x3d, 0x00, 0x82, 0x3d, 0x00, 0x96, 0x3d,
-    0x00, 0x89, 0x3d, 0x00, 0x84, 0x3d, 0x01, 0x88,
-    0x3d, 0x00, 0x82, 0x3d, 0x00, 0x83, 0x3d, 0x06,
-    0x81, 0x3d, 0x05, 0x81, 0x3d, 0x00, 0x83, 0x3d,
-    0x01, 0x89, 0x3d, 0x00, 0x82, 0x3d, 0x0b, 0x8c,
-    0x51, 0x00, 0x82, 0x51, 0x00, 0xb2, 0x51, 0x00,
-    0x82, 0x51, 0x00, 0x85, 0x51, 0x03, 0x8f, 0x51,
-    0x01, 0x99, 0x51, 0x00, 0x82, 0x85, 0x00, 0x91,
-    0x85, 0x02, 0x97, 0x85, 0x00, 0x88, 0x85, 0x00,
-    0x80, 0x85, 0x01, 0x86, 0x85, 0x02, 0x80, 0x85,
-    0x03, 0x85, 0x85, 0x00, 0x80, 0x85, 0x00, 0x87,
-    0x85, 0x05, 0x89, 0x85, 0x01, 0x82, 0x85, 0x0b,
-    0xb9, 0x96, 0x03, 0x80, 0x19, 0x9b, 0x96, 0x24,
-    0x81, 0x46, 0x00, 0x80, 0x46, 0x00, 0x84, 0x46,
-    0x00, 0x97, 0x46, 0x00, 0x80, 0x46, 0x00, 0x96,
-    0x46, 0x01, 0x84, 0x46, 0x00, 0x80, 0x46, 0x00,
-    0x86, 0x46, 0x00, 0x89, 0x46, 0x01, 0x83, 0x46,
-    0x1f, 0xc7, 0x97, 0x00, 0xa3, 0x97, 0x03, 0xa6,
-    0x97, 0x00, 0xa3, 0x97, 0x00, 0x8e, 0x97, 0x00,
-    0x86, 0x97, 0x83, 0x19, 0x81, 0x97, 0x24, 0xe0,
-    0x3f, 0x60, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
-    0x80, 0x28, 0x01, 0xaa, 0x28, 0x80, 0x19, 0x83,
-    0x28, 0xe0, 0x9f, 0x31, 0xc8, 0x27, 0x00, 0x83,
+    0x84, 0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x30,
+    0x00, 0x85, 0x30, 0x03, 0x81, 0x30, 0x01, 0x95,
+    0x30, 0x00, 0x86, 0x30, 0x00, 0x81, 0x30, 0x00,
+    0x81, 0x30, 0x00, 0x81, 0x30, 0x01, 0x80, 0x30,
+    0x00, 0x84, 0x30, 0x03, 0x81, 0x30, 0x01, 0x82,
+    0x30, 0x02, 0x80, 0x30, 0x06, 0x83, 0x30, 0x00,
+    0x80, 0x30, 0x06, 0x90, 0x30, 0x09, 0x82, 0x2e,
+    0x00, 0x88, 0x2e, 0x00, 0x82, 0x2e, 0x00, 0x95,
+    0x2e, 0x00, 0x86, 0x2e, 0x00, 0x81, 0x2e, 0x00,
+    0x84, 0x2e, 0x01, 0x89, 0x2e, 0x00, 0x82, 0x2e,
+    0x00, 0x82, 0x2e, 0x01, 0x80, 0x2e, 0x0e, 0x83,
+    0x2e, 0x01, 0x8b, 0x2e, 0x06, 0x86, 0x2e, 0x00,
+    0x82, 0x78, 0x00, 0x87, 0x78, 0x01, 0x81, 0x78,
+    0x01, 0x95, 0x78, 0x00, 0x86, 0x78, 0x00, 0x81,
+    0x78, 0x00, 0x84, 0x78, 0x01, 0x88, 0x78, 0x01,
+    0x81, 0x78, 0x01, 0x82, 0x78, 0x06, 0x82, 0x78,
+    0x03, 0x81, 0x78, 0x00, 0x84, 0x78, 0x01, 0x91,
+    0x78, 0x09, 0x81, 0x97, 0x00, 0x85, 0x97, 0x02,
+    0x82, 0x97, 0x00, 0x83, 0x97, 0x02, 0x81, 0x97,
+    0x00, 0x80, 0x97, 0x00, 0x81, 0x97, 0x02, 0x81,
+    0x97, 0x02, 0x82, 0x97, 0x02, 0x8b, 0x97, 0x03,
+    0x84, 0x97, 0x02, 0x82, 0x97, 0x00, 0x83, 0x97,
+    0x01, 0x80, 0x97, 0x05, 0x80, 0x97, 0x0d, 0x94,
+    0x97, 0x04, 0x8c, 0x99, 0x00, 0x82, 0x99, 0x00,
+    0x96, 0x99, 0x00, 0x8f, 0x99, 0x01, 0x88, 0x99,
+    0x00, 0x82, 0x99, 0x00, 0x83, 0x99, 0x06, 0x81,
+    0x99, 0x00, 0x82, 0x99, 0x01, 0x80, 0x99, 0x01,
+    0x83, 0x99, 0x01, 0x89, 0x99, 0x06, 0x88, 0x99,
+    0x8c, 0x3f, 0x00, 0x82, 0x3f, 0x00, 0x96, 0x3f,
+    0x00, 0x89, 0x3f, 0x00, 0x84, 0x3f, 0x01, 0x88,
+    0x3f, 0x00, 0x82, 0x3f, 0x00, 0x83, 0x3f, 0x06,
+    0x81, 0x3f, 0x05, 0x81, 0x3f, 0x00, 0x83, 0x3f,
+    0x01, 0x89, 0x3f, 0x00, 0x82, 0x3f, 0x0b, 0x8c,
+    0x54, 0x00, 0x82, 0x54, 0x00, 0xb2, 0x54, 0x00,
+    0x82, 0x54, 0x00, 0x85, 0x54, 0x03, 0x8f, 0x54,
+    0x01, 0x99, 0x54, 0x00, 0x82, 0x89, 0x00, 0x91,
+    0x89, 0x02, 0x97, 0x89, 0x00, 0x88, 0x89, 0x00,
+    0x80, 0x89, 0x01, 0x86, 0x89, 0x02, 0x80, 0x89,
+    0x03, 0x85, 0x89, 0x00, 0x80, 0x89, 0x00, 0x87,
+    0x89, 0x05, 0x89, 0x89, 0x01, 0x82, 0x89, 0x0b,
+    0xb9, 0x9b, 0x03, 0x80, 0x19, 0x9b, 0x9b, 0x24,
+    0x81, 0x49, 0x00, 0x80, 0x49, 0x00, 0x84, 0x49,
+    0x00, 0x97, 0x49, 0x00, 0x80, 0x49, 0x00, 0x96,
+    0x49, 0x01, 0x84, 0x49, 0x00, 0x80, 0x49, 0x00,
+    0x86, 0x49, 0x00, 0x89, 0x49, 0x01, 0x83, 0x49,
+    0x1f, 0xc7, 0x9c, 0x00, 0xa3, 0x9c, 0x03, 0xa6,
+    0x9c, 0x00, 0xa3, 0x9c, 0x00, 0x8e, 0x9c, 0x00,
+    0x86, 0x9c, 0x83, 0x19, 0x81, 0x9c, 0x24, 0xe0,
+    0x3f, 0x63, 0xa5, 0x29, 0x00, 0x80, 0x29, 0x04,
+    0x80, 0x29, 0x01, 0xaa, 0x29, 0x80, 0x19, 0x83,
+    0x29, 0xe0, 0x9f, 0x33, 0xc8, 0x27, 0x00, 0x83,
     0x27, 0x01, 0x86, 0x27, 0x00, 0x80, 0x27, 0x00,
     0x83, 0x27, 0x01, 0xa8, 0x27, 0x00, 0x83, 0x27,
     0x01, 0xa0, 0x27, 0x00, 0x83, 0x27, 0x01, 0x86,
@@ -3254,366 +3391,430 @@ static const uint8_t unicode_script_table[2720] = {
     0x8e, 0x27, 0x00, 0xb8, 0x27, 0x00, 0x83, 0x27,
     0x01, 0xc2, 0x27, 0x01, 0x9f, 0x27, 0x02, 0x99,
     0x27, 0x05, 0xd5, 0x17, 0x01, 0x85, 0x17, 0x01,
-    0xe2, 0x1f, 0x12, 0x9c, 0x69, 0x02, 0xca, 0x7e,
-    0x82, 0x19, 0x8a, 0x7e, 0x06, 0x95, 0x8c, 0x08,
-    0x80, 0x8c, 0x94, 0x33, 0x81, 0x19, 0x08, 0x93,
-    0x11, 0x0b, 0x8c, 0x8d, 0x00, 0x82, 0x8d, 0x00,
-    0x81, 0x8d, 0x0b, 0xdd, 0x42, 0x01, 0x89, 0x42,
-    0x05, 0x89, 0x42, 0x05, 0x81, 0x5d, 0x81, 0x19,
-    0x80, 0x5d, 0x80, 0x19, 0x93, 0x5d, 0x05, 0xd8,
-    0x5d, 0x06, 0xaa, 0x5d, 0x04, 0xc5, 0x12, 0x09,
-    0x9e, 0x49, 0x00, 0x8b, 0x49, 0x03, 0x8b, 0x49,
-    0x03, 0x80, 0x49, 0x02, 0x8b, 0x49, 0x9d, 0x8e,
-    0x01, 0x84, 0x8e, 0x0a, 0xab, 0x64, 0x03, 0x99,
-    0x64, 0x05, 0x8a, 0x64, 0x02, 0x81, 0x64, 0x9f,
-    0x42, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x8f,
-    0x00, 0x9c, 0x8f, 0x01, 0x8a, 0x8f, 0x05, 0x89,
-    0x8f, 0x05, 0x8d, 0x8f, 0x01, 0x9e, 0x38, 0x30,
-    0xcc, 0x07, 0x02, 0xae, 0x07, 0x00, 0xbf, 0x89,
-    0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x48, 0x02,
-    0x8e, 0x48, 0x02, 0x82, 0x48, 0xaf, 0x6a, 0x88,
-    0x1d, 0x06, 0xaa, 0x28, 0x01, 0x82, 0x28, 0x87,
-    0x89, 0x07, 0x82, 0x38, 0x80, 0x19, 0x8c, 0x38,
-    0x80, 0x19, 0x86, 0x38, 0x83, 0x19, 0x80, 0x38,
-    0x85, 0x19, 0x80, 0x38, 0x82, 0x19, 0x81, 0x38,
-    0x80, 0x19, 0x04, 0xa5, 0x47, 0x84, 0x2c, 0x80,
-    0x1d, 0xb0, 0x47, 0x84, 0x2c, 0x83, 0x47, 0x84,
-    0x2c, 0x8c, 0x47, 0x80, 0x1d, 0xc5, 0x47, 0x80,
-    0x2c, 0xbf, 0x38, 0xe0, 0x9f, 0x47, 0x95, 0x2c,
-    0x01, 0x85, 0x2c, 0x01, 0xa5, 0x2c, 0x01, 0x85,
-    0x2c, 0x01, 0x87, 0x2c, 0x00, 0x80, 0x2c, 0x00,
-    0x80, 0x2c, 0x00, 0x80, 0x2c, 0x00, 0x9e, 0x2c,
-    0x01, 0xb4, 0x2c, 0x00, 0x8e, 0x2c, 0x00, 0x8d,
-    0x2c, 0x01, 0x85, 0x2c, 0x00, 0x92, 0x2c, 0x01,
-    0x82, 0x2c, 0x00, 0x88, 0x2c, 0x00, 0x8b, 0x19,
-    0x81, 0x38, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80,
-    0x47, 0x01, 0x8a, 0x19, 0x80, 0x47, 0x8e, 0x19,
-    0x00, 0x8c, 0x47, 0x02, 0xa0, 0x19, 0x0e, 0xa0,
-    0x38, 0x0e, 0xa5, 0x19, 0x80, 0x2c, 0x82, 0x19,
-    0x81, 0x47, 0x85, 0x19, 0x80, 0x47, 0x9a, 0x19,
-    0x80, 0x47, 0x90, 0x19, 0xa8, 0x47, 0x82, 0x19,
-    0x03, 0xe2, 0x36, 0x19, 0x18, 0x8a, 0x19, 0x14,
-    0xe3, 0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13,
-    0x19, 0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19,
-    0xdf, 0x29, 0x9f, 0x47, 0xe0, 0x13, 0x1a, 0x04,
-    0x86, 0x1a, 0xa5, 0x28, 0x00, 0x80, 0x28, 0x04,
-    0x80, 0x28, 0x01, 0xb7, 0x98, 0x06, 0x81, 0x98,
-    0x0d, 0x80, 0x98, 0x96, 0x27, 0x08, 0x86, 0x27,
+    0xe2, 0x1f, 0x12, 0x9c, 0x6c, 0x02, 0xca, 0x82,
+    0x82, 0x19, 0x8a, 0x82, 0x06, 0x95, 0x91, 0x08,
+    0x80, 0x91, 0x94, 0x35, 0x81, 0x19, 0x08, 0x93,
+    0x11, 0x0b, 0x8c, 0x92, 0x00, 0x82, 0x92, 0x00,
+    0x81, 0x92, 0x0b, 0xdd, 0x44, 0x01, 0x89, 0x44,
+    0x05, 0x89, 0x44, 0x05, 0x81, 0x60, 0x81, 0x19,
+    0x80, 0x60, 0x80, 0x19, 0x93, 0x60, 0x05, 0xd8,
+    0x60, 0x06, 0xaa, 0x60, 0x04, 0xc5, 0x12, 0x09,
+    0x9e, 0x4c, 0x00, 0x8b, 0x4c, 0x03, 0x8b, 0x4c,
+    0x03, 0x80, 0x4c, 0x02, 0x8b, 0x4c, 0x9d, 0x93,
+    0x01, 0x84, 0x93, 0x0a, 0xab, 0x67, 0x03, 0x99,
+    0x67, 0x05, 0x8a, 0x67, 0x02, 0x81, 0x67, 0x9f,
+    0x44, 0x9b, 0x10, 0x01, 0x81, 0x10, 0xbe, 0x94,
+    0x00, 0x9c, 0x94, 0x01, 0x8a, 0x94, 0x05, 0x89,
+    0x94, 0x05, 0x8d, 0x94, 0x01, 0x9e, 0x3a, 0x30,
+    0xcc, 0x07, 0x00, 0xb1, 0x07, 0xbf, 0x8d, 0xb3,
+    0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x4b, 0x02, 0x8e,
+    0x4b, 0x02, 0x82, 0x4b, 0xaf, 0x6d, 0x8a, 0x1d,
+    0x04, 0xaa, 0x29, 0x01, 0x82, 0x29, 0x87, 0x8d,
+    0x07, 0x82, 0x3a, 0x80, 0x19, 0x8c, 0x3a, 0x80,
+    0x19, 0x86, 0x3a, 0x83, 0x19, 0x80, 0x3a, 0x85,
+    0x19, 0x80, 0x3a, 0x82, 0x19, 0x81, 0x3a, 0x80,
+    0x19, 0x04, 0xa5, 0x4a, 0x84, 0x2d, 0x80, 0x1d,
+    0xb0, 0x4a, 0x84, 0x2d, 0x83, 0x4a, 0x84, 0x2d,
+    0x8c, 0x4a, 0x80, 0x1d, 0xc5, 0x4a, 0x80, 0x2d,
+    0xbf, 0x3a, 0xe0, 0x9f, 0x4a, 0x95, 0x2d, 0x01,
+    0x85, 0x2d, 0x01, 0xa5, 0x2d, 0x01, 0x85, 0x2d,
+    0x01, 0x87, 0x2d, 0x00, 0x80, 0x2d, 0x00, 0x80,
+    0x2d, 0x00, 0x80, 0x2d, 0x00, 0x9e, 0x2d, 0x01,
+    0xb4, 0x2d, 0x00, 0x8e, 0x2d, 0x00, 0x8d, 0x2d,
+    0x01, 0x85, 0x2d, 0x00, 0x92, 0x2d, 0x01, 0x82,
+    0x2d, 0x00, 0x88, 0x2d, 0x00, 0x8b, 0x19, 0x81,
+    0x3a, 0xd6, 0x19, 0x00, 0x8a, 0x19, 0x80, 0x4a,
+    0x01, 0x8a, 0x19, 0x80, 0x4a, 0x8e, 0x19, 0x00,
+    0x8c, 0x4a, 0x02, 0xa0, 0x19, 0x0e, 0xa0, 0x3a,
+    0x0e, 0xa5, 0x19, 0x80, 0x2d, 0x82, 0x19, 0x81,
+    0x4a, 0x85, 0x19, 0x80, 0x4a, 0x9a, 0x19, 0x80,
+    0x4a, 0x90, 0x19, 0xa8, 0x4a, 0x82, 0x19, 0x03,
+    0xe2, 0x39, 0x19, 0x15, 0x8a, 0x19, 0x14, 0xe3,
+    0x3f, 0x19, 0xe0, 0x9f, 0x0f, 0xe2, 0x13, 0x19,
+    0x01, 0x9f, 0x19, 0x00, 0xe0, 0x08, 0x19, 0xdf,
+    0x2a, 0x9f, 0x4a, 0xe0, 0x13, 0x1a, 0x04, 0x86,
+    0x1a, 0xa5, 0x29, 0x00, 0x80, 0x29, 0x04, 0x80,
+    0x29, 0x01, 0xb7, 0x9d, 0x06, 0x81, 0x9d, 0x0d,
+    0x80, 0x9d, 0x96, 0x27, 0x08, 0x86, 0x27, 0x00,
+    0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x86, 0x27,
     0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x86,
-    0x27, 0x00, 0x86, 0x27, 0x00, 0x86, 0x27, 0x00,
-    0x86, 0x27, 0x00, 0x86, 0x27, 0x00, 0x9f, 0x1d,
-    0xdd, 0x19, 0x21, 0x99, 0x30, 0x00, 0xd8, 0x30,
-    0x0b, 0xe0, 0x75, 0x30, 0x19, 0x8b, 0x19, 0x03,
-    0x84, 0x19, 0x80, 0x30, 0x80, 0x19, 0x80, 0x30,
-    0x98, 0x19, 0x88, 0x30, 0x83, 0x38, 0x81, 0x31,
-    0x87, 0x19, 0x83, 0x30, 0x83, 0x19, 0x00, 0xd5,
-    0x36, 0x01, 0x81, 0x38, 0x81, 0x19, 0x82, 0x36,
-    0x80, 0x19, 0xd9, 0x3e, 0x81, 0x19, 0x82, 0x3e,
-    0x04, 0xaa, 0x0d, 0x00, 0xdd, 0x31, 0x00, 0x8f,
-    0x19, 0x9f, 0x0d, 0xa3, 0x19, 0x0b, 0x8f, 0x3e,
-    0x9e, 0x31, 0x00, 0xbf, 0x19, 0x9e, 0x31, 0xd0,
-    0x19, 0xae, 0x3e, 0x80, 0x19, 0xd7, 0x3e, 0xe0,
-    0x47, 0x19, 0xf0, 0x09, 0x5f, 0x30, 0xbf, 0x19,
-    0xf0, 0x41, 0x9f, 0x30, 0xe4, 0x2c, 0xa2, 0x02,
-    0xb6, 0xa2, 0x08, 0xaf, 0x4c, 0xe0, 0xcb, 0x9d,
-    0x13, 0xdf, 0x1d, 0xd7, 0x08, 0x07, 0xa1, 0x19,
-    0xe0, 0x05, 0x47, 0x82, 0x19, 0xbf, 0x47, 0x04,
-    0x81, 0x47, 0x00, 0x80, 0x47, 0x00, 0x84, 0x47,
-    0x17, 0x8d, 0x47, 0xac, 0x8a, 0x02, 0x89, 0x19,
-    0x05, 0xb7, 0x7a, 0x07, 0xc5, 0x80, 0x07, 0x8b,
-    0x80, 0x05, 0x9f, 0x20, 0xad, 0x40, 0x80, 0x19,
-    0x80, 0x40, 0xa3, 0x7d, 0x0a, 0x80, 0x7d, 0x9c,
-    0x31, 0x02, 0xcd, 0x3b, 0x00, 0x80, 0x19, 0x89,
-    0x3b, 0x03, 0x81, 0x3b, 0x9e, 0x60, 0x00, 0xb6,
-    0x16, 0x08, 0x8d, 0x16, 0x01, 0x89, 0x16, 0x01,
-    0x83, 0x16, 0x9f, 0x60, 0xc2, 0x90, 0x17, 0x84,
-    0x90, 0x96, 0x57, 0x09, 0x85, 0x27, 0x01, 0x85,
-    0x27, 0x01, 0x85, 0x27, 0x08, 0x86, 0x27, 0x00,
-    0x86, 0x27, 0x00, 0xaa, 0x47, 0x80, 0x19, 0x88,
-    0x47, 0x80, 0x2c, 0x83, 0x47, 0x81, 0x19, 0x03,
-    0xcf, 0x17, 0xad, 0x57, 0x01, 0x89, 0x57, 0x05,
-    0xf0, 0x1b, 0x43, 0x31, 0x0b, 0x96, 0x31, 0x03,
-    0xb0, 0x31, 0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x30,
-    0x01, 0xe0, 0x09, 0x30, 0x25, 0x86, 0x47, 0x0b,
-    0x84, 0x05, 0x04, 0x99, 0x35, 0x00, 0x84, 0x35,
-    0x00, 0x80, 0x35, 0x00, 0x81, 0x35, 0x00, 0x81,
-    0x35, 0x00, 0x89, 0x35, 0xe0, 0x12, 0x04, 0x0f,
-    0xe1, 0x0a, 0x04, 0x81, 0x19, 0xcf, 0x04, 0x01,
-    0xb5, 0x04, 0x06, 0x80, 0x04, 0x1f, 0x8f, 0x04,
-    0x8f, 0x38, 0x89, 0x19, 0x05, 0x8d, 0x38, 0x81,
-    0x1d, 0xa2, 0x19, 0x00, 0x92, 0x19, 0x00, 0x83,
-    0x19, 0x03, 0x84, 0x04, 0x00, 0xe0, 0x26, 0x04,
-    0x01, 0x80, 0x19, 0x00, 0x9f, 0x19, 0x99, 0x47,
-    0x85, 0x19, 0x99, 0x47, 0x8a, 0x19, 0x89, 0x3e,
-    0x80, 0x19, 0xac, 0x3e, 0x81, 0x19, 0x9e, 0x31,
-    0x02, 0x85, 0x31, 0x01, 0x85, 0x31, 0x01, 0x85,
-    0x31, 0x01, 0x82, 0x31, 0x02, 0x86, 0x19, 0x00,
-    0x86, 0x19, 0x09, 0x84, 0x19, 0x01, 0x8b, 0x4b,
-    0x00, 0x99, 0x4b, 0x00, 0x92, 0x4b, 0x00, 0x81,
-    0x4b, 0x00, 0x8e, 0x4b, 0x01, 0x8d, 0x4b, 0x21,
-    0xe0, 0x1a, 0x4b, 0x04, 0x82, 0x19, 0x03, 0xac,
-    0x19, 0x02, 0x88, 0x19, 0xce, 0x2c, 0x00, 0x8c,
-    0x19, 0x02, 0x80, 0x2c, 0x2e, 0xac, 0x19, 0x80,
-    0x38, 0x60, 0x21, 0x9c, 0x4d, 0x02, 0xb0, 0x13,
-    0x0e, 0x80, 0x38, 0x9a, 0x19, 0x03, 0xa3, 0x6c,
-    0x08, 0x82, 0x6c, 0x9a, 0x2a, 0x04, 0xaa, 0x6e,
-    0x04, 0x9d, 0x9c, 0x00, 0x80, 0x9c, 0xa3, 0x6f,
-    0x03, 0x8d, 0x6f, 0x29, 0xcf, 0x1f, 0xaf, 0x82,
-    0x9d, 0x76, 0x01, 0x89, 0x76, 0x05, 0xa3, 0x75,
-    0x03, 0xa3, 0x75, 0x03, 0xa7, 0x25, 0x07, 0xb3,
-    0x14, 0x0a, 0x80, 0x14, 0x8a, 0x9e, 0x00, 0x8e,
-    0x9e, 0x00, 0x86, 0x9e, 0x00, 0x81, 0x9e, 0x00,
-    0x8a, 0x9e, 0x00, 0x8e, 0x9e, 0x00, 0x86, 0x9e,
-    0x00, 0x81, 0x9e, 0x42, 0xe0, 0xd6, 0x4a, 0x08,
-    0x95, 0x4a, 0x09, 0x87, 0x4a, 0x17, 0x85, 0x47,
-    0x00, 0xa9, 0x47, 0x00, 0x88, 0x47, 0x44, 0x85,
-    0x1c, 0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c, 0x00,
-    0x81, 0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80, 0x1c,
-    0x95, 0x37, 0x00, 0x88, 0x37, 0x9f, 0x78, 0x9e,
-    0x61, 0x07, 0x88, 0x61, 0x2f, 0x92, 0x34, 0x00,
-    0x81, 0x34, 0x04, 0x84, 0x34, 0x9b, 0x7b, 0x02,
-    0x80, 0x7b, 0x99, 0x4e, 0x04, 0x80, 0x4e, 0x3f,
-    0x9f, 0x5a, 0x97, 0x59, 0x03, 0x93, 0x59, 0x01,
-    0xad, 0x59, 0x83, 0x41, 0x00, 0x81, 0x41, 0x04,
-    0x87, 0x41, 0x00, 0x82, 0x41, 0x00, 0x9c, 0x41,
-    0x01, 0x82, 0x41, 0x03, 0x89, 0x41, 0x06, 0x88,
-    0x41, 0x06, 0x9f, 0x71, 0x9f, 0x6d, 0x1f, 0xa6,
-    0x53, 0x03, 0x8b, 0x53, 0x08, 0xb5, 0x06, 0x02,
-    0x86, 0x06, 0x95, 0x3a, 0x01, 0x87, 0x3a, 0x92,
-    0x39, 0x04, 0x87, 0x39, 0x91, 0x7c, 0x06, 0x83,
-    0x7c, 0x0b, 0x86, 0x7c, 0x4f, 0xc8, 0x72, 0x36,
-    0xb2, 0x6b, 0x0c, 0xb2, 0x6b, 0x06, 0x85, 0x6b,
-    0xa7, 0x32, 0x07, 0x89, 0x32, 0x60, 0xc5, 0x9e,
-    0x04, 0x00, 0xa9, 0xa1, 0x00, 0x82, 0xa1, 0x01,
-    0x81, 0xa1, 0x4a, 0x82, 0x04, 0xa7, 0x70, 0x07,
-    0xa9, 0x86, 0x15, 0x99, 0x73, 0x25, 0x9b, 0x18,
-    0x13, 0x96, 0x26, 0x08, 0xcd, 0x0e, 0x03, 0xa3,
-    0x0e, 0x08, 0x80, 0x0e, 0xc2, 0x3c, 0x09, 0x80,
-    0x3c, 0x01, 0x98, 0x87, 0x06, 0x89, 0x87, 0x05,
-    0xb4, 0x15, 0x00, 0x91, 0x15, 0x07, 0xa6, 0x50,
-    0x08, 0xdf, 0x81, 0x00, 0x93, 0x85, 0x0a, 0x91,
-    0x43, 0x00, 0xae, 0x43, 0x3d, 0x86, 0x5f, 0x00,
-    0x80, 0x5f, 0x00, 0x83, 0x5f, 0x00, 0x8e, 0x5f,
-    0x00, 0x8a, 0x5f, 0x05, 0xba, 0x45, 0x04, 0x89,
-    0x45, 0x05, 0x83, 0x2b, 0x00, 0x87, 0x2b, 0x01,
-    0x81, 0x2b, 0x01, 0x95, 0x2b, 0x00, 0x86, 0x2b,
-    0x00, 0x81, 0x2b, 0x00, 0x84, 0x2b, 0x00, 0x80,
-    0x38, 0x88, 0x2b, 0x01, 0x81, 0x2b, 0x01, 0x82,
-    0x2b, 0x01, 0x80, 0x2b, 0x05, 0x80, 0x2b, 0x04,
-    0x86, 0x2b, 0x01, 0x86, 0x2b, 0x02, 0x84, 0x2b,
-    0x60, 0x2a, 0xdb, 0x65, 0x00, 0x84, 0x65, 0x1d,
-    0xc7, 0x99, 0x07, 0x89, 0x99, 0x60, 0x45, 0xb5,
-    0x83, 0x01, 0xa5, 0x83, 0x21, 0xc4, 0x5c, 0x0a,
-    0x89, 0x5c, 0x05, 0x8c, 0x5d, 0x12, 0xb9, 0x91,
-    0x05, 0x89, 0x91, 0x35, 0x9a, 0x02, 0x01, 0x8e,
+    0x27, 0x00, 0x86, 0x27, 0x00, 0x9f, 0x1d, 0xdd,
+    0x19, 0x21, 0x99, 0x32, 0x00, 0xd8, 0x32, 0x0b,
+    0xe0, 0x75, 0x32, 0x19, 0x94, 0x19, 0x80, 0x32,
+    0x80, 0x19, 0x80, 0x32, 0x98, 0x19, 0x88, 0x32,
+    0x83, 0x3a, 0x81, 0x33, 0x87, 0x19, 0x83, 0x32,
+    0x83, 0x19, 0x00, 0xd5, 0x38, 0x01, 0x81, 0x3a,
+    0x81, 0x19, 0x82, 0x38, 0x80, 0x19, 0xd9, 0x40,
+    0x81, 0x19, 0x82, 0x40, 0x04, 0xaa, 0x0d, 0x00,
+    0xdd, 0x33, 0x00, 0x8f, 0x19, 0x9f, 0x0d, 0xa5,
+    0x19, 0x08, 0x80, 0x19, 0x8f, 0x40, 0x9e, 0x33,
+    0x00, 0xbf, 0x19, 0x9e, 0x33, 0xd0, 0x19, 0xae,
+    0x40, 0x80, 0x19, 0xd7, 0x40, 0xe0, 0x47, 0x19,
+    0xf0, 0x09, 0x5f, 0x32, 0xbf, 0x19, 0xf0, 0x41,
+    0x9f, 0x32, 0xe4, 0x2c, 0xa9, 0x02, 0xb6, 0xa9,
+    0x08, 0xaf, 0x4f, 0xe0, 0xcb, 0xa4, 0x13, 0xdf,
+    0x1d, 0xd7, 0x08, 0x07, 0xa1, 0x19, 0xe0, 0x05,
+    0x4a, 0x82, 0x19, 0xc2, 0x4a, 0x01, 0x81, 0x4a,
+    0x00, 0x80, 0x4a, 0x00, 0x87, 0x4a, 0x14, 0x8d,
+    0x4a, 0xac, 0x8f, 0x02, 0x89, 0x19, 0x05, 0xb7,
+    0x7e, 0x07, 0xc5, 0x84, 0x07, 0x8b, 0x84, 0x05,
+    0x9f, 0x20, 0xad, 0x42, 0x80, 0x19, 0x80, 0x42,
+    0xa3, 0x81, 0x0a, 0x80, 0x81, 0x9c, 0x33, 0x02,
+    0xcd, 0x3d, 0x00, 0x80, 0x19, 0x89, 0x3d, 0x03,
+    0x81, 0x3d, 0x9e, 0x63, 0x00, 0xb6, 0x16, 0x08,
+    0x8d, 0x16, 0x01, 0x89, 0x16, 0x01, 0x83, 0x16,
+    0x9f, 0x63, 0xc2, 0x95, 0x17, 0x84, 0x95, 0x96,
+    0x5a, 0x09, 0x85, 0x27, 0x01, 0x85, 0x27, 0x01,
+    0x85, 0x27, 0x08, 0x86, 0x27, 0x00, 0x86, 0x27,
+    0x00, 0xaa, 0x4a, 0x80, 0x19, 0x88, 0x4a, 0x80,
+    0x2d, 0x83, 0x4a, 0x81, 0x19, 0x03, 0xcf, 0x17,
+    0xad, 0x5a, 0x01, 0x89, 0x5a, 0x05, 0xf0, 0x1b,
+    0x43, 0x33, 0x0b, 0x96, 0x33, 0x03, 0xb0, 0x33,
+    0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x32, 0x01, 0xe0,
+    0x09, 0x32, 0x25, 0x86, 0x4a, 0x0b, 0x84, 0x05,
+    0x04, 0x99, 0x37, 0x00, 0x84, 0x37, 0x00, 0x80,
+    0x37, 0x00, 0x81, 0x37, 0x00, 0x81, 0x37, 0x00,
+    0x89, 0x37, 0xe0, 0x12, 0x04, 0x0f, 0xe1, 0x0a,
+    0x04, 0x81, 0x19, 0xcf, 0x04, 0x01, 0xb5, 0x04,
+    0x06, 0x80, 0x04, 0x1f, 0x8f, 0x04, 0x8f, 0x3a,
+    0x89, 0x19, 0x05, 0x8d, 0x3a, 0x81, 0x1d, 0xa2,
+    0x19, 0x00, 0x92, 0x19, 0x00, 0x83, 0x19, 0x03,
+    0x84, 0x04, 0x00, 0xe0, 0x26, 0x04, 0x01, 0x80,
+    0x19, 0x00, 0x9f, 0x19, 0x99, 0x4a, 0x85, 0x19,
+    0x99, 0x4a, 0x8a, 0x19, 0x89, 0x40, 0x80, 0x19,
+    0xac, 0x40, 0x81, 0x19, 0x9e, 0x33, 0x02, 0x85,
+    0x33, 0x01, 0x85, 0x33, 0x01, 0x85, 0x33, 0x01,
+    0x82, 0x33, 0x02, 0x86, 0x19, 0x00, 0x86, 0x19,
+    0x09, 0x84, 0x19, 0x01, 0x8b, 0x4e, 0x00, 0x99,
+    0x4e, 0x00, 0x92, 0x4e, 0x00, 0x81, 0x4e, 0x00,
+    0x8e, 0x4e, 0x01, 0x8d, 0x4e, 0x21, 0xe0, 0x1a,
+    0x4e, 0x04, 0x82, 0x19, 0x03, 0xac, 0x19, 0x02,
+    0x88, 0x19, 0xce, 0x2d, 0x00, 0x8c, 0x19, 0x02,
+    0x80, 0x2d, 0x2e, 0xac, 0x19, 0x80, 0x3a, 0x60,
+    0x21, 0x9c, 0x50, 0x02, 0xb0, 0x13, 0x0e, 0x80,
+    0x3a, 0x9a, 0x19, 0x03, 0xa3, 0x70, 0x08, 0x82,
+    0x70, 0x9a, 0x2b, 0x04, 0xaa, 0x72, 0x04, 0x9d,
+    0xa3, 0x00, 0x80, 0xa3, 0xa3, 0x73, 0x03, 0x8d,
+    0x73, 0x29, 0xcf, 0x1f, 0xaf, 0x86, 0x9d, 0x7a,
+    0x01, 0x89, 0x7a, 0x05, 0xa3, 0x79, 0x03, 0xa3,
+    0x79, 0x03, 0xa7, 0x25, 0x07, 0xb3, 0x14, 0x0a,
+    0x80, 0x14, 0x8a, 0xa5, 0x00, 0x8e, 0xa5, 0x00,
+    0x86, 0xa5, 0x00, 0x81, 0xa5, 0x00, 0x8a, 0xa5,
+    0x00, 0x8e, 0xa5, 0x00, 0x86, 0xa5, 0x00, 0x81,
+    0xa5, 0x02, 0xb3, 0xa0, 0x0b, 0xe0, 0xd6, 0x4d,
+    0x08, 0x95, 0x4d, 0x09, 0x87, 0x4d, 0x17, 0x85,
+    0x4a, 0x00, 0xa9, 0x4a, 0x00, 0x88, 0x4a, 0x44,
+    0x85, 0x1c, 0x01, 0x80, 0x1c, 0x00, 0xab, 0x1c,
+    0x00, 0x81, 0x1c, 0x02, 0x80, 0x1c, 0x01, 0x80,
+    0x1c, 0x95, 0x39, 0x00, 0x88, 0x39, 0x9f, 0x7c,
+    0x9e, 0x64, 0x07, 0x88, 0x64, 0x2f, 0x92, 0x36,
+    0x00, 0x81, 0x36, 0x04, 0x84, 0x36, 0x9b, 0x7f,
+    0x02, 0x80, 0x7f, 0x99, 0x51, 0x04, 0x80, 0x51,
+    0x3f, 0x9f, 0x5d, 0x97, 0x5c, 0x03, 0x93, 0x5c,
+    0x01, 0xad, 0x5c, 0x83, 0x43, 0x00, 0x81, 0x43,
+    0x04, 0x87, 0x43, 0x00, 0x82, 0x43, 0x00, 0x9c,
+    0x43, 0x01, 0x82, 0x43, 0x03, 0x89, 0x43, 0x06,
+    0x88, 0x43, 0x06, 0x9f, 0x75, 0x9f, 0x71, 0x1f,
+    0xa6, 0x56, 0x03, 0x8b, 0x56, 0x08, 0xb5, 0x06,
+    0x02, 0x86, 0x06, 0x95, 0x3c, 0x01, 0x87, 0x3c,
+    0x92, 0x3b, 0x04, 0x87, 0x3b, 0x91, 0x80, 0x06,
+    0x83, 0x80, 0x0b, 0x86, 0x80, 0x4f, 0xc8, 0x76,
+    0x36, 0xb2, 0x6f, 0x0c, 0xb2, 0x6f, 0x06, 0x85,
+    0x6f, 0xa7, 0x34, 0x07, 0x89, 0x34, 0x05, 0xa5,
+    0x28, 0x02, 0x9c, 0x28, 0x07, 0x81, 0x28, 0x60,
+    0x6f, 0x9e, 0x04, 0x00, 0xa9, 0xa8, 0x00, 0x82,
+    0xa8, 0x01, 0x81, 0xa8, 0x0f, 0x82, 0x04, 0x36,
+    0x83, 0x04, 0xa7, 0x74, 0x07, 0xa9, 0x8a, 0x15,
+    0x99, 0x77, 0x25, 0x9b, 0x18, 0x13, 0x96, 0x26,
+    0x08, 0xcd, 0x0e, 0x03, 0xa3, 0x0e, 0x08, 0x80,
+    0x0e, 0xc2, 0x3e, 0x09, 0x80, 0x3e, 0x01, 0x98,
+    0x8b, 0x06, 0x89, 0x8b, 0x05, 0xb4, 0x15, 0x00,
+    0x91, 0x15, 0x07, 0xa6, 0x53, 0x08, 0xdf, 0x85,
+    0x00, 0x93, 0x89, 0x0a, 0x91, 0x45, 0x00, 0xae,
+    0x45, 0x3d, 0x86, 0x62, 0x00, 0x80, 0x62, 0x00,
+    0x83, 0x62, 0x00, 0x8e, 0x62, 0x00, 0x8a, 0x62,
+    0x05, 0xba, 0x47, 0x04, 0x89, 0x47, 0x05, 0x83,
+    0x2c, 0x00, 0x87, 0x2c, 0x01, 0x81, 0x2c, 0x01,
+    0x95, 0x2c, 0x00, 0x86, 0x2c, 0x00, 0x81, 0x2c,
+    0x00, 0x84, 0x2c, 0x00, 0x80, 0x3a, 0x88, 0x2c,
+    0x01, 0x81, 0x2c, 0x01, 0x82, 0x2c, 0x01, 0x80,
+    0x2c, 0x05, 0x80, 0x2c, 0x04, 0x86, 0x2c, 0x01,
+    0x86, 0x2c, 0x02, 0x84, 0x2c, 0x0a, 0x89, 0xa2,
+    0x00, 0x80, 0xa2, 0x01, 0x80, 0xa2, 0x00, 0xa5,
+    0xa2, 0x00, 0x89, 0xa2, 0x00, 0x80, 0xa2, 0x01,
+    0x80, 0xa2, 0x00, 0x83, 0xa2, 0x00, 0x89, 0xa2,
+    0x00, 0x81, 0xa2, 0x07, 0x81, 0xa2, 0x1c, 0xdb,
+    0x68, 0x00, 0x84, 0x68, 0x1d, 0xc7, 0x9e, 0x07,
+    0x89, 0x9e, 0x60, 0x45, 0xb5, 0x87, 0x01, 0xa5,
+    0x87, 0x21, 0xc4, 0x5f, 0x0a, 0x89, 0x5f, 0x05,
+    0x8c, 0x60, 0x12, 0xb9, 0x96, 0x05, 0x89, 0x96,
+    0x05, 0x93, 0x63, 0x1b, 0x9a, 0x02, 0x01, 0x8e,
     0x02, 0x03, 0x96, 0x02, 0x60, 0x58, 0xbb, 0x22,
-    0x60, 0x03, 0xd2, 0xa0, 0x0b, 0x80, 0xa0, 0x86,
+    0x60, 0x03, 0xd2, 0xa7, 0x0b, 0x80, 0xa7, 0x86,
     0x21, 0x01, 0x80, 0x21, 0x01, 0x87, 0x21, 0x00,
     0x81, 0x21, 0x00, 0x9d, 0x21, 0x00, 0x81, 0x21,
     0x01, 0x8b, 0x21, 0x08, 0x89, 0x21, 0x45, 0x87,
-    0x63, 0x01, 0xad, 0x63, 0x01, 0x8a, 0x63, 0x1a,
-    0xc7, 0xa3, 0x07, 0xd2, 0x88, 0x0c, 0x8f, 0x12,
-    0xb8, 0x79, 0x06, 0x89, 0x20, 0x60, 0x95, 0x88,
-    0x0c, 0x00, 0xac, 0x0c, 0x00, 0x8d, 0x0c, 0x09,
-    0x9c, 0x0c, 0x02, 0x9f, 0x54, 0x01, 0x95, 0x54,
-    0x00, 0x8d, 0x54, 0x48, 0x86, 0x55, 0x00, 0x81,
-    0x55, 0x00, 0xab, 0x55, 0x02, 0x80, 0x55, 0x00,
-    0x81, 0x55, 0x00, 0x88, 0x55, 0x07, 0x89, 0x55,
-    0x05, 0x85, 0x2e, 0x00, 0x81, 0x2e, 0x00, 0xa4,
-    0x2e, 0x00, 0x81, 0x2e, 0x00, 0x85, 0x2e, 0x06,
-    0x89, 0x2e, 0x60, 0xd5, 0x98, 0x4f, 0x06, 0x90,
-    0x3f, 0x00, 0xa8, 0x3f, 0x02, 0x9b, 0x3f, 0x55,
-    0x80, 0x4c, 0x0e, 0xb1, 0x92, 0x0c, 0x80, 0x92,
-    0xe3, 0x39, 0x1b, 0x60, 0x05, 0xe0, 0x0e, 0x1b,
-    0x00, 0x84, 0x1b, 0x0a, 0xe0, 0x63, 0x1b, 0x69,
-    0xeb, 0xe0, 0x02, 0x1e, 0x0c, 0xe3, 0xf5, 0x24,
-    0x6f, 0x49, 0xe1, 0xe6, 0x03, 0x70, 0x11, 0x58,
-    0xe1, 0xd8, 0x08, 0x06, 0x9e, 0x5e, 0x00, 0x89,
-    0x5e, 0x03, 0x81, 0x5e, 0xce, 0x9a, 0x00, 0x89,
-    0x9a, 0x05, 0x9d, 0x09, 0x01, 0x85, 0x09, 0x09,
-    0xc5, 0x77, 0x09, 0x89, 0x77, 0x00, 0x86, 0x77,
-    0x00, 0x94, 0x77, 0x04, 0x92, 0x77, 0x62, 0x4f,
-    0xda, 0x56, 0x60, 0x04, 0xca, 0x5b, 0x03, 0xb8,
-    0x5b, 0x06, 0x90, 0x5b, 0x3f, 0x80, 0x93, 0x80,
-    0x67, 0x81, 0x30, 0x80, 0x44, 0x0a, 0x81, 0x30,
-    0x0d, 0xf0, 0x07, 0x97, 0x93, 0x07, 0xe2, 0x9f,
-    0x93, 0xe1, 0x75, 0x44, 0x29, 0x88, 0x93, 0x70,
-    0x12, 0x86, 0x83, 0x3e, 0x00, 0x86, 0x3e, 0x00,
-    0x81, 0x3e, 0x00, 0x80, 0x3e, 0xe0, 0xbe, 0x36,
-    0x82, 0x3e, 0x0e, 0x80, 0x36, 0x1c, 0x82, 0x36,
-    0x01, 0x80, 0x3e, 0x0d, 0x83, 0x3e, 0x07, 0xe1,
-    0x2b, 0x67, 0x68, 0xa3, 0xe0, 0x0a, 0x23, 0x04,
-    0x8c, 0x23, 0x02, 0x88, 0x23, 0x06, 0x89, 0x23,
-    0x01, 0x83, 0x23, 0x83, 0x19, 0x70, 0x01, 0xfb,
-    0xad, 0x38, 0x01, 0x96, 0x38, 0x08, 0xe0, 0x13,
-    0x19, 0x3b, 0xe0, 0x95, 0x19, 0x09, 0xa6, 0x19,
-    0x01, 0xbd, 0x19, 0x82, 0x38, 0x90, 0x19, 0x87,
-    0x38, 0x81, 0x19, 0x86, 0x38, 0x9d, 0x19, 0x83,
-    0x38, 0xbc, 0x19, 0x14, 0xc5, 0x2c, 0x60, 0x19,
-    0x93, 0x19, 0x0b, 0x93, 0x19, 0x0b, 0xd6, 0x19,
-    0x08, 0x98, 0x19, 0x60, 0x26, 0xd4, 0x19, 0x00,
-    0xc6, 0x19, 0x00, 0x81, 0x19, 0x01, 0x80, 0x19,
-    0x01, 0x81, 0x19, 0x01, 0x83, 0x19, 0x00, 0x8b,
-    0x19, 0x00, 0x80, 0x19, 0x00, 0x86, 0x19, 0x00,
-    0xc0, 0x19, 0x00, 0x83, 0x19, 0x01, 0x87, 0x19,
-    0x00, 0x86, 0x19, 0x00, 0x9b, 0x19, 0x00, 0x83,
-    0x19, 0x00, 0x84, 0x19, 0x00, 0x80, 0x19, 0x02,
-    0x86, 0x19, 0x00, 0xe0, 0xf3, 0x19, 0x01, 0xe0,
-    0xc3, 0x19, 0x01, 0xb1, 0x19, 0xe2, 0x2b, 0x84,
-    0x0e, 0x84, 0x84, 0x00, 0x8e, 0x84, 0x63, 0xef,
-    0x9e, 0x47, 0x05, 0x85, 0x47, 0x60, 0x74, 0x86,
-    0x29, 0x00, 0x90, 0x29, 0x01, 0x86, 0x29, 0x00,
-    0x81, 0x29, 0x00, 0x84, 0x29, 0x04, 0xbd, 0x1d,
-    0x20, 0x80, 0x1d, 0x60, 0x0f, 0xac, 0x68, 0x02,
-    0x8d, 0x68, 0x01, 0x89, 0x68, 0x03, 0x81, 0x68,
-    0x60, 0xdf, 0x9e, 0x9b, 0x10, 0xb9, 0x9f, 0x04,
-    0x80, 0x9f, 0x61, 0x6f, 0xa9, 0x62, 0x62, 0x85,
-    0x86, 0x27, 0x00, 0x83, 0x27, 0x00, 0x81, 0x27,
-    0x00, 0x8e, 0x27, 0x00, 0xe0, 0x64, 0x58, 0x01,
-    0x8f, 0x58, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01,
-    0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19, 0x4b,
-    0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a,
-    0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
-    0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83, 0x04,
-    0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05, 0x80,
-    0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81, 0x04,
-    0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00, 0x80,
-    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
-    0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00, 0x83,
-    0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04, 0x00,
-    0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82, 0x04,
-    0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33, 0x81,
-    0x04, 0x60, 0xad, 0xab, 0x19, 0x03, 0xe0, 0x03,
-    0x19, 0x0b, 0x8e, 0x19, 0x01, 0x8e, 0x19, 0x00,
-    0x8e, 0x19, 0x00, 0xa4, 0x19, 0x09, 0xe0, 0x4d,
-    0x19, 0x37, 0x99, 0x19, 0x80, 0x36, 0x81, 0x19,
-    0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06, 0x81,
-    0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3, 0x77,
-    0x19, 0x03, 0x90, 0x19, 0x02, 0x8c, 0x19, 0x02,
-    0xe0, 0x16, 0x19, 0x03, 0xde, 0x19, 0x05, 0x8b,
-    0x19, 0x03, 0x80, 0x19, 0x0e, 0x8b, 0x19, 0x03,
-    0xb7, 0x19, 0x07, 0x89, 0x19, 0x05, 0xa7, 0x19,
-    0x07, 0x9d, 0x19, 0x01, 0x81, 0x19, 0x4d, 0xe0,
-    0xf3, 0x19, 0x0b, 0x8d, 0x19, 0x01, 0x8c, 0x19,
-    0x02, 0x88, 0x19, 0x06, 0xad, 0x19, 0x00, 0x86,
-    0x19, 0x07, 0x8d, 0x19, 0x03, 0x88, 0x19, 0x06,
-    0x88, 0x19, 0x06, 0xe0, 0x32, 0x19, 0x00, 0xb6,
-    0x19, 0x24, 0x89, 0x19, 0x63, 0xa5, 0xf0, 0x96,
-    0x7f, 0x30, 0x1f, 0xef, 0xd9, 0x30, 0x05, 0xe0,
-    0x7d, 0x30, 0x01, 0xf0, 0x06, 0x21, 0x30, 0x0d,
-    0xf0, 0x0c, 0xd0, 0x30, 0x6b, 0xbe, 0xe1, 0xbd,
-    0x30, 0x65, 0x81, 0xf0, 0x02, 0xea, 0x30, 0x04,
-    0xef, 0xff, 0x30, 0x7a, 0xcb, 0xf0, 0x80, 0x19,
-    0x1d, 0xdf, 0x19, 0x60, 0x1f, 0xe0, 0x8f, 0x38,
+    0x66, 0x01, 0xad, 0x66, 0x01, 0x8a, 0x66, 0x1a,
+    0xc7, 0xaa, 0x07, 0xd2, 0x8c, 0x0c, 0x8f, 0x12,
+    0xb8, 0x7d, 0x06, 0x89, 0x20, 0x60, 0x55, 0xa1,
+    0x8e, 0x0d, 0x89, 0x8e, 0x05, 0x88, 0x0c, 0x00,
+    0xac, 0x0c, 0x00, 0x8d, 0x0c, 0x09, 0x9c, 0x0c,
+    0x02, 0x9f, 0x57, 0x01, 0x95, 0x57, 0x00, 0x8d,
+    0x57, 0x48, 0x86, 0x58, 0x00, 0x81, 0x58, 0x00,
+    0xab, 0x58, 0x02, 0x80, 0x58, 0x00, 0x81, 0x58,
+    0x00, 0x88, 0x58, 0x07, 0x89, 0x58, 0x05, 0x85,
+    0x2f, 0x00, 0x81, 0x2f, 0x00, 0xa4, 0x2f, 0x00,
+    0x81, 0x2f, 0x00, 0x85, 0x2f, 0x06, 0x89, 0x2f,
+    0x60, 0xd5, 0x98, 0x52, 0x06, 0x90, 0x41, 0x00,
+    0xa8, 0x41, 0x02, 0x9c, 0x41, 0x54, 0x80, 0x4f,
+    0x0e, 0xb1, 0x97, 0x0c, 0x80, 0x97, 0xe3, 0x39,
+    0x1b, 0x60, 0x05, 0xe0, 0x0e, 0x1b, 0x00, 0x84,
+    0x1b, 0x0a, 0xe0, 0x63, 0x1b, 0x69, 0xeb, 0xe0,
+    0x02, 0x1e, 0x0c, 0xe3, 0xf5, 0x24, 0x09, 0xef,
+    0x3a, 0x24, 0x04, 0xe1, 0xe6, 0x03, 0x70, 0x0a,
+    0x58, 0xb9, 0x31, 0x66, 0x65, 0xe1, 0xd8, 0x08,
+    0x06, 0x9e, 0x61, 0x00, 0x89, 0x61, 0x03, 0x81,
+    0x61, 0xce, 0x9f, 0x00, 0x89, 0x9f, 0x05, 0x9d,
+    0x09, 0x01, 0x85, 0x09, 0x09, 0xc5, 0x7b, 0x09,
+    0x89, 0x7b, 0x00, 0x86, 0x7b, 0x00, 0x94, 0x7b,
+    0x04, 0x92, 0x7b, 0x61, 0x4f, 0xb9, 0x48, 0x60,
+    0x65, 0xda, 0x59, 0x60, 0x04, 0xca, 0x5e, 0x03,
+    0xb8, 0x5e, 0x06, 0x90, 0x5e, 0x3f, 0x80, 0x98,
+    0x80, 0x6a, 0x81, 0x32, 0x80, 0x46, 0x0a, 0x81,
+    0x32, 0x0d, 0xf0, 0x07, 0x97, 0x98, 0x07, 0xe2,
+    0x9f, 0x98, 0xe1, 0x75, 0x46, 0x28, 0x80, 0x46,
+    0x88, 0x98, 0x70, 0x12, 0x86, 0x83, 0x40, 0x00,
+    0x86, 0x40, 0x00, 0x81, 0x40, 0x00, 0x80, 0x40,
+    0xe0, 0xbe, 0x38, 0x82, 0x40, 0x0e, 0x80, 0x38,
+    0x1c, 0x82, 0x38, 0x01, 0x80, 0x40, 0x0d, 0x83,
+    0x40, 0x07, 0xe1, 0x2b, 0x6a, 0x68, 0xa3, 0xe0,
+    0x0a, 0x23, 0x04, 0x8c, 0x23, 0x02, 0x88, 0x23,
+    0x06, 0x89, 0x23, 0x01, 0x83, 0x23, 0x83, 0x19,
+    0x6e, 0xfb, 0xe0, 0x99, 0x19, 0x05, 0xe1, 0x53,
+    0x19, 0x4b, 0xad, 0x3a, 0x01, 0x96, 0x3a, 0x08,
+    0xe0, 0x13, 0x19, 0x3b, 0xe0, 0x95, 0x19, 0x09,
+    0xa6, 0x19, 0x01, 0xbd, 0x19, 0x82, 0x3a, 0x90,
+    0x19, 0x87, 0x3a, 0x81, 0x19, 0x86, 0x3a, 0x9d,
+    0x19, 0x83, 0x3a, 0xbc, 0x19, 0x14, 0xc5, 0x2d,
+    0x60, 0x19, 0x93, 0x19, 0x0b, 0x93, 0x19, 0x0b,
+    0xd6, 0x19, 0x08, 0x98, 0x19, 0x60, 0x26, 0xd4,
+    0x19, 0x00, 0xc6, 0x19, 0x00, 0x81, 0x19, 0x01,
+    0x80, 0x19, 0x01, 0x81, 0x19, 0x01, 0x83, 0x19,
+    0x00, 0x8b, 0x19, 0x00, 0x80, 0x19, 0x00, 0x86,
+    0x19, 0x00, 0xc0, 0x19, 0x00, 0x83, 0x19, 0x01,
+    0x87, 0x19, 0x00, 0x86, 0x19, 0x00, 0x9b, 0x19,
+    0x00, 0x83, 0x19, 0x00, 0x84, 0x19, 0x00, 0x80,
+    0x19, 0x02, 0x86, 0x19, 0x00, 0xe0, 0xf3, 0x19,
+    0x01, 0xe0, 0xc3, 0x19, 0x01, 0xb1, 0x19, 0xe2,
+    0x2b, 0x88, 0x0e, 0x84, 0x88, 0x00, 0x8e, 0x88,
+    0x63, 0xef, 0x9e, 0x4a, 0x05, 0x85, 0x4a, 0x60,
+    0x74, 0x86, 0x2a, 0x00, 0x90, 0x2a, 0x01, 0x86,
+    0x2a, 0x00, 0x81, 0x2a, 0x00, 0x84, 0x2a, 0x04,
+    0xbd, 0x1d, 0x20, 0x80, 0x1d, 0x60, 0x0f, 0xac,
+    0x6b, 0x02, 0x8d, 0x6b, 0x01, 0x89, 0x6b, 0x03,
+    0x81, 0x6b, 0x60, 0xdf, 0x9e, 0xa1, 0x10, 0xb9,
+    0xa6, 0x04, 0x80, 0xa6, 0x61, 0x6f, 0xa9, 0x65,
+    0x60, 0x75, 0xaa, 0x6e, 0x03, 0x80, 0x6e, 0x61,
+    0x7f, 0x86, 0x27, 0x00, 0x83, 0x27, 0x00, 0x81,
+    0x27, 0x00, 0x8e, 0x27, 0x00, 0xe0, 0x64, 0x5b,
+    0x01, 0x8f, 0x5b, 0x28, 0xcb, 0x01, 0x03, 0x89,
+    0x01, 0x03, 0x81, 0x01, 0x62, 0xb0, 0xc3, 0x19,
+    0x4b, 0xbc, 0x19, 0x60, 0x61, 0x83, 0x04, 0x00,
+    0x9a, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04,
+    0x01, 0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83,
+    0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x05,
+    0x80, 0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x80, 0x04, 0x00, 0x82, 0x04, 0x00, 0x81,
+    0x04, 0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00,
+    0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80,
+    0x04, 0x01, 0x83, 0x04, 0x00, 0x86, 0x04, 0x00,
+    0x83, 0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04,
+    0x00, 0x89, 0x04, 0x00, 0x90, 0x04, 0x04, 0x82,
+    0x04, 0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33,
+    0x81, 0x04, 0x60, 0xad, 0xab, 0x19, 0x03, 0xe0,
+    0x03, 0x19, 0x0b, 0x8e, 0x19, 0x01, 0x8e, 0x19,
+    0x00, 0x8e, 0x19, 0x00, 0xa4, 0x19, 0x09, 0xe0,
+    0x4d, 0x19, 0x37, 0x99, 0x19, 0x80, 0x38, 0x81,
+    0x19, 0x0c, 0xab, 0x19, 0x03, 0x88, 0x19, 0x06,
+    0x81, 0x19, 0x0d, 0x85, 0x19, 0x60, 0x39, 0xe3,
+    0x77, 0x19, 0x03, 0x90, 0x19, 0x02, 0x8c, 0x19,
+    0x02, 0xe0, 0x16, 0x19, 0x03, 0xde, 0x19, 0x05,
+    0x8b, 0x19, 0x03, 0x80, 0x19, 0x0e, 0x8b, 0x19,
+    0x03, 0xb7, 0x19, 0x07, 0x89, 0x19, 0x05, 0xa7,
+    0x19, 0x07, 0x9d, 0x19, 0x01, 0x8b, 0x19, 0x03,
+    0x81, 0x19, 0x3d, 0xe0, 0xf3, 0x19, 0x0b, 0x8d,
+    0x19, 0x01, 0x8c, 0x19, 0x02, 0x89, 0x19, 0x04,
+    0xb7, 0x19, 0x06, 0x8e, 0x19, 0x01, 0x8a, 0x19,
+    0x05, 0x88, 0x19, 0x06, 0xe0, 0x32, 0x19, 0x00,
+    0xe0, 0x05, 0x19, 0x63, 0xa5, 0xf0, 0x96, 0x7f,
+    0x32, 0x1f, 0xef, 0xd9, 0x32, 0x05, 0xe0, 0x7d,
+    0x32, 0x01, 0xf0, 0x06, 0x21, 0x32, 0x0d, 0xf0,
+    0x0c, 0xd0, 0x32, 0x0e, 0xe2, 0x0d, 0x32, 0x69,
+    0x41, 0xe1, 0xbd, 0x32, 0x65, 0x81, 0xf0, 0x02,
+    0xea, 0x32, 0x04, 0xef, 0xff, 0x32, 0x7a, 0xcb,
+    0xf0, 0x80, 0x19, 0x1d, 0xdf, 0x19, 0x60, 0x1f,
+    0xe0, 0x8f, 0x3a,
 };
 
-static const uint8_t unicode_script_ext_table[828] = {
-    0x82, 0xc1, 0x00, 0x00, 0x01, 0x2c, 0x01, 0x00,
-    0x00, 0x01, 0x2c, 0x1c, 0x00, 0x0c, 0x01, 0x47,
-    0x80, 0x92, 0x00, 0x00, 0x02, 0x1d, 0x6e, 0x00,
-    0x02, 0x1d, 0x29, 0x01, 0x02, 0x1d, 0x47, 0x00,
-    0x02, 0x1d, 0x29, 0x81, 0x03, 0x00, 0x00, 0x06,
-    0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1, 0x0d, 0x00,
-    0x00, 0x06, 0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1,
-    0x00, 0x03, 0x04, 0x8b, 0x95, 0x01, 0x00, 0x00,
-    0x07, 0x01, 0x04, 0x66, 0x32, 0x8b, 0x95, 0xa1,
-    0x1f, 0x00, 0x00, 0x09, 0x01, 0x04, 0x52, 0x53,
-    0x73, 0x7c, 0x32, 0x86, 0x8b, 0x09, 0x00, 0x0a,
-    0x02, 0x04, 0x8b, 0x09, 0x00, 0x09, 0x03, 0x04,
-    0x95, 0xa1, 0x05, 0x00, 0x00, 0x02, 0x04, 0x8b,
-    0x62, 0x00, 0x00, 0x02, 0x04, 0x32, 0x81, 0xfb,
-    0x00, 0x00, 0x0d, 0x0b, 0x20, 0x2b, 0x2d, 0x2f,
-    0x3d, 0x47, 0x51, 0x74, 0x81, 0x92, 0x94, 0x99,
-    0x00, 0x0c, 0x0b, 0x20, 0x2b, 0x2d, 0x2f, 0x3d,
-    0x47, 0x51, 0x74, 0x92, 0x94, 0x99, 0x10, 0x00,
-    0x00, 0x14, 0x0b, 0x20, 0x22, 0x2e, 0x55, 0x2b,
-    0x2d, 0x2f, 0x3d, 0x50, 0x51, 0x63, 0x74, 0x45,
-    0x85, 0x8a, 0x91, 0x92, 0x94, 0x99, 0x00, 0x15,
-    0x0b, 0x20, 0x22, 0x2e, 0x55, 0x2b, 0x2d, 0x2f,
-    0x3d, 0x49, 0x50, 0x51, 0x63, 0x74, 0x45, 0x85,
-    0x8a, 0x91, 0x92, 0x94, 0x99, 0x09, 0x04, 0x20,
-    0x22, 0x3c, 0x50, 0x75, 0x00, 0x09, 0x03, 0x0b,
-    0x15, 0x8a, 0x75, 0x00, 0x09, 0x02, 0x2f, 0x5f,
-    0x75, 0x00, 0x09, 0x02, 0x2d, 0x43, 0x80, 0x75,
-    0x00, 0x0d, 0x02, 0x2b, 0x92, 0x80, 0x71, 0x00,
-    0x09, 0x02, 0x3d, 0x63, 0x82, 0xcf, 0x00, 0x09,
-    0x03, 0x15, 0x60, 0x8e, 0x80, 0x30, 0x00, 0x00,
-    0x02, 0x28, 0x47, 0x85, 0xb8, 0x00, 0x01, 0x04,
-    0x11, 0x33, 0x8d, 0x8c, 0x80, 0x4a, 0x00, 0x01,
-    0x02, 0x5d, 0x7a, 0x00, 0x00, 0x00, 0x02, 0x5d,
-    0x7a, 0x84, 0x49, 0x00, 0x00, 0x04, 0x0b, 0x20,
-    0x2b, 0x3d, 0x00, 0x01, 0x20, 0x00, 0x04, 0x0b,
-    0x20, 0x2b, 0x3d, 0x00, 0x02, 0x20, 0x2b, 0x00,
-    0x01, 0x20, 0x01, 0x02, 0x0b, 0x20, 0x00, 0x02,
-    0x20, 0x81, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x02,
-    0x20, 0x81, 0x00, 0x06, 0x20, 0x3d, 0x51, 0x74,
-    0x92, 0x94, 0x00, 0x01, 0x20, 0x01, 0x02, 0x20,
-    0x81, 0x01, 0x01, 0x20, 0x00, 0x02, 0x20, 0x81,
-    0x00, 0x02, 0x0b, 0x20, 0x06, 0x01, 0x20, 0x00,
-    0x02, 0x20, 0x63, 0x00, 0x02, 0x0b, 0x20, 0x01,
-    0x01, 0x20, 0x00, 0x02, 0x0b, 0x20, 0x03, 0x01,
-    0x20, 0x00, 0x08, 0x0b, 0x20, 0x2b, 0x3d, 0x63,
-    0x74, 0x94, 0x99, 0x00, 0x02, 0x20, 0x2b, 0x00,
-    0x03, 0x20, 0x2b, 0x3d, 0x01, 0x02, 0x0b, 0x20,
-    0x00, 0x01, 0x0b, 0x01, 0x02, 0x20, 0x2b, 0x00,
-    0x01, 0x63, 0x80, 0x44, 0x00, 0x01, 0x01, 0x2c,
-    0x35, 0x00, 0x00, 0x02, 0x1d, 0x8b, 0x00, 0x00,
-    0x00, 0x01, 0x8b, 0x81, 0xb3, 0x00, 0x00, 0x02,
-    0x47, 0x5d, 0x80, 0x3f, 0x00, 0x00, 0x03, 0x20,
-    0x2b, 0x47, 0x8c, 0xd1, 0x00, 0x00, 0x02, 0x1d,
-    0x29, 0x81, 0x3c, 0x00, 0x01, 0x06, 0x0d, 0x31,
-    0x30, 0x36, 0x3e, 0xa2, 0x00, 0x05, 0x0d, 0x31,
-    0x30, 0x36, 0x3e, 0x01, 0x00, 0x00, 0x01, 0x30,
-    0x00, 0x00, 0x09, 0x06, 0x0d, 0x31, 0x30, 0x36,
-    0x3e, 0xa2, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x31,
-    0x30, 0x36, 0x3e, 0x07, 0x06, 0x0d, 0x31, 0x30,
-    0x36, 0x3e, 0xa2, 0x03, 0x05, 0x0d, 0x31, 0x30,
-    0x36, 0x3e, 0x09, 0x00, 0x03, 0x02, 0x0d, 0x30,
-    0x01, 0x00, 0x00, 0x05, 0x0d, 0x31, 0x30, 0x36,
-    0x3e, 0x04, 0x02, 0x36, 0x3e, 0x00, 0x00, 0x00,
-    0x05, 0x0d, 0x31, 0x30, 0x36, 0x3e, 0x03, 0x00,
-    0x01, 0x03, 0x30, 0x36, 0x3e, 0x01, 0x01, 0x30,
-    0x58, 0x00, 0x03, 0x02, 0x36, 0x3e, 0x02, 0x00,
-    0x00, 0x02, 0x36, 0x3e, 0x59, 0x00, 0x00, 0x06,
-    0x0d, 0x31, 0x30, 0x36, 0x3e, 0xa2, 0x00, 0x02,
-    0x36, 0x3e, 0x80, 0x12, 0x00, 0x0f, 0x01, 0x30,
-    0x1f, 0x00, 0x23, 0x01, 0x30, 0x3b, 0x00, 0x27,
-    0x01, 0x30, 0x37, 0x00, 0x30, 0x01, 0x30, 0x0e,
-    0x00, 0x0b, 0x01, 0x30, 0x32, 0x00, 0x00, 0x01,
-    0x30, 0x57, 0x00, 0x18, 0x01, 0x30, 0x09, 0x00,
-    0x04, 0x01, 0x30, 0x5f, 0x00, 0x1e, 0x01, 0x30,
-    0xc0, 0x31, 0xef, 0x00, 0x00, 0x02, 0x1d, 0x29,
-    0x80, 0x0f, 0x00, 0x07, 0x02, 0x30, 0x47, 0x80,
-    0xa7, 0x00, 0x02, 0x0e, 0x20, 0x22, 0x2d, 0x2f,
-    0x43, 0x3d, 0x3c, 0x50, 0x51, 0x5c, 0x63, 0x45,
-    0x91, 0x99, 0x02, 0x0d, 0x20, 0x22, 0x2d, 0x2f,
-    0x43, 0x3d, 0x3c, 0x50, 0x5c, 0x63, 0x45, 0x91,
-    0x99, 0x03, 0x0b, 0x20, 0x22, 0x2d, 0x2f, 0x43,
-    0x3c, 0x50, 0x5c, 0x45, 0x91, 0x99, 0x80, 0x36,
-    0x00, 0x00, 0x02, 0x0b, 0x20, 0x00, 0x00, 0x00,
-    0x02, 0x20, 0x92, 0x39, 0x00, 0x00, 0x03, 0x40,
-    0x47, 0x60, 0x80, 0x1f, 0x00, 0x00, 0x02, 0x10,
-    0x3b, 0xc0, 0x12, 0xed, 0x00, 0x01, 0x02, 0x04,
-    0x66, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04, 0x95,
-    0x09, 0x00, 0x00, 0x02, 0x04, 0x95, 0x46, 0x00,
-    0x01, 0x05, 0x0d, 0x31, 0x30, 0x36, 0x3e, 0x80,
-    0x99, 0x00, 0x04, 0x06, 0x0d, 0x31, 0x30, 0x36,
-    0x3e, 0xa2, 0x09, 0x00, 0x00, 0x02, 0x36, 0x3e,
-    0x2c, 0x00, 0x01, 0x02, 0x36, 0x3e, 0x80, 0xdf,
-    0x00, 0x01, 0x03, 0x1e, 0x1c, 0x4b, 0x00, 0x02,
-    0x1c, 0x4b, 0x03, 0x00, 0x2c, 0x03, 0x1c, 0x4a,
-    0x4b, 0x02, 0x00, 0x08, 0x02, 0x1c, 0x4b, 0x81,
-    0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a, 0x87, 0x75,
-    0x00, 0x00, 0x02, 0x53, 0x73, 0x87, 0x8d, 0x00,
-    0x00, 0x02, 0x2b, 0x92, 0x00, 0x00, 0x00, 0x02,
-    0x2b, 0x92, 0x36, 0x00, 0x01, 0x02, 0x2b, 0x92,
-    0x8c, 0x12, 0x00, 0x01, 0x02, 0x2b, 0x92, 0x00,
-    0x00, 0x00, 0x02, 0x2b, 0x92, 0xc0, 0x5c, 0x4b,
-    0x00, 0x03, 0x01, 0x23, 0x96, 0x3b, 0x00, 0x11,
-    0x01, 0x30, 0x9e, 0x5d, 0x00, 0x01, 0x01, 0x30,
-    0xce, 0xcd, 0x2d, 0x00,
+static const uint8_t unicode_script_ext_table[1253] = {
+    0x80, 0x36, 0x00, 0x00, 0x10, 0x06, 0x13, 0x1a,
+    0x23, 0x25, 0x29, 0x2a, 0x2f, 0x2b, 0x2d, 0x32,
+    0x4a, 0x51, 0x53, 0x72, 0x86, 0x81, 0x83, 0x00,
+    0x00, 0x07, 0x0b, 0x1d, 0x20, 0x4a, 0x4f, 0x9b,
+    0xa1, 0x09, 0x00, 0x00, 0x02, 0x0d, 0x4a, 0x00,
+    0x00, 0x02, 0x02, 0x0d, 0x4a, 0x00, 0x00, 0x00,
+    0x02, 0x4a, 0x4f, 0x08, 0x00, 0x00, 0x02, 0x4a,
+    0x9b, 0x00, 0x00, 0x00, 0x02, 0x0d, 0x4a, 0x25,
+    0x00, 0x00, 0x08, 0x17, 0x1a, 0x1d, 0x2d, 0x4a,
+    0x72, 0x8e, 0x93, 0x00, 0x08, 0x17, 0x1d, 0x2d,
+    0x4a, 0x79, 0x8e, 0x93, 0xa0, 0x00, 0x04, 0x17,
+    0x1d, 0x4a, 0x9d, 0x00, 0x05, 0x2a, 0x4a, 0x8e,
+    0x90, 0x9b, 0x00, 0x0b, 0x14, 0x17, 0x1a, 0x1d,
+    0x2b, 0x2d, 0x4a, 0x79, 0x90, 0x9d, 0xa0, 0x00,
+    0x06, 0x1a, 0x25, 0x2a, 0x2b, 0x40, 0x4a, 0x00,
+    0x04, 0x1d, 0x2d, 0x4a, 0x72, 0x00, 0x09, 0x1a,
+    0x23, 0x37, 0x4a, 0x72, 0x90, 0x93, 0x9d, 0xa0,
+    0x00, 0x0a, 0x05, 0x1d, 0x23, 0x2b, 0x2d, 0x37,
+    0x4a, 0x72, 0x90, 0x93, 0x00, 0x02, 0x4a, 0x9d,
+    0x00, 0x03, 0x23, 0x4a, 0x90, 0x00, 0x04, 0x17,
+    0x1d, 0x4a, 0x79, 0x00, 0x03, 0x17, 0x4a, 0x93,
+    0x00, 0x02, 0x4a, 0x8e, 0x00, 0x02, 0x27, 0x4a,
+    0x00, 0x00, 0x00, 0x02, 0x4a, 0x8e, 0x00, 0x03,
+    0x1d, 0x4a, 0xa0, 0x00, 0x00, 0x00, 0x04, 0x2d,
+    0x4a, 0x72, 0xa0, 0x0b, 0x00, 0x00, 0x02, 0x4a,
+    0x90, 0x01, 0x00, 0x00, 0x05, 0x17, 0x23, 0x40,
+    0x4a, 0x90, 0x00, 0x04, 0x17, 0x23, 0x4a, 0x90,
+    0x00, 0x02, 0x4a, 0x90, 0x06, 0x00, 0x00, 0x03,
+    0x4a, 0x8e, 0x90, 0x00, 0x02, 0x4a, 0x90, 0x00,
+    0x00, 0x00, 0x03, 0x17, 0x4a, 0x90, 0x00, 0x06,
+    0x14, 0x17, 0x2b, 0x4a, 0x8e, 0x9b, 0x0f, 0x00,
+    0x00, 0x01, 0x2d, 0x01, 0x00, 0x00, 0x01, 0x2d,
+    0x11, 0x00, 0x00, 0x02, 0x4a, 0x79, 0x04, 0x00,
+    0x00, 0x03, 0x14, 0x4a, 0xa0, 0x03, 0x00, 0x0c,
+    0x01, 0x4a, 0x03, 0x00, 0x01, 0x02, 0x1a, 0x2d,
+    0x80, 0x8c, 0x00, 0x00, 0x02, 0x1d, 0x72, 0x00,
+    0x02, 0x1d, 0x2a, 0x01, 0x02, 0x1d, 0x4a, 0x00,
+    0x02, 0x1d, 0x2a, 0x80, 0x80, 0x00, 0x00, 0x03,
+    0x05, 0x29, 0x2a, 0x80, 0x01, 0x00, 0x00, 0x07,
+    0x04, 0x28, 0x69, 0x34, 0x90, 0x9a, 0xa8, 0x0d,
+    0x00, 0x00, 0x07, 0x04, 0x28, 0x69, 0x34, 0x90,
+    0x9a, 0xa8, 0x00, 0x03, 0x04, 0x90, 0x9a, 0x01,
+    0x00, 0x00, 0x08, 0x01, 0x04, 0x28, 0x69, 0x34,
+    0x90, 0x9a, 0xa8, 0x1f, 0x00, 0x00, 0x09, 0x01,
+    0x04, 0x55, 0x56, 0x77, 0x80, 0x34, 0x8a, 0x90,
+    0x09, 0x00, 0x0a, 0x02, 0x04, 0x90, 0x09, 0x00,
+    0x09, 0x03, 0x04, 0x9a, 0xa8, 0x05, 0x00, 0x00,
+    0x02, 0x04, 0x90, 0x62, 0x00, 0x00, 0x02, 0x04,
+    0x34, 0x81, 0xfb, 0x00, 0x00, 0x0d, 0x0b, 0x20,
+    0x2c, 0x2e, 0x30, 0x3f, 0x4a, 0x54, 0x78, 0x85,
+    0x97, 0x99, 0x9e, 0x00, 0x0c, 0x0b, 0x20, 0x2c,
+    0x2e, 0x30, 0x3f, 0x4a, 0x54, 0x78, 0x97, 0x99,
+    0x9e, 0x10, 0x00, 0x00, 0x15, 0x0b, 0x20, 0x22,
+    0x2f, 0x58, 0x2c, 0x2e, 0x30, 0x3f, 0x53, 0x54,
+    0x66, 0x6e, 0x78, 0x47, 0x89, 0x8f, 0x96, 0x97,
+    0x99, 0x9e, 0x00, 0x17, 0x0b, 0x20, 0x22, 0x2f,
+    0x58, 0x2c, 0x2e, 0x31, 0x30, 0x3f, 0x4c, 0x53,
+    0x54, 0x66, 0x6e, 0x78, 0x47, 0x89, 0x8f, 0x96,
+    0x97, 0x99, 0x9e, 0x09, 0x04, 0x20, 0x22, 0x3e,
+    0x53, 0x75, 0x00, 0x09, 0x03, 0x0b, 0x15, 0x8f,
+    0x75, 0x00, 0x09, 0x02, 0x30, 0x62, 0x75, 0x00,
+    0x09, 0x02, 0x2e, 0x45, 0x80, 0x75, 0x00, 0x0d,
+    0x02, 0x2c, 0x97, 0x80, 0x71, 0x00, 0x09, 0x03,
+    0x3f, 0x66, 0xa2, 0x82, 0xcf, 0x00, 0x09, 0x03,
+    0x15, 0x63, 0x93, 0x80, 0x30, 0x00, 0x00, 0x03,
+    0x29, 0x2a, 0x4a, 0x85, 0x6e, 0x00, 0x02, 0x01,
+    0x82, 0x46, 0x00, 0x01, 0x04, 0x11, 0x35, 0x92,
+    0x91, 0x80, 0x4a, 0x00, 0x01, 0x02, 0x60, 0x7e,
+    0x00, 0x00, 0x00, 0x02, 0x60, 0x7e, 0x84, 0x49,
+    0x00, 0x00, 0x04, 0x0b, 0x20, 0x2c, 0x3f, 0x00,
+    0x01, 0x20, 0x00, 0x04, 0x0b, 0x20, 0x2c, 0x3f,
+    0x00, 0x03, 0x20, 0x2c, 0x3f, 0x00, 0x01, 0x20,
+    0x01, 0x02, 0x0b, 0x20, 0x00, 0x02, 0x20, 0x85,
+    0x00, 0x02, 0x0b, 0x20, 0x00, 0x02, 0x20, 0x85,
+    0x00, 0x06, 0x20, 0x3f, 0x54, 0x78, 0x97, 0x99,
+    0x00, 0x01, 0x20, 0x01, 0x02, 0x20, 0x85, 0x01,
+    0x01, 0x20, 0x00, 0x02, 0x20, 0x85, 0x00, 0x02,
+    0x0b, 0x20, 0x06, 0x01, 0x20, 0x00, 0x02, 0x20,
+    0x66, 0x00, 0x02, 0x0b, 0x20, 0x01, 0x01, 0x20,
+    0x00, 0x02, 0x0b, 0x20, 0x03, 0x01, 0x20, 0x00,
+    0x0b, 0x0b, 0x20, 0x2c, 0x3f, 0x54, 0x66, 0x78,
+    0x89, 0x99, 0x9e, 0xa2, 0x00, 0x02, 0x20, 0x2c,
+    0x00, 0x04, 0x20, 0x2c, 0x3f, 0xa2, 0x01, 0x02,
+    0x0b, 0x20, 0x00, 0x01, 0x0b, 0x01, 0x02, 0x20,
+    0x2c, 0x00, 0x01, 0x66, 0x80, 0x44, 0x00, 0x01,
+    0x01, 0x2d, 0x35, 0x00, 0x00, 0x03, 0x1d, 0x4a,
+    0x90, 0x00, 0x00, 0x00, 0x01, 0x90, 0x81, 0xb3,
+    0x00, 0x00, 0x03, 0x4a, 0x60, 0x7e, 0x1e, 0x00,
+    0x00, 0x02, 0x01, 0x04, 0x09, 0x00, 0x00, 0x06,
+    0x13, 0x29, 0x2a, 0x6f, 0x50, 0x76, 0x01, 0x00,
+    0x00, 0x04, 0x13, 0x2d, 0x6f, 0x5d, 0x80, 0x11,
+    0x00, 0x00, 0x03, 0x20, 0x2c, 0x4a, 0x8c, 0xa5,
+    0x00, 0x00, 0x02, 0x1a, 0x4a, 0x17, 0x00, 0x00,
+    0x02, 0x06, 0x76, 0x00, 0x07, 0x06, 0x13, 0x29,
+    0x6f, 0x3e, 0x51, 0x83, 0x09, 0x00, 0x00, 0x01,
+    0x23, 0x03, 0x00, 0x00, 0x03, 0x01, 0x04, 0x6f,
+    0x00, 0x00, 0x00, 0x02, 0x1d, 0x2a, 0x81, 0x2b,
+    0x00, 0x0f, 0x02, 0x32, 0x98, 0x00, 0x00, 0x00,
+    0x07, 0x0d, 0x33, 0x32, 0x38, 0x40, 0x60, 0xa9,
+    0x00, 0x08, 0x0d, 0x33, 0x32, 0x38, 0x40, 0x60,
+    0x7e, 0xa9, 0x00, 0x05, 0x0d, 0x33, 0x32, 0x38,
+    0x40, 0x01, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00,
+    0x01, 0x08, 0x0d, 0x33, 0x32, 0x38, 0x40, 0x60,
+    0x9c, 0xa9, 0x01, 0x09, 0x0d, 0x33, 0x32, 0x38,
+    0x40, 0x4f, 0x60, 0x9c, 0xa9, 0x05, 0x06, 0x0d,
+    0x33, 0x32, 0x38, 0x40, 0xa9, 0x00, 0x00, 0x00,
+    0x05, 0x0d, 0x33, 0x32, 0x38, 0x40, 0x07, 0x06,
+    0x0d, 0x33, 0x32, 0x38, 0x40, 0xa9, 0x03, 0x05,
+    0x0d, 0x33, 0x32, 0x38, 0x40, 0x09, 0x00, 0x03,
+    0x02, 0x0d, 0x32, 0x01, 0x00, 0x00, 0x05, 0x0d,
+    0x33, 0x32, 0x38, 0x40, 0x04, 0x02, 0x38, 0x40,
+    0x00, 0x00, 0x00, 0x05, 0x0d, 0x33, 0x32, 0x38,
+    0x40, 0x03, 0x00, 0x01, 0x03, 0x32, 0x38, 0x40,
+    0x01, 0x01, 0x32, 0x58, 0x00, 0x03, 0x02, 0x38,
+    0x40, 0x02, 0x00, 0x00, 0x02, 0x38, 0x40, 0x59,
+    0x00, 0x00, 0x06, 0x0d, 0x33, 0x32, 0x38, 0x40,
+    0xa9, 0x00, 0x02, 0x38, 0x40, 0x80, 0x12, 0x00,
+    0x0f, 0x01, 0x32, 0x1f, 0x00, 0x25, 0x01, 0x32,
+    0x08, 0x00, 0x00, 0x02, 0x32, 0x98, 0x2f, 0x00,
+    0x27, 0x01, 0x32, 0x37, 0x00, 0x30, 0x01, 0x32,
+    0x0e, 0x00, 0x0b, 0x01, 0x32, 0x32, 0x00, 0x00,
+    0x01, 0x32, 0x57, 0x00, 0x18, 0x01, 0x32, 0x09,
+    0x00, 0x04, 0x01, 0x32, 0x5f, 0x00, 0x1e, 0x01,
+    0x32, 0xc0, 0x31, 0xef, 0x00, 0x00, 0x02, 0x1d,
+    0x2a, 0x80, 0x0f, 0x00, 0x07, 0x02, 0x32, 0x4a,
+    0x80, 0xa7, 0x00, 0x02, 0x10, 0x20, 0x22, 0x2e,
+    0x30, 0x45, 0x3f, 0x3e, 0x53, 0x54, 0x5f, 0x66,
+    0x85, 0x47, 0x96, 0x9e, 0xa2, 0x02, 0x0f, 0x20,
+    0x22, 0x2e, 0x30, 0x45, 0x3f, 0x3e, 0x53, 0x5f,
+    0x66, 0x85, 0x47, 0x96, 0x9e, 0xa2, 0x01, 0x0b,
+    0x20, 0x22, 0x2e, 0x30, 0x45, 0x3e, 0x53, 0x5f,
+    0x47, 0x96, 0x9e, 0x00, 0x0c, 0x20, 0x22, 0x2e,
+    0x30, 0x45, 0x3e, 0x53, 0x5f, 0x85, 0x47, 0x96,
+    0x9e, 0x00, 0x0b, 0x20, 0x22, 0x2e, 0x30, 0x45,
+    0x3e, 0x53, 0x5f, 0x47, 0x96, 0x9e, 0x80, 0x36,
+    0x00, 0x00, 0x03, 0x0b, 0x20, 0xa2, 0x00, 0x00,
+    0x00, 0x02, 0x20, 0x97, 0x39, 0x00, 0x00, 0x03,
+    0x42, 0x4a, 0x63, 0x80, 0x1f, 0x00, 0x00, 0x02,
+    0x10, 0x3d, 0xc0, 0x12, 0xed, 0x00, 0x01, 0x02,
+    0x04, 0x69, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04,
+    0x9a, 0x09, 0x00, 0x00, 0x02, 0x04, 0x9a, 0x46,
+    0x00, 0x01, 0x05, 0x0d, 0x33, 0x32, 0x38, 0x40,
+    0x80, 0x99, 0x00, 0x04, 0x06, 0x0d, 0x33, 0x32,
+    0x38, 0x40, 0xa9, 0x09, 0x00, 0x00, 0x02, 0x38,
+    0x40, 0x2c, 0x00, 0x01, 0x02, 0x38, 0x40, 0x80,
+    0xdf, 0x00, 0x01, 0x03, 0x1e, 0x1c, 0x4e, 0x00,
+    0x02, 0x1c, 0x4e, 0x03, 0x00, 0x2c, 0x03, 0x1c,
+    0x4d, 0x4e, 0x02, 0x00, 0x08, 0x02, 0x1c, 0x4e,
+    0x81, 0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1a, 0x87,
+    0x75, 0x00, 0x00, 0x02, 0x56, 0x77, 0x87, 0x8d,
+    0x00, 0x00, 0x02, 0x2c, 0x97, 0x00, 0x00, 0x00,
+    0x02, 0x2c, 0x97, 0x36, 0x00, 0x01, 0x02, 0x2c,
+    0x97, 0x8c, 0x12, 0x00, 0x01, 0x02, 0x2c, 0x97,
+    0x00, 0x00, 0x00, 0x02, 0x2c, 0x97, 0xc0, 0x5c,
+    0x4b, 0x00, 0x03, 0x01, 0x23, 0x96, 0x3b, 0x00,
+    0x11, 0x01, 0x32, 0x9e, 0x5d, 0x00, 0x01, 0x01,
+    0x32, 0xce, 0xcd, 0x2d, 0x00,
 };
 
 static const uint8_t unicode_prop_Hyphen_table[28] = {
@@ -3651,61 +3852,63 @@ static const uint8_t unicode_prop_Other_Math_table[200] = {
     0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
 };
 
-static const uint8_t unicode_prop_Other_Alphabetic_table[428] = {
-    0x43, 0x44, 0x80, 0x42, 0x69, 0x8d, 0x00, 0x01,
-    0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c, 0x06, 0x8f,
-    0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80,
-    0x9d, 0x8f, 0xe5, 0x8a, 0xe4, 0x0a, 0x88, 0x02,
-    0x03, 0x40, 0xa6, 0x8b, 0x16, 0x85, 0x93, 0xb5,
-    0x09, 0x8e, 0x01, 0x22, 0x89, 0x81, 0x9c, 0x82,
-    0xb9, 0x31, 0x09, 0x81, 0x89, 0x80, 0x89, 0x81,
-    0x9c, 0x82, 0xb9, 0x23, 0x09, 0x0b, 0x80, 0x9d,
-    0x0a, 0x80, 0x8a, 0x82, 0xb9, 0x38, 0x10, 0x81,
-    0x94, 0x81, 0x95, 0x13, 0x82, 0xb9, 0x31, 0x09,
-    0x81, 0x88, 0x81, 0x89, 0x81, 0x9d, 0x80, 0xba,
-    0x22, 0x10, 0x82, 0x89, 0x80, 0xa7, 0x84, 0xb8,
-    0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9c, 0x82,
-    0xb9, 0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x8e,
-    0x80, 0x8b, 0x83, 0xb9, 0x30, 0x10, 0x82, 0x89,
-    0x80, 0x89, 0x81, 0x9c, 0x82, 0xca, 0x28, 0x00,
-    0x87, 0x91, 0x81, 0xbc, 0x01, 0x86, 0x91, 0x80,
-    0xe2, 0x01, 0x28, 0x81, 0x8f, 0x80, 0x40, 0xa2,
-    0x92, 0x88, 0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00,
-    0x0b, 0x96, 0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c,
-    0x8b, 0x00, 0x89, 0x83, 0x46, 0x73, 0x81, 0x9d,
-    0x81, 0x9d, 0x81, 0x9d, 0x81, 0xc1, 0x92, 0x40,
-    0xbb, 0x81, 0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88,
-    0x40, 0xdd, 0x84, 0xb8, 0x89, 0x81, 0x93, 0xc9,
-    0x81, 0x8a, 0x82, 0xb0, 0x84, 0xaf, 0x8e, 0xbb,
-    0x82, 0x9d, 0x88, 0x09, 0xb8, 0x8a, 0xb1, 0x92,
-    0x41, 0xaf, 0x8d, 0x46, 0xc0, 0xb3, 0x48, 0xf5,
-    0x9f, 0x60, 0x78, 0x73, 0x87, 0xa1, 0x81, 0x41,
-    0x61, 0x07, 0x80, 0x96, 0x84, 0xd7, 0x81, 0xb1,
-    0x8f, 0x00, 0xb8, 0x80, 0xa5, 0x84, 0x9b, 0x8b,
-    0xac, 0x83, 0xaf, 0x8b, 0xa4, 0x80, 0xc2, 0x8d,
-    0x8b, 0x07, 0x81, 0xac, 0x82, 0xb1, 0x00, 0x11,
-    0x0c, 0x80, 0xab, 0x24, 0x80, 0x40, 0xec, 0x87,
-    0x60, 0x4f, 0x32, 0x80, 0x48, 0x56, 0x84, 0x46,
-    0x85, 0x10, 0x0c, 0x83, 0x43, 0x13, 0x83, 0x41,
-    0x82, 0x81, 0x41, 0x52, 0x82, 0xb4, 0x8d, 0xac,
-    0x81, 0x8a, 0x82, 0xac, 0x88, 0x88, 0x80, 0xbc,
-    0x82, 0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf,
-    0x8c, 0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x08,
-    0x40, 0x9c, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09,
-    0x81, 0x89, 0x80, 0x89, 0x81, 0x40, 0xd0, 0x8c,
-    0x02, 0xe9, 0x91, 0x40, 0xec, 0x31, 0x86, 0x9c,
-    0x81, 0xd1, 0x8e, 0x00, 0xe9, 0x8a, 0xe6, 0x8d,
-    0x41, 0x00, 0x8c, 0x40, 0xf6, 0x28, 0x09, 0x0a,
-    0x00, 0x80, 0x40, 0x8d, 0x31, 0x2b, 0x80, 0x9b,
-    0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a, 0xad, 0x8d,
-    0x41, 0x96, 0x38, 0x86, 0xd2, 0x95, 0x80, 0x8d,
-    0xf9, 0x2a, 0x00, 0x08, 0x10, 0x02, 0x80, 0xc1,
-    0x20, 0x08, 0x83, 0x41, 0x5b, 0x83, 0x88, 0x08,
-    0x80, 0xaf, 0x32, 0x82, 0x60, 0x50, 0x0d, 0x00,
-    0xb6, 0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80,
-    0x60, 0x23, 0x60, 0x30, 0x90, 0x0e, 0x01, 0x04,
-    0xe3, 0x80, 0x48, 0xb6, 0x80, 0x47, 0xe7, 0x99,
-    0x85, 0x99, 0x85, 0x99,
+static const uint8_t unicode_prop_Other_Alphabetic_table[443] = {
+    0x43, 0x44, 0x80, 0x9c, 0x8c, 0x42, 0x3f, 0x8d,
+    0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c,
+    0x06, 0x8f, 0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80,
+    0xa2, 0x80, 0x9d, 0x8f, 0xe5, 0x8a, 0xe4, 0x0a,
+    0x88, 0x02, 0x03, 0xe9, 0x80, 0xbb, 0x8b, 0x16,
+    0x85, 0x93, 0xb5, 0x09, 0x8e, 0x01, 0x22, 0x89,
+    0x81, 0x9c, 0x82, 0xb9, 0x31, 0x09, 0x81, 0x89,
+    0x80, 0x89, 0x81, 0x9c, 0x82, 0xb9, 0x23, 0x09,
+    0x0b, 0x80, 0x9d, 0x0a, 0x80, 0x8a, 0x82, 0xb9,
+    0x38, 0x10, 0x81, 0x94, 0x81, 0x95, 0x13, 0x82,
+    0xb9, 0x31, 0x09, 0x81, 0x88, 0x81, 0x89, 0x81,
+    0x9d, 0x80, 0xba, 0x22, 0x10, 0x82, 0x89, 0x80,
+    0xa7, 0x84, 0xb8, 0x30, 0x10, 0x17, 0x81, 0x8a,
+    0x81, 0x9c, 0x82, 0xb9, 0x30, 0x10, 0x17, 0x81,
+    0x8a, 0x81, 0x8e, 0x80, 0x8b, 0x83, 0xb9, 0x30,
+    0x10, 0x82, 0x89, 0x80, 0x89, 0x81, 0x9c, 0x82,
+    0xca, 0x28, 0x00, 0x87, 0x91, 0x81, 0xbc, 0x01,
+    0x86, 0x91, 0x80, 0xe2, 0x01, 0x28, 0x81, 0x8f,
+    0x80, 0x40, 0xa2, 0x92, 0x88, 0x8a, 0x80, 0xa3,
+    0xed, 0x8b, 0x00, 0x0b, 0x96, 0x1b, 0x10, 0x11,
+    0x32, 0x83, 0x8c, 0x8b, 0x00, 0x89, 0x83, 0x46,
+    0x73, 0x81, 0x9d, 0x81, 0x9d, 0x81, 0x9d, 0x81,
+    0xc1, 0x92, 0x40, 0xbb, 0x81, 0xa1, 0x80, 0xf5,
+    0x8b, 0x83, 0x88, 0x40, 0xdd, 0x84, 0xb8, 0x89,
+    0x81, 0x93, 0xc9, 0x81, 0x8a, 0x82, 0xb0, 0x84,
+    0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09, 0xb8,
+    0x8a, 0xb1, 0x92, 0x41, 0x9b, 0xa1, 0x46, 0xc0,
+    0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73, 0x87,
+    0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96, 0x84,
+    0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80, 0xa5,
+    0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b, 0xa4,
+    0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac, 0x82,
+    0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24, 0x80,
+    0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80, 0x48,
+    0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0x43,
+    0x13, 0x83, 0xc0, 0x80, 0x41, 0x40, 0x81, 0xce,
+    0x80, 0x41, 0x02, 0x82, 0xb4, 0x8d, 0xac, 0x81,
+    0x8a, 0x82, 0xac, 0x88, 0x88, 0x80, 0xbc, 0x82,
+    0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf, 0x8c,
+    0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x08, 0x40,
+    0x9c, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09, 0x81,
+    0x89, 0x80, 0x89, 0x81, 0xd3, 0x88, 0x00, 0x08,
+    0x03, 0x01, 0xe6, 0x8c, 0x02, 0xe9, 0x91, 0x40,
+    0xec, 0x31, 0x86, 0x9c, 0x81, 0xd1, 0x8e, 0x00,
+    0xe9, 0x8a, 0xe6, 0x8d, 0x41, 0x00, 0x8c, 0x40,
+    0xf6, 0x28, 0x09, 0x0a, 0x00, 0x80, 0x40, 0x8d,
+    0x31, 0x2b, 0x80, 0x9b, 0x89, 0xa9, 0x20, 0x83,
+    0x91, 0x8a, 0xad, 0x8d, 0x41, 0x96, 0x38, 0x86,
+    0xd2, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08,
+    0x10, 0x02, 0x80, 0xc1, 0x20, 0x08, 0x83, 0x41,
+    0x5b, 0x83, 0x88, 0x08, 0x80, 0xaf, 0x32, 0x82,
+    0x60, 0x41, 0xdc, 0x90, 0x4e, 0x1f, 0x00, 0xb6,
+    0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80, 0x60,
+    0x23, 0x60, 0x30, 0x90, 0x0e, 0x01, 0x04, 0xe3,
+    0x80, 0x48, 0xb6, 0x80, 0x47, 0xe7, 0x99, 0x85,
+    0x99, 0x85, 0x99,
 };
 
 static const uint8_t unicode_prop_Other_Lowercase_table[69] = {
@@ -3725,16 +3928,21 @@ static const uint8_t unicode_prop_Other_Uppercase_table[15] = {
     0xcc, 0x5f, 0x99, 0x85, 0x99, 0x85, 0x99,
 };
 
-static const uint8_t unicode_prop_Other_Grapheme_Extend_table[65] = {
+static const uint8_t unicode_prop_Other_Grapheme_Extend_table[112] = {
     0x49, 0xbd, 0x80, 0x97, 0x80, 0x41, 0x65, 0x80,
-    0x97, 0x80, 0xe5, 0x80, 0x97, 0x80, 0x40, 0xe9,
-    0x80, 0x91, 0x81, 0xe6, 0x80, 0x97, 0x80, 0xf6,
-    0x80, 0x8e, 0x80, 0x4d, 0x54, 0x80, 0x44, 0xd5,
-    0x80, 0x50, 0x20, 0x81, 0x60, 0xcf, 0x6d, 0x81,
-    0x53, 0x9d, 0x80, 0x97, 0x80, 0x41, 0x57, 0x80,
-    0x8b, 0x80, 0x40, 0xf0, 0x80, 0x43, 0x7f, 0x80,
-    0x60, 0xb8, 0x33, 0x07, 0x84, 0x6c, 0x2e, 0xac,
-    0xdf,
+    0x97, 0x80, 0xe5, 0x80, 0x97, 0x80, 0x40, 0xe7,
+    0x00, 0x03, 0x08, 0x81, 0x88, 0x81, 0xe6, 0x80,
+    0x97, 0x80, 0xf6, 0x80, 0x8e, 0x80, 0x49, 0x34,
+    0x80, 0x9d, 0x80, 0x43, 0xff, 0x04, 0x00, 0x04,
+    0x81, 0xe4, 0x80, 0xc6, 0x81, 0x44, 0x17, 0x80,
+    0x50, 0x20, 0x81, 0x60, 0x79, 0x22, 0x80, 0xeb,
+    0x80, 0x60, 0x55, 0xdc, 0x81, 0x52, 0x1f, 0x80,
+    0xf3, 0x80, 0x41, 0x07, 0x80, 0x8d, 0x80, 0x88,
+    0x80, 0xdf, 0x80, 0x88, 0x01, 0x00, 0x14, 0x80,
+    0x40, 0xdf, 0x80, 0x8b, 0x80, 0x40, 0xf0, 0x80,
+    0x41, 0x05, 0x80, 0x42, 0x78, 0x80, 0x8b, 0x80,
+    0x46, 0x02, 0x80, 0x60, 0x50, 0xad, 0x81, 0x60,
+    0x61, 0x72, 0x0d, 0x85, 0x6c, 0x2e, 0xac, 0xdf,
 };
 
 static const uint8_t unicode_prop_Other_Default_Ignorable_Code_Point_table[32] = {
@@ -3749,9 +3957,10 @@ static const uint8_t unicode_prop_Other_ID_Start_table[11] = {
     0x4f, 0x6b, 0x81,
 };
 
-static const uint8_t unicode_prop_Other_ID_Continue_table[12] = {
+static const uint8_t unicode_prop_Other_ID_Continue_table[22] = {
     0x40, 0xb6, 0x80, 0x42, 0xce, 0x80, 0x4f, 0xe0,
-    0x88, 0x46, 0x67, 0x80,
+    0x88, 0x46, 0x67, 0x80, 0x46, 0x30, 0x81, 0x50,
+    0xec, 0x80, 0x60, 0xce, 0x68, 0x80,
 };
 
 static const uint8_t unicode_prop_Prepended_Concatenation_Mark_table[19] = {
@@ -3779,72 +3988,154 @@ static const uint8_t unicode_prop_Changes_When_Titlecased1_table[22] = {
     0x8b, 0x80, 0x8e, 0x80, 0xae, 0x80,
 };
 
-static const uint8_t unicode_prop_Changes_When_Casefolded1_table[33] = {
-    0x40, 0xde, 0x80, 0xcf, 0x80, 0x97, 0x80, 0x44,
-    0x3c, 0x80, 0x59, 0x11, 0x80, 0x40, 0xe4, 0x3f,
-    0x3f, 0x87, 0x89, 0x11, 0x05, 0x02, 0x11, 0x80,
-    0xa9, 0x11, 0x80, 0x60, 0xdb, 0x07, 0x86, 0x8b,
-    0x84,
+static const uint8_t unicode_prop_Changes_When_Casefolded1_table[29] = {
+    0x41, 0xef, 0x80, 0x41, 0x9e, 0x80, 0x9e, 0x80,
+    0x5a, 0xe4, 0x83, 0x40, 0xb5, 0x00, 0x00, 0x00,
+    0x80, 0xde, 0x06, 0x06, 0x80, 0x8a, 0x09, 0x81,
+    0x89, 0x10, 0x81, 0x8d, 0x80,
 };
 
-static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[451] = {
+static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[450] = {
     0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12,
-    0x10, 0x82, 0x9f, 0x80, 0xcf, 0x01, 0x80, 0x8b,
-    0x07, 0x80, 0xfb, 0x01, 0x01, 0x80, 0xa5, 0x80,
-    0x40, 0xbb, 0x88, 0x9e, 0x29, 0x84, 0xda, 0x08,
-    0x81, 0x89, 0x80, 0xa3, 0x04, 0x02, 0x04, 0x08,
-    0x80, 0xc9, 0x82, 0x9c, 0x80, 0x41, 0x93, 0x80,
-    0x40, 0x93, 0x80, 0xd7, 0x83, 0x42, 0xde, 0x87,
-    0xfb, 0x08, 0x80, 0xd2, 0x01, 0x80, 0xa1, 0x11,
-    0x80, 0x40, 0xfc, 0x81, 0x42, 0xd4, 0x80, 0xfe,
-    0x80, 0xa7, 0x81, 0xad, 0x80, 0xb5, 0x80, 0x88,
-    0x03, 0x03, 0x03, 0x80, 0x8b, 0x80, 0x88, 0x00,
-    0x26, 0x80, 0x90, 0x80, 0x88, 0x03, 0x03, 0x03,
-    0x80, 0x8b, 0x80, 0x41, 0x41, 0x80, 0xe1, 0x81,
-    0x46, 0x52, 0x81, 0xd4, 0x84, 0x45, 0x1b, 0x10,
-    0x8a, 0x80, 0x91, 0x80, 0x9b, 0x8c, 0x80, 0xa1,
-    0xa4, 0x40, 0xd9, 0x80, 0x40, 0xd5, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x3f, 0x3f, 0x87,
-    0x89, 0x11, 0x04, 0x00, 0x29, 0x04, 0x12, 0x80,
-    0x88, 0x12, 0x80, 0x88, 0x11, 0x11, 0x04, 0x08,
-    0x8f, 0x00, 0x20, 0x8b, 0x12, 0x2a, 0x08, 0x0b,
-    0x00, 0x07, 0x82, 0x8c, 0x06, 0x92, 0x81, 0x9a,
-    0x80, 0x8c, 0x8a, 0x80, 0xd6, 0x18, 0x10, 0x8a,
-    0x01, 0x0c, 0x0a, 0x00, 0x10, 0x11, 0x02, 0x06,
-    0x05, 0x1c, 0x85, 0x8f, 0x8f, 0x8f, 0x88, 0x80,
-    0x40, 0xa1, 0x08, 0x81, 0x40, 0xf7, 0x81, 0x41,
-    0x34, 0xd5, 0x99, 0x9a, 0x45, 0x20, 0x80, 0xe6,
-    0x82, 0xe4, 0x80, 0x41, 0x9e, 0x81, 0x40, 0xf0,
-    0x80, 0x41, 0x2e, 0x80, 0xd2, 0x80, 0x8b, 0x40,
-    0xd5, 0xa9, 0x80, 0xb4, 0x00, 0x82, 0xdf, 0x09,
-    0x80, 0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf,
-    0x9e, 0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f,
-    0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0x40,
-    0x80, 0x12, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80,
-    0x60, 0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81,
-    0x89, 0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9,
-    0xa5, 0x86, 0x8b, 0x24, 0x00, 0x97, 0x04, 0x00,
-    0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91,
-    0xbf, 0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95,
-    0x94, 0x81, 0x8b, 0x80, 0x92, 0x03, 0x1a, 0x00,
-    0x80, 0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40,
-    0x83, 0x15, 0x0d, 0x0d, 0x0a, 0x16, 0x06, 0x80,
-    0x88, 0x47, 0x87, 0x20, 0xa9, 0x80, 0x88, 0x60,
-    0xb4, 0xe4, 0x83, 0x54, 0xb9, 0x86, 0x8d, 0x87,
-    0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01,
-    0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80,
-    0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04,
-    0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23,
-    0x81, 0xb1, 0x48, 0x2f, 0xbd, 0x4d, 0x91, 0x18,
-    0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00,
-    0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b,
-    0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90,
-    0x22, 0x04, 0x80, 0x90, 0x42, 0x43, 0x8a, 0x84,
-    0x9e, 0x80, 0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee,
-    0x82, 0x8c, 0xab, 0x83, 0x88, 0x31, 0x49, 0x9d,
-    0x89, 0x60, 0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05,
-    0xe1, 0x4f, 0xff,
+    0x10, 0x82, 0xf3, 0x80, 0x8b, 0x80, 0x40, 0x84,
+    0x01, 0x01, 0x80, 0xa2, 0x01, 0x80, 0x40, 0xbb,
+    0x88, 0x9e, 0x29, 0x84, 0xda, 0x08, 0x81, 0x89,
+    0x80, 0xa3, 0x04, 0x02, 0x04, 0x08, 0x07, 0x80,
+    0x9e, 0x80, 0xa0, 0x82, 0x9c, 0x80, 0x42, 0x28,
+    0x80, 0xd7, 0x83, 0x42, 0xde, 0x87, 0xfb, 0x08,
+    0x80, 0xd2, 0x01, 0x80, 0xa1, 0x11, 0x80, 0x40,
+    0xfc, 0x81, 0x42, 0xd4, 0x80, 0xfe, 0x80, 0xa7,
+    0x81, 0xad, 0x80, 0xb5, 0x80, 0x88, 0x03, 0x03,
+    0x03, 0x80, 0x8b, 0x80, 0x88, 0x00, 0x26, 0x80,
+    0x90, 0x80, 0x88, 0x03, 0x03, 0x03, 0x80, 0x8b,
+    0x80, 0x41, 0x41, 0x80, 0xe1, 0x81, 0x46, 0x52,
+    0x81, 0xd4, 0x84, 0x45, 0x1b, 0x10, 0x8a, 0x80,
+    0x91, 0x80, 0x9b, 0x8c, 0x80, 0xa1, 0xa4, 0x40,
+    0xd5, 0x83, 0x40, 0xb5, 0x00, 0x00, 0x00, 0x80,
+    0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+    0xb7, 0x05, 0x00, 0x13, 0x05, 0x11, 0x02, 0x0c,
+    0x11, 0x00, 0x00, 0x0c, 0x15, 0x05, 0x08, 0x8f,
+    0x00, 0x20, 0x8b, 0x12, 0x2a, 0x08, 0x0b, 0x00,
+    0x07, 0x82, 0x8c, 0x06, 0x92, 0x81, 0x9a, 0x80,
+    0x8c, 0x8a, 0x80, 0xd6, 0x18, 0x10, 0x8a, 0x01,
+    0x0c, 0x0a, 0x00, 0x10, 0x11, 0x02, 0x06, 0x05,
+    0x1c, 0x85, 0x8f, 0x8f, 0x8f, 0x88, 0x80, 0x40,
+    0xa1, 0x08, 0x81, 0x40, 0xf7, 0x81, 0x41, 0x34,
+    0xd5, 0x99, 0x9a, 0x45, 0x20, 0x80, 0xe6, 0x82,
+    0xe4, 0x80, 0x41, 0x9e, 0x81, 0x40, 0xf0, 0x80,
+    0x41, 0x2e, 0x80, 0xd2, 0x80, 0x8b, 0x40, 0xd5,
+    0xa9, 0x80, 0xb4, 0x00, 0x82, 0xdf, 0x09, 0x80,
+    0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf, 0x9e,
+    0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f, 0x60,
+    0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0x40, 0x80,
+    0x12, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80, 0x60,
+    0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81, 0x89,
+    0x00, 0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9, 0xc2,
+    0x00, 0x97, 0x04, 0x00, 0x01, 0x01, 0x80, 0xeb,
+    0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5, 0xa7,
+    0x8c, 0x82, 0x99, 0x95, 0x94, 0x81, 0x8b, 0x80,
+    0x92, 0x03, 0x1a, 0x00, 0x80, 0x40, 0x86, 0x08,
+    0x80, 0x9f, 0x99, 0x40, 0x83, 0x15, 0x0d, 0x0d,
+    0x0a, 0x16, 0x06, 0x80, 0x88, 0x47, 0x87, 0x20,
+    0xa9, 0x80, 0x88, 0x60, 0xb4, 0xe4, 0x83, 0x50,
+    0x31, 0xa3, 0x44, 0x63, 0x86, 0x8d, 0x87, 0xbf,
+    0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01, 0x08,
+    0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0,
+    0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00,
+    0x16, 0x80, 0x41, 0x53, 0x81, 0x41, 0x23, 0x81,
+    0xb1, 0x48, 0x2f, 0xbd, 0x4d, 0x91, 0x18, 0x9a,
+    0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00,
+    0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06,
+    0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22,
+    0x04, 0x80, 0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e,
+    0x80, 0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee, 0x82,
+    0x8c, 0xab, 0x83, 0x88, 0x31, 0x49, 0x9d, 0x89,
+    0x60, 0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1,
+    0x4f, 0xff,
+};
+
+static const uint8_t unicode_prop_Basic_Emoji1_table[143] = {
+    0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
+    0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
+    0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
+    0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
+    0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00,
+    0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
+    0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61,
+    0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
+    0x01, 0x89, 0xe5, 0x80, 0x97, 0x80, 0x93, 0x01,
+    0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0, 0x8b,
+    0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c,
+    0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80, 0x40,
+    0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80,
+    0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf, 0xc5,
+    0x28, 0x12, 0x0a, 0x1b, 0x8a, 0x0e, 0x88, 0x40,
+    0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89,
+    0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x89, 0x84,
+    0xb7, 0x86, 0x8e, 0x81, 0x8a, 0x85, 0x88,
+};
+
+static const uint8_t unicode_prop_Basic_Emoji2_table[183] = {
+    0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b,
+    0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
+    0x8e, 0x81, 0x41, 0x7c, 0x80, 0x40, 0xa5, 0x80,
+    0x9c, 0x10, 0x0c, 0x82, 0x40, 0xc6, 0x80, 0x40,
+    0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x0a,
+    0x84, 0x88, 0x01, 0x05, 0x03, 0x01, 0x00, 0x09,
+    0x02, 0x02, 0x0f, 0x14, 0x00, 0x80, 0x9b, 0x09,
+    0x00, 0x08, 0x80, 0x91, 0x01, 0x80, 0x92, 0x00,
+    0x18, 0x00, 0x0a, 0x05, 0x07, 0x81, 0x95, 0x05,
+    0x00, 0x00, 0x80, 0x94, 0x05, 0x09, 0x01, 0x17,
+    0x04, 0x09, 0x08, 0x01, 0x00, 0x00, 0x05, 0x02,
+    0x80, 0x90, 0x81, 0x8e, 0x01, 0x80, 0x9a, 0x81,
+    0xbb, 0x80, 0x41, 0x91, 0x81, 0x41, 0xce, 0x82,
+    0x45, 0x27, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
+    0x80, 0x61, 0xbe, 0xd5, 0x81, 0x8b, 0x81, 0x40,
+    0x81, 0x80, 0xb3, 0x80, 0x40, 0xe8, 0x01, 0x88,
+    0x88, 0x80, 0xc5, 0x80, 0x97, 0x08, 0x11, 0x81,
+    0xaa, 0x1c, 0x8b, 0x92, 0x00, 0x00, 0x80, 0xc6,
+    0x00, 0x80, 0x40, 0xba, 0x80, 0xca, 0x81, 0xa3,
+    0x09, 0x86, 0x8c, 0x01, 0x19, 0x80, 0x93, 0x01,
+    0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11,
+    0x00, 0x03, 0x05, 0x02, 0x05, 0x80, 0x40, 0xcf,
+    0x00, 0x82, 0x8f, 0x2a, 0x05, 0x01, 0x80,
+};
+
+static const uint8_t unicode_prop_RGI_Emoji_Modifier_Sequence_table[73] = {
+    0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
+    0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
+    0x82, 0xf4, 0x09, 0x8a, 0x94, 0x18, 0x18, 0x88,
+    0x10, 0x1a, 0x02, 0x30, 0x00, 0x97, 0x80, 0x40,
+    0xc8, 0x0b, 0x80, 0x94, 0x03, 0x81, 0x40, 0xad,
+    0x12, 0x84, 0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80,
+    0x8a, 0x80, 0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80,
+    0x88, 0x89, 0x11, 0xb7, 0x80, 0xbc, 0x08, 0x08,
+    0x80, 0x90, 0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9,
+    0x88,
+};
+
+static const uint8_t unicode_prop_RGI_Emoji_Flag_Sequence_table[128] = {
+    0x0c, 0x00, 0x09, 0x00, 0x04, 0x01, 0x02, 0x06,
+    0x03, 0x03, 0x01, 0x02, 0x01, 0x03, 0x07, 0x0d,
+    0x18, 0x00, 0x09, 0x00, 0x00, 0x89, 0x08, 0x00,
+    0x00, 0x81, 0x88, 0x83, 0x8c, 0x10, 0x00, 0x01,
+    0x07, 0x08, 0x29, 0x10, 0x28, 0x00, 0x80, 0x8a,
+    0x00, 0x0a, 0x00, 0x0e, 0x15, 0x18, 0x83, 0x89,
+    0x06, 0x00, 0x81, 0x8d, 0x00, 0x12, 0x08, 0x00,
+    0x03, 0x00, 0x24, 0x00, 0x05, 0x21, 0x00, 0x00,
+    0x29, 0x90, 0x00, 0x02, 0x00, 0x08, 0x09, 0x00,
+    0x08, 0x18, 0x8b, 0x80, 0x8c, 0x02, 0x19, 0x1a,
+    0x11, 0x00, 0x00, 0x80, 0x9c, 0x80, 0x88, 0x02,
+    0x00, 0x00, 0x02, 0x20, 0x88, 0x0a, 0x00, 0x03,
+    0x01, 0x02, 0x05, 0x08, 0x00, 0x01, 0x09, 0x20,
+    0x21, 0x18, 0x22, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x28, 0x89, 0x80, 0x8b, 0x80, 0x90, 0x80, 0x92,
+    0x80, 0x8d, 0x05, 0x80, 0x8a, 0x80, 0x88, 0x80,
+};
+
+static const uint8_t unicode_prop_Emoji_Keycap_Sequence_table[4] = {
+    0xa2, 0x05, 0x04, 0x89,
 };
 
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
@@ -3856,14 +4147,15 @@ static const uint8_t unicode_prop_Bidi_Control_table[10] = {
     0xb6, 0x83,
 };
 
-static const uint8_t unicode_prop_Dash_table[55] = {
+static const uint8_t unicode_prop_Dash_table[58] = {
     0xac, 0x80, 0x45, 0x5b, 0x80, 0xb2, 0x80, 0x4e,
     0x40, 0x80, 0x44, 0x04, 0x80, 0x48, 0x08, 0x85,
     0xbc, 0x80, 0xa6, 0x80, 0x8e, 0x80, 0x41, 0x85,
     0x80, 0x4c, 0x03, 0x01, 0x80, 0x9e, 0x0b, 0x80,
     0x9b, 0x80, 0x41, 0xbd, 0x80, 0x92, 0x80, 0xee,
     0x80, 0x60, 0xcd, 0x8f, 0x81, 0xa4, 0x80, 0x89,
-    0x80, 0x40, 0xa8, 0x80, 0x4f, 0x9e, 0x80,
+    0x80, 0x40, 0xa8, 0x80, 0x4e, 0x5f, 0x80, 0x41,
+    0x3d, 0x80,
 };
 
 static const uint8_t unicode_prop_Deprecated_table[23] = {
@@ -3872,7 +4164,7 @@ static const uint8_t unicode_prop_Deprecated_table[23] = {
     0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
 };
 
-static const uint8_t unicode_prop_Diacritic_table[399] = {
+static const uint8_t unicode_prop_Diacritic_table[438] = {
     0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81,
     0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
     0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0,
@@ -3885,59 +4177,66 @@ static const uint8_t unicode_prop_Diacritic_table[399] = {
     0x8f, 0x80, 0xae, 0x82, 0xbb, 0x80, 0x8f, 0x06,
     0x80, 0xf6, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xed,
     0x80, 0x8f, 0x80, 0xec, 0x81, 0x8f, 0x80, 0xfb,
-    0x80, 0xfb, 0x28, 0x80, 0xea, 0x80, 0x8c, 0x84,
-    0xca, 0x81, 0x9a, 0x00, 0x00, 0x03, 0x81, 0xc1,
-    0x10, 0x81, 0xbd, 0x80, 0xef, 0x00, 0x81, 0xa7,
-    0x0b, 0x84, 0x98, 0x30, 0x80, 0x89, 0x81, 0x42,
-    0xc0, 0x82, 0x43, 0xb3, 0x81, 0x40, 0xb2, 0x8a,
-    0x88, 0x80, 0x41, 0x5a, 0x82, 0x41, 0x38, 0x39,
-    0x80, 0xaf, 0x8e, 0x81, 0x8a, 0xe7, 0x80, 0x8e,
-    0x80, 0xa5, 0x88, 0xb5, 0x81, 0x40, 0x89, 0x81,
-    0xbf, 0x85, 0xd1, 0x98, 0x18, 0x28, 0x0a, 0xb1,
-    0xbe, 0xd8, 0x8b, 0xa4, 0x8a, 0x41, 0xbc, 0x00,
-    0x82, 0x8a, 0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c,
-    0x81, 0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80, 0x41,
-    0xf9, 0x85, 0xe8, 0x83, 0xde, 0x80, 0x60, 0x75,
-    0x71, 0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1,
-    0x81, 0x8d, 0xa1, 0xe5, 0x82, 0xec, 0x81, 0x40,
-    0xc9, 0x80, 0x9a, 0x91, 0xb8, 0x83, 0xa3, 0x80,
-    0xde, 0x80, 0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94,
-    0x82, 0xc0, 0x83, 0xb2, 0x80, 0xe3, 0x84, 0x88,
-    0x82, 0xff, 0x81, 0x60, 0x4f, 0x2f, 0x80, 0x43,
-    0x00, 0x8f, 0x41, 0x0d, 0x00, 0x80, 0xae, 0x80,
-    0xac, 0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x44,
-    0x9e, 0x28, 0xa9, 0x80, 0x88, 0x43, 0x29, 0x81,
-    0x42, 0x3a, 0x85, 0x41, 0xd4, 0x82, 0xc5, 0x8a,
-    0xb0, 0x83, 0x40, 0xbf, 0x80, 0xa8, 0x80, 0xc7,
-    0x81, 0xf7, 0x81, 0xbd, 0x80, 0xcb, 0x80, 0x88,
-    0x82, 0xe7, 0x81, 0x40, 0xb1, 0x81, 0xd0, 0x80,
-    0x8f, 0x80, 0x97, 0x32, 0x84, 0x40, 0xcc, 0x02,
-    0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80,
-    0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41,
-    0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2, 0x80,
-    0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80, 0x41,
-    0x01, 0x00, 0x81, 0xd0, 0x80, 0x56, 0xae, 0x8e,
-    0x60, 0x36, 0x99, 0x84, 0xba, 0x86, 0x44, 0x57,
-    0x90, 0xcf, 0x81, 0x60, 0x3f, 0xfd, 0x18, 0x30,
-    0x81, 0x5f, 0x00, 0xad, 0x81, 0x96, 0x42, 0x1f,
-    0x12, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x4e, 0x81,
-    0xbd, 0x40, 0xc1, 0x86, 0x41, 0x76, 0x80, 0xbc,
-    0x83, 0x45, 0xdf, 0x86, 0xec, 0x10, 0x82,
+    0x80, 0xee, 0x80, 0x8b, 0x28, 0x80, 0xea, 0x80,
+    0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00, 0x03,
+    0x81, 0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef, 0x00,
+    0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80, 0x89,
+    0x81, 0x42, 0xc0, 0x82, 0x43, 0xb3, 0x81, 0x9d,
+    0x80, 0x40, 0x93, 0x8a, 0x88, 0x80, 0x41, 0x5a,
+    0x82, 0x41, 0x23, 0x80, 0x93, 0x39, 0x80, 0xaf,
+    0x8e, 0x81, 0x8a, 0xe7, 0x80, 0x8e, 0x80, 0xa5,
+    0x88, 0xb5, 0x81, 0xb9, 0x80, 0x8a, 0x81, 0xc1,
+    0x81, 0xbf, 0x85, 0xd1, 0x98, 0x18, 0x28, 0x0a,
+    0xb1, 0xbe, 0xd8, 0x8b, 0xa4, 0x8a, 0x41, 0xbc,
+    0x00, 0x82, 0x8a, 0x82, 0x8c, 0x82, 0x8c, 0x82,
+    0x8c, 0x81, 0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80,
+    0x41, 0xf9, 0x85, 0xe8, 0x83, 0xde, 0x80, 0x60,
+    0x75, 0x71, 0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81,
+    0xd1, 0x81, 0x8d, 0xa1, 0xe5, 0x82, 0xec, 0x81,
+    0x8b, 0x80, 0xa4, 0x80, 0x40, 0x96, 0x80, 0x9a,
+    0x91, 0xb8, 0x83, 0xa3, 0x80, 0xde, 0x80, 0x8b,
+    0x80, 0xa3, 0x80, 0x40, 0x94, 0x82, 0xc0, 0x83,
+    0xb2, 0x80, 0xe3, 0x84, 0x88, 0x82, 0xff, 0x81,
+    0x60, 0x4f, 0x2f, 0x80, 0x43, 0x00, 0x8f, 0x41,
+    0x0d, 0x00, 0x80, 0xae, 0x80, 0xac, 0x81, 0xc2,
+    0x80, 0x42, 0xfb, 0x80, 0x44, 0x9e, 0x28, 0xa9,
+    0x80, 0x88, 0x42, 0x7c, 0x13, 0x80, 0x40, 0xa4,
+    0x81, 0x42, 0x3a, 0x85, 0xa5, 0x80, 0x99, 0x84,
+    0x41, 0x8e, 0x82, 0xc5, 0x8a, 0xb0, 0x83, 0x40,
+    0xbf, 0x80, 0xa8, 0x80, 0xc7, 0x81, 0xf7, 0x81,
+    0xbd, 0x80, 0xcb, 0x80, 0x88, 0x82, 0xe7, 0x81,
+    0x40, 0xb1, 0x81, 0xcf, 0x81, 0x8f, 0x80, 0x97,
+    0x32, 0x84, 0xd8, 0x10, 0x81, 0x8c, 0x81, 0xde,
+    0x02, 0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd,
+    0x80, 0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81,
+    0x41, 0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2,
+    0x80, 0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80,
+    0x41, 0x01, 0x00, 0x81, 0xd0, 0x80, 0x41, 0xa8,
+    0x81, 0x96, 0x80, 0x54, 0xeb, 0x8e, 0x60, 0x2c,
+    0xd8, 0x80, 0x49, 0xbf, 0x84, 0xba, 0x86, 0x42,
+    0x33, 0x81, 0x42, 0x21, 0x90, 0xcf, 0x81, 0x60,
+    0x3f, 0xfd, 0x18, 0x30, 0x81, 0x5f, 0x00, 0xad,
+    0x81, 0x96, 0x42, 0x1f, 0x12, 0x2f, 0x39, 0x86,
+    0x9d, 0x83, 0x4e, 0x81, 0xbd, 0x40, 0xc1, 0x86,
+    0x41, 0x76, 0x80, 0xbc, 0x83, 0x42, 0xfd, 0x81,
+    0x42, 0xdf, 0x86, 0xec, 0x10, 0x82,
 };
 
-static const uint8_t unicode_prop_Extender_table[92] = {
+static const uint8_t unicode_prop_Extender_table[111] = {
     0x40, 0xb6, 0x80, 0x42, 0x17, 0x81, 0x43, 0x6d,
-    0x80, 0x41, 0xb8, 0x80, 0x43, 0x59, 0x80, 0x42,
-    0xef, 0x80, 0xfe, 0x80, 0x49, 0x42, 0x80, 0xb7,
-    0x80, 0x42, 0x62, 0x80, 0x41, 0x8d, 0x80, 0xc3,
-    0x80, 0x53, 0x88, 0x80, 0xaa, 0x84, 0xe6, 0x81,
-    0xdc, 0x82, 0x60, 0x6f, 0x15, 0x80, 0x45, 0xf5,
-    0x80, 0x43, 0xc1, 0x80, 0x95, 0x80, 0x40, 0x88,
-    0x80, 0xeb, 0x80, 0x94, 0x81, 0x60, 0x54, 0x7a,
-    0x80, 0x48, 0x0f, 0x81, 0x4b, 0xd9, 0x80, 0x42,
-    0x67, 0x82, 0x44, 0xce, 0x80, 0x60, 0x50, 0xa8,
+    0x80, 0x41, 0xb8, 0x80, 0x42, 0x75, 0x80, 0x40,
+    0x88, 0x80, 0xd8, 0x80, 0x42, 0xef, 0x80, 0xfe,
+    0x80, 0x49, 0x42, 0x80, 0xb7, 0x80, 0x42, 0x62,
+    0x80, 0x41, 0x8d, 0x80, 0xc3, 0x80, 0x53, 0x88,
+    0x80, 0xaa, 0x84, 0xe6, 0x81, 0xdc, 0x82, 0x60,
+    0x6f, 0x15, 0x80, 0x45, 0xf5, 0x80, 0x43, 0xc1,
+    0x80, 0x95, 0x80, 0x40, 0x88, 0x80, 0xeb, 0x80,
+    0x94, 0x81, 0x60, 0x54, 0x7a, 0x80, 0x48, 0x0f,
+    0x81, 0x45, 0xca, 0x80, 0x9a, 0x03, 0x80, 0x44,
+    0xc6, 0x80, 0x41, 0x24, 0x80, 0xf3, 0x81, 0x41,
+    0xf1, 0x82, 0x44, 0xce, 0x80, 0x60, 0x50, 0xa8,
     0x81, 0x44, 0x9b, 0x08, 0x80, 0x60, 0x71, 0x57,
-    0x81, 0x48, 0x05, 0x82,
+    0x81, 0x44, 0xb0, 0x80, 0x43, 0x53, 0x82,
 };
 
 static const uint8_t unicode_prop_Hex_Digit_table[12] = {
@@ -3945,24 +4244,28 @@ static const uint8_t unicode_prop_Hex_Digit_table[12] = {
     0x89, 0x35, 0x99, 0x85,
 };
 
-static const uint8_t unicode_prop_IDS_Binary_Operator_table[5] = {
-    0x60, 0x2f, 0xef, 0x09, 0x87,
+static const uint8_t unicode_prop_IDS_Unary_Operator_table[4] = {
+    0x60, 0x2f, 0xfd, 0x81,
+};
+
+static const uint8_t unicode_prop_IDS_Binary_Operator_table[8] = {
+    0x60, 0x2f, 0xef, 0x09, 0x89, 0x41, 0xf0, 0x80,
 };
 
 static const uint8_t unicode_prop_IDS_Trinary_Operator_table[4] = {
     0x60, 0x2f, 0xf1, 0x81,
 };
 
-static const uint8_t unicode_prop_Ideographic_table[69] = {
+static const uint8_t unicode_prop_Ideographic_table[72] = {
     0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82,
     0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xff,
     0x60, 0x58, 0xff, 0x41, 0x6d, 0x81, 0xe9, 0x60,
     0x75, 0x09, 0x80, 0x9a, 0x57, 0xf7, 0x87, 0x44,
-    0xd5, 0xa9, 0x88, 0x60, 0x24, 0x66, 0x41, 0x8b,
+    0xd5, 0xa8, 0x89, 0x60, 0x24, 0x66, 0x41, 0x8b,
     0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdf, 0x9f, 0x50,
     0x39, 0x85, 0x40, 0xdd, 0x81, 0x56, 0x81, 0x8d,
-    0x5d, 0x30, 0x4c, 0x1e, 0x42, 0x1d, 0x45, 0xe1,
-    0x53, 0x4a, 0x84, 0x50, 0x5f,
+    0x5d, 0x30, 0x8e, 0x42, 0x6d, 0x49, 0xa1, 0x42,
+    0x1d, 0x45, 0xe1, 0x53, 0x4a, 0x84, 0x50, 0x5f,
 };
 
 static const uint8_t unicode_prop_Join_Control_table[4] = {
@@ -3974,6 +4277,11 @@ static const uint8_t unicode_prop_Logical_Order_Exception_table[15] = {
     0x80, 0x60, 0x90, 0xf9, 0x09, 0x00, 0x81,
 };
 
+static const uint8_t unicode_prop_Modifier_Combining_Mark_table[16] = {
+    0x46, 0x53, 0x09, 0x80, 0x40, 0x82, 0x05, 0x02,
+    0x81, 0x41, 0xe0, 0x08, 0x12, 0x80, 0x9e, 0x80,
+};
+
 static const uint8_t unicode_prop_Noncharacter_Code_Point_table[71] = {
     0x60, 0xfd, 0xcf, 0x9f, 0x42, 0x0d, 0x81, 0x60,
     0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60,
@@ -4018,32 +4326,34 @@ static const uint8_t unicode_prop_Regional_Indicator_table[4] = {
     0x61, 0xf1, 0xe5, 0x99,
 };
 
-static const uint8_t unicode_prop_Sentence_Terminal_table[196] = {
+static const uint8_t unicode_prop_Sentence_Terminal_table[213] = {
     0xa0, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0x45, 0x48,
     0x80, 0x40, 0x92, 0x82, 0x40, 0xb3, 0x80, 0xaa,
     0x82, 0x40, 0xf5, 0x80, 0xbc, 0x00, 0x02, 0x81,
     0x41, 0x24, 0x81, 0x46, 0xe3, 0x81, 0x43, 0x15,
     0x03, 0x81, 0x43, 0x04, 0x80, 0x40, 0xc5, 0x81,
-    0x40, 0xcb, 0x04, 0x80, 0x41, 0x39, 0x81, 0x41,
-    0x61, 0x83, 0x40, 0xad, 0x09, 0x81, 0x9c, 0x81,
-    0x40, 0xbb, 0x81, 0xc0, 0x81, 0x43, 0xbb, 0x81,
-    0x88, 0x82, 0x4d, 0xe3, 0x80, 0x8c, 0x80, 0x95,
-    0x81, 0x41, 0xac, 0x80, 0x60, 0x74, 0xfb, 0x80,
-    0x41, 0x0d, 0x81, 0x40, 0xe2, 0x02, 0x80, 0x41,
-    0x7d, 0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x97,
-    0x81, 0x40, 0x92, 0x82, 0x40, 0x8f, 0x81, 0x40,
-    0xf8, 0x80, 0x60, 0x52, 0x65, 0x02, 0x81, 0x40,
-    0xa8, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0xc0, 0x80,
-    0x4a, 0xf3, 0x81, 0x44, 0xfc, 0x84, 0xab, 0x83,
-    0x40, 0xbc, 0x81, 0xf4, 0x83, 0xfe, 0x82, 0x40,
-    0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x08, 0x81,
-    0xeb, 0x80, 0x41, 0xa0, 0x81, 0x41, 0x74, 0x0c,
-    0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42, 0x04,
-    0x00, 0x80, 0x40, 0xfa, 0x81, 0xd6, 0x81, 0x41,
-    0xa3, 0x81, 0x42, 0xb3, 0x81, 0xc9, 0x81, 0x60,
-    0x4b, 0x28, 0x81, 0x40, 0x84, 0x80, 0xc0, 0x81,
-    0x8a, 0x80, 0x43, 0x52, 0x80, 0x60, 0x4e, 0x05,
-    0x80, 0x5d, 0xe7, 0x80,
+    0x40, 0x9c, 0x81, 0xac, 0x04, 0x80, 0x41, 0x39,
+    0x81, 0x41, 0x61, 0x83, 0x40, 0xa1, 0x81, 0x89,
+    0x09, 0x81, 0x9c, 0x82, 0x40, 0xba, 0x81, 0xc0,
+    0x81, 0x43, 0xa3, 0x80, 0x96, 0x81, 0x88, 0x82,
+    0x4c, 0xae, 0x82, 0x41, 0x31, 0x80, 0x8c, 0x80,
+    0x95, 0x81, 0x41, 0xac, 0x80, 0x60, 0x74, 0xfb,
+    0x80, 0x41, 0x0d, 0x81, 0x40, 0xe2, 0x02, 0x80,
+    0x41, 0x7d, 0x81, 0xd5, 0x81, 0xde, 0x80, 0x40,
+    0x97, 0x81, 0x40, 0x92, 0x82, 0x40, 0x8f, 0x81,
+    0x40, 0xf8, 0x80, 0x60, 0x52, 0x25, 0x01, 0x81,
+    0xba, 0x02, 0x81, 0x40, 0xa8, 0x80, 0x8b, 0x80,
+    0x8f, 0x80, 0xc0, 0x80, 0x4a, 0xf3, 0x81, 0x44,
+    0xfc, 0x84, 0xab, 0x83, 0x40, 0xbc, 0x81, 0xf4,
+    0x83, 0xfe, 0x82, 0x40, 0x80, 0x0d, 0x80, 0x8f,
+    0x81, 0xd7, 0x08, 0x81, 0xeb, 0x80, 0x41, 0x29,
+    0x81, 0xf4, 0x81, 0x41, 0x74, 0x0c, 0x8e, 0xe8,
+    0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80,
+    0x40, 0xfa, 0x81, 0xd6, 0x81, 0x41, 0xa3, 0x81,
+    0x42, 0xb3, 0x81, 0xc9, 0x81, 0x60, 0x4b, 0x28,
+    0x81, 0x40, 0x84, 0x80, 0xc0, 0x81, 0x8a, 0x80,
+    0x42, 0x28, 0x81, 0x41, 0x27, 0x80, 0x60, 0x4e,
+    0x05, 0x80, 0x5d, 0xe7, 0x80,
 };
 
 static const uint8_t unicode_prop_Soft_Dotted_table[79] = {
@@ -4059,47 +4369,49 @@ static const uint8_t unicode_prop_Soft_Dotted_table[79] = {
     0x85, 0x80, 0x41, 0x30, 0x81, 0x99, 0x80,
 };
 
-static const uint8_t unicode_prop_Terminal_Punctuation_table[248] = {
+static const uint8_t unicode_prop_Terminal_Punctuation_table[264] = {
     0xa0, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
     0x43, 0x3d, 0x07, 0x80, 0x42, 0x00, 0x80, 0xb8,
     0x80, 0xc7, 0x80, 0x8d, 0x00, 0x82, 0x40, 0xb3,
     0x80, 0xaa, 0x8a, 0x00, 0x40, 0xea, 0x81, 0xb5,
-    0x8e, 0x9e, 0x80, 0x41, 0x04, 0x81, 0x44, 0xf3,
-    0x81, 0x40, 0xab, 0x03, 0x85, 0x41, 0x36, 0x81,
-    0x43, 0x14, 0x87, 0x43, 0x04, 0x80, 0xfb, 0x82,
-    0xc6, 0x81, 0x40, 0x9c, 0x12, 0x80, 0xa6, 0x19,
-    0x81, 0x41, 0x39, 0x81, 0x41, 0x61, 0x83, 0x40,
-    0xad, 0x08, 0x82, 0x9c, 0x81, 0x40, 0xbb, 0x84,
-    0xbd, 0x81, 0x43, 0xbb, 0x81, 0x88, 0x82, 0x4d,
-    0xe3, 0x80, 0x8c, 0x03, 0x80, 0x89, 0x00, 0x0a,
+    0x28, 0x87, 0x9e, 0x80, 0x41, 0x04, 0x81, 0x44,
+    0xf3, 0x81, 0x40, 0xab, 0x03, 0x85, 0x41, 0x36,
+    0x81, 0x43, 0x14, 0x87, 0x43, 0x04, 0x80, 0xfb,
+    0x82, 0xc6, 0x81, 0x40, 0x9c, 0x12, 0x80, 0xa6,
+    0x19, 0x81, 0x41, 0x39, 0x81, 0x41, 0x61, 0x83,
+    0x40, 0xa1, 0x81, 0x89, 0x08, 0x82, 0x9c, 0x82,
+    0x40, 0xba, 0x84, 0xbd, 0x81, 0x43, 0xa3, 0x80,
+    0x96, 0x81, 0x88, 0x82, 0x4c, 0xae, 0x82, 0x41,
+    0x31, 0x80, 0x8c, 0x03, 0x80, 0x89, 0x00, 0x0a,
     0x81, 0x41, 0xab, 0x81, 0x60, 0x74, 0xfa, 0x81,
     0x41, 0x0c, 0x82, 0x40, 0xe2, 0x84, 0x41, 0x7d,
     0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x96, 0x82,
     0x40, 0x92, 0x82, 0xfe, 0x80, 0x8f, 0x81, 0x40,
-    0xf8, 0x80, 0x60, 0x52, 0x63, 0x10, 0x83, 0x40,
-    0xa8, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80,
-    0xc0, 0x01, 0x80, 0x44, 0x39, 0x80, 0xaf, 0x80,
-    0x44, 0x85, 0x80, 0x40, 0xc6, 0x80, 0x41, 0x35,
-    0x81, 0x40, 0x97, 0x85, 0xc3, 0x85, 0xd8, 0x83,
-    0x43, 0xb7, 0x84, 0xab, 0x83, 0x40, 0xbc, 0x86,
-    0xef, 0x83, 0xfe, 0x82, 0x40, 0x80, 0x0d, 0x80,
-    0x8f, 0x81, 0xd7, 0x84, 0xeb, 0x80, 0x41, 0xa0,
-    0x82, 0x8b, 0x81, 0x41, 0x65, 0x1a, 0x8e, 0xe8,
-    0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80,
-    0x40, 0xfa, 0x81, 0xd6, 0x0b, 0x81, 0x41, 0x9d,
-    0x82, 0xac, 0x80, 0x42, 0x84, 0x81, 0xc9, 0x81,
-    0x45, 0x2a, 0x84, 0x60, 0x45, 0xf8, 0x81, 0x40,
-    0x84, 0x80, 0xc0, 0x82, 0x89, 0x80, 0x43, 0x51,
+    0xf8, 0x80, 0x60, 0x52, 0x25, 0x01, 0x81, 0xb8,
+    0x10, 0x83, 0x40, 0xa8, 0x80, 0x89, 0x00, 0x80,
+    0x8a, 0x0a, 0x80, 0xc0, 0x01, 0x80, 0x44, 0x39,
+    0x80, 0xaf, 0x80, 0x44, 0x85, 0x80, 0x40, 0xc6,
+    0x80, 0x41, 0x35, 0x81, 0x40, 0x97, 0x85, 0xc3,
+    0x85, 0xd8, 0x83, 0x43, 0xb7, 0x84, 0xab, 0x83,
+    0x40, 0xbc, 0x86, 0xef, 0x83, 0xfe, 0x82, 0x40,
+    0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x84, 0xeb,
+    0x80, 0x41, 0x29, 0x81, 0xf4, 0x82, 0x8b, 0x81,
+    0x41, 0x65, 0x1a, 0x8e, 0xe8, 0x81, 0x40, 0xf8,
+    0x82, 0x42, 0x04, 0x00, 0x80, 0x40, 0xfa, 0x81,
+    0xd6, 0x0b, 0x81, 0x41, 0x9d, 0x82, 0xac, 0x80,
+    0x42, 0x84, 0x81, 0xc9, 0x81, 0x45, 0x2a, 0x84,
+    0x60, 0x45, 0xf8, 0x81, 0x40, 0x84, 0x80, 0xc0,
+    0x82, 0x89, 0x80, 0x42, 0x28, 0x81, 0x41, 0x26,
     0x81, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe6, 0x83,
 };
 
-static const uint8_t unicode_prop_Unified_Ideograph_table[45] = {
+static const uint8_t unicode_prop_Unified_Ideograph_table[48] = {
     0x60, 0x33, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x51,
     0xff, 0x60, 0x5a, 0x0d, 0x08, 0x00, 0x81, 0x89,
     0x00, 0x00, 0x09, 0x82, 0x61, 0x05, 0xd5, 0x60,
     0xa6, 0xdf, 0x9f, 0x50, 0x39, 0x85, 0x40, 0xdd,
-    0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x54, 0x1e,
-    0x53, 0x4a, 0x84, 0x50, 0x5f,
+    0x81, 0x56, 0x81, 0x8d, 0x5d, 0x30, 0x8e, 0x42,
+    0x6d, 0x51, 0xa1, 0x53, 0x4a, 0x84, 0x50, 0x5f,
 };
 
 static const uint8_t unicode_prop_Variation_Selector_table[13] = {
@@ -4120,7 +4432,7 @@ static const uint8_t unicode_prop_Bidi_Mirrored_table[173] = {
     0x89, 0x81, 0xb5, 0x81, 0x8d, 0x81, 0x40, 0xb0,
     0x80, 0x40, 0xbf, 0x1a, 0x2a, 0x02, 0x0a, 0x18,
     0x18, 0x00, 0x03, 0x88, 0x20, 0x80, 0x91, 0x23,
-    0x88, 0x08, 0x00, 0x39, 0x9e, 0x0b, 0x20, 0x88,
+    0x88, 0x08, 0x00, 0x38, 0x9f, 0x0b, 0x20, 0x88,
     0x09, 0x92, 0x21, 0x88, 0x21, 0x0b, 0x97, 0x81,
     0x8f, 0x3b, 0x93, 0x0e, 0x81, 0x44, 0x3c, 0x8d,
     0xc9, 0x01, 0x18, 0x08, 0x14, 0x1c, 0x12, 0x8d,
@@ -4138,7 +4450,7 @@ static const uint8_t unicode_prop_Bidi_Mirrored_table[173] = {
     0x80, 0xb8, 0x80, 0xb8, 0x80,
 };
 
-static const uint8_t unicode_prop_Emoji_table[239] = {
+static const uint8_t unicode_prop_Emoji_table[238] = {
     0xa2, 0x05, 0x04, 0x89, 0xee, 0x03, 0x80, 0x5f,
     0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95,
     0x80, 0xd9, 0x85, 0x8e, 0x81, 0x41, 0x6e, 0x81,
@@ -4167,8 +4479,8 @@ static const uint8_t unicode_prop_Emoji_table[239] = {
     0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0a, 0x83,
     0x89, 0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2,
     0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89, 0x80,
-    0x40, 0xb8, 0xef, 0x8c, 0x82, 0x88, 0x86, 0xad,
-    0x06, 0x87, 0x8d, 0x83, 0x88, 0x86, 0x88,
+    0x40, 0xb8, 0xef, 0x8c, 0x82, 0x89, 0x84, 0xb7,
+    0x86, 0x8e, 0x81, 0x8a, 0x85, 0x88,
 };
 
 static const uint8_t unicode_prop_Emoji_Component_table[28] = {
@@ -4194,7 +4506,7 @@ static const uint8_t unicode_prop_Emoji_Modifier_Base_table[71] = {
     0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x88,
 };
 
-static const uint8_t unicode_prop_Emoji_Presentation_table[145] = {
+static const uint8_t unicode_prop_Emoji_Presentation_table[144] = {
     0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
     0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
     0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
@@ -4211,9 +4523,8 @@ static const uint8_t unicode_prop_Emoji_Presentation_table[145] = {
     0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
     0xc5, 0x28, 0x12, 0x0a, 0x1b, 0x8a, 0x0e, 0x88,
     0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80,
-    0x89, 0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x88,
-    0x86, 0xad, 0x06, 0x87, 0x8d, 0x83, 0x88, 0x86,
-    0x88,
+    0x89, 0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x89,
+    0x84, 0xb7, 0x86, 0x8e, 0x81, 0x8a, 0x85, 0x88,
 };
 
 static const uint8_t unicode_prop_Extended_Pictographic_table[156] = {
@@ -4266,6 +4577,11 @@ typedef enum {
     UNICODE_PROP_Changes_When_Titlecased1,
     UNICODE_PROP_Changes_When_Casefolded1,
     UNICODE_PROP_Changes_When_NFKC_Casefolded1,
+    UNICODE_PROP_Basic_Emoji1,
+    UNICODE_PROP_Basic_Emoji2,
+    UNICODE_PROP_RGI_Emoji_Modifier_Sequence,
+    UNICODE_PROP_RGI_Emoji_Flag_Sequence,
+    UNICODE_PROP_Emoji_Keycap_Sequence,
     UNICODE_PROP_ASCII_Hex_Digit,
     UNICODE_PROP_Bidi_Control,
     UNICODE_PROP_Dash,
@@ -4273,11 +4589,13 @@ typedef enum {
     UNICODE_PROP_Diacritic,
     UNICODE_PROP_Extender,
     UNICODE_PROP_Hex_Digit,
+    UNICODE_PROP_IDS_Unary_Operator,
     UNICODE_PROP_IDS_Binary_Operator,
     UNICODE_PROP_IDS_Trinary_Operator,
     UNICODE_PROP_Ideographic,
     UNICODE_PROP_Join_Control,
     UNICODE_PROP_Logical_Order_Exception,
+    UNICODE_PROP_Modifier_Combining_Mark,
     UNICODE_PROP_Noncharacter_Code_Point,
     UNICODE_PROP_Pattern_Syntax,
     UNICODE_PROP_Pattern_White_Space,
@@ -4314,6 +4632,9 @@ typedef enum {
     UNICODE_PROP_Grapheme_Base,
     UNICODE_PROP_Grapheme_Extend,
     UNICODE_PROP_ID_Continue,
+    UNICODE_PROP_ID_Compat_Math_Start,
+    UNICODE_PROP_ID_Compat_Math_Continue,
+    UNICODE_PROP_InCB,
     UNICODE_PROP_Lowercase,
     UNICODE_PROP_Math,
     UNICODE_PROP_Uppercase,
@@ -4331,11 +4652,13 @@ static const char unicode_prop_name_table[] =
     "Diacritic,Dia"                      "\0"
     "Extender,Ext"                       "\0"
     "Hex_Digit,Hex"                      "\0"
+    "IDS_Unary_Operator,IDSU"            "\0"
     "IDS_Binary_Operator,IDSB"           "\0"
     "IDS_Trinary_Operator,IDST"          "\0"
     "Ideographic,Ideo"                   "\0"
     "Join_Control,Join_C"                "\0"
     "Logical_Order_Exception,LOE"        "\0"
+    "Modifier_Combining_Mark,MCM"        "\0"
     "Noncharacter_Code_Point,NChar"      "\0"
     "Pattern_Syntax,Pat_Syn"             "\0"
     "Pattern_White_Space,Pat_WS"         "\0"
@@ -4372,6 +4695,9 @@ static const char unicode_prop_name_table[] =
     "Grapheme_Base,Gr_Base"              "\0"
     "Grapheme_Extend,Gr_Ext"             "\0"
     "ID_Continue,IDC"                    "\0"
+    "ID_Compat_Math_Start"               "\0"
+    "ID_Compat_Math_Continue"            "\0"
+    "InCB"                               "\0"
     "Lowercase,Lower"                    "\0"
     "Math"                               "\0"
     "Uppercase,Upper"                    "\0"
@@ -4396,6 +4722,11 @@ static const uint8_t * const unicode_prop_table[] = {
     unicode_prop_Changes_When_Titlecased1_table,
     unicode_prop_Changes_When_Casefolded1_table,
     unicode_prop_Changes_When_NFKC_Casefolded1_table,
+    unicode_prop_Basic_Emoji1_table,
+    unicode_prop_Basic_Emoji2_table,
+    unicode_prop_RGI_Emoji_Modifier_Sequence_table,
+    unicode_prop_RGI_Emoji_Flag_Sequence_table,
+    unicode_prop_Emoji_Keycap_Sequence_table,
     unicode_prop_ASCII_Hex_Digit_table,
     unicode_prop_Bidi_Control_table,
     unicode_prop_Dash_table,
@@ -4403,11 +4734,13 @@ static const uint8_t * const unicode_prop_table[] = {
     unicode_prop_Diacritic_table,
     unicode_prop_Extender_table,
     unicode_prop_Hex_Digit_table,
+    unicode_prop_IDS_Unary_Operator_table,
     unicode_prop_IDS_Binary_Operator_table,
     unicode_prop_IDS_Trinary_Operator_table,
     unicode_prop_Ideographic_table,
     unicode_prop_Join_Control_table,
     unicode_prop_Logical_Order_Exception_table,
+    unicode_prop_Modifier_Combining_Mark_table,
     unicode_prop_Noncharacter_Code_Point_table,
     unicode_prop_Pattern_Syntax_table,
     unicode_prop_Pattern_White_Space_table,
@@ -4449,6 +4782,11 @@ static const uint16_t unicode_prop_len_table[] = {
     countof(unicode_prop_Changes_When_Titlecased1_table),
     countof(unicode_prop_Changes_When_Casefolded1_table),
     countof(unicode_prop_Changes_When_NFKC_Casefolded1_table),
+    countof(unicode_prop_Basic_Emoji1_table),
+    countof(unicode_prop_Basic_Emoji2_table),
+    countof(unicode_prop_RGI_Emoji_Modifier_Sequence_table),
+    countof(unicode_prop_RGI_Emoji_Flag_Sequence_table),
+    countof(unicode_prop_Emoji_Keycap_Sequence_table),
     countof(unicode_prop_ASCII_Hex_Digit_table),
     countof(unicode_prop_Bidi_Control_table),
     countof(unicode_prop_Dash_table),
@@ -4456,11 +4794,13 @@ static const uint16_t unicode_prop_len_table[] = {
     countof(unicode_prop_Diacritic_table),
     countof(unicode_prop_Extender_table),
     countof(unicode_prop_Hex_Digit_table),
+    countof(unicode_prop_IDS_Unary_Operator_table),
     countof(unicode_prop_IDS_Binary_Operator_table),
     countof(unicode_prop_IDS_Trinary_Operator_table),
     countof(unicode_prop_Ideographic_table),
     countof(unicode_prop_Join_Control_table),
     countof(unicode_prop_Logical_Order_Exception_table),
+    countof(unicode_prop_Modifier_Combining_Mark_table),
     countof(unicode_prop_Noncharacter_Code_Point_table),
     countof(unicode_prop_Pattern_Syntax_table),
     countof(unicode_prop_Pattern_White_Space_table),
@@ -4485,4 +4825,325 @@ static const uint16_t unicode_prop_len_table[] = {
     countof(unicode_prop_Case_Ignorable_table),
 };
 
+typedef enum {
+    UNICODE_SEQUENCE_PROP_Basic_Emoji,
+    UNICODE_SEQUENCE_PROP_Emoji_Keycap_Sequence,
+    UNICODE_SEQUENCE_PROP_RGI_Emoji_Modifier_Sequence,
+    UNICODE_SEQUENCE_PROP_RGI_Emoji_Flag_Sequence,
+    UNICODE_SEQUENCE_PROP_RGI_Emoji_Tag_Sequence,
+    UNICODE_SEQUENCE_PROP_RGI_Emoji_ZWJ_Sequence,
+    UNICODE_SEQUENCE_PROP_RGI_Emoji,
+    UNICODE_SEQUENCE_PROP_COUNT,
+} UnicodeSequencePropertyEnum;
+
+static const char unicode_sequence_prop_name_table[] =
+    "Basic_Emoji"                 "\0"
+    "Emoji_Keycap_Sequence"       "\0"
+    "RGI_Emoji_Modifier_Sequence" "\0"
+    "RGI_Emoji_Flag_Sequence"     "\0"
+    "RGI_Emoji_Tag_Sequence"      "\0"
+    "RGI_Emoji_ZWJ_Sequence"      "\0"
+    "RGI_Emoji"                   "\0"
+;
+
+static const uint8_t unicode_rgi_emoji_tag_sequence[18] = {
+    0x67, 0x62, 0x65, 0x6e, 0x67, 0x00, 0x67, 0x62,
+    0x73, 0x63, 0x74, 0x00, 0x67, 0x62, 0x77, 0x6c,
+    0x73, 0x00,
+};
+
+static const uint8_t unicode_rgi_emoji_zwj_sequence[2320] = {
+    0x02, 0xb8, 0x19, 0x40, 0x86, 0x02, 0xd1, 0x39,
+    0xb0, 0x19, 0x02, 0x26, 0x39, 0x42, 0x86, 0x02,
+    0xb4, 0x36, 0x42, 0x86, 0x03, 0x68, 0x54, 0x64,
+    0x87, 0x68, 0x54, 0x02, 0xdc, 0x39, 0x42, 0x86,
+    0x02, 0xd1, 0x39, 0x73, 0x13, 0x02, 0x39, 0x39,
+    0x40, 0x86, 0x02, 0x69, 0x34, 0xbd, 0x19, 0x03,
+    0xb6, 0x36, 0x40, 0x86, 0xa1, 0x87, 0x03, 0x68,
+    0x74, 0x1d, 0x19, 0x68, 0x74, 0x03, 0x68, 0x34,
+    0xbd, 0x19, 0xa1, 0x87, 0x02, 0xf1, 0x7a, 0xf2,
+    0x7a, 0x02, 0xca, 0x33, 0x42, 0x86, 0x02, 0x69,
+    0x34, 0xb0, 0x19, 0x04, 0x68, 0x14, 0x68, 0x14,
+    0x67, 0x14, 0x66, 0x14, 0x02, 0xf9, 0x26, 0x42,
+    0x86, 0x03, 0x69, 0x74, 0x1d, 0x19, 0x69, 0x74,
+    0x03, 0xd1, 0x19, 0xbc, 0x19, 0xa1, 0x87, 0x02,
+    0x3c, 0x19, 0x40, 0x86, 0x02, 0x68, 0x34, 0xeb,
+    0x13, 0x02, 0xc3, 0x33, 0xa1, 0x87, 0x02, 0x70,
+    0x34, 0x40, 0x86, 0x02, 0xd4, 0x39, 0x42, 0x86,
+    0x02, 0xcf, 0x39, 0x42, 0x86, 0x02, 0x47, 0x36,
+    0x40, 0x86, 0x02, 0x39, 0x39, 0x42, 0x86, 0x04,
+    0xd1, 0x79, 0x64, 0x87, 0x8b, 0x14, 0xd1, 0x79,
+    0x02, 0xd1, 0x39, 0x95, 0x86, 0x02, 0x68, 0x34,
+    0x93, 0x13, 0x02, 0x69, 0x34, 0xed, 0x13, 0x02,
+    0xda, 0x39, 0x40, 0x86, 0x03, 0x69, 0x34, 0xaf,
+    0x19, 0xa1, 0x87, 0x02, 0xd1, 0x39, 0x93, 0x13,
+    0x03, 0xce, 0x39, 0x42, 0x86, 0xa1, 0x87, 0x03,
+    0xd1, 0x79, 0x64, 0x87, 0xd1, 0x79, 0x03, 0xc3,
+    0x33, 0x42, 0x86, 0xa1, 0x87, 0x03, 0x69, 0x74,
+    0x1d, 0x19, 0x68, 0x74, 0x02, 0x69, 0x34, 0x92,
+    0x16, 0x02, 0xd1, 0x39, 0x96, 0x86, 0x04, 0x69,
+    0x14, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x14, 0x02,
+    0x68, 0x34, 0x7c, 0x13, 0x02, 0x47, 0x36, 0x42,
+    0x86, 0x02, 0x86, 0x34, 0x42, 0x86, 0x02, 0xd1,
+    0x39, 0x7c, 0x13, 0x02, 0x69, 0x14, 0xa4, 0x13,
+    0x02, 0xda, 0x39, 0x42, 0x86, 0x02, 0x37, 0x39,
+    0x40, 0x86, 0x02, 0xd1, 0x39, 0x08, 0x87, 0x04,
+    0x68, 0x54, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x54,
+    0x02, 0x4d, 0x36, 0x40, 0x86, 0x02, 0x68, 0x34,
+    0x2c, 0x15, 0x02, 0x69, 0x34, 0xaf, 0x19, 0x02,
+    0x6e, 0x34, 0x40, 0x86, 0x02, 0xcd, 0x39, 0x42,
+    0x86, 0x02, 0xd1, 0x39, 0x2c, 0x15, 0x02, 0x6f,
+    0x14, 0x40, 0x86, 0x03, 0xd1, 0x39, 0xbc, 0x19,
+    0xa1, 0x87, 0x02, 0x68, 0x34, 0xa8, 0x13, 0x02,
+    0x69, 0x34, 0x73, 0x13, 0x04, 0x69, 0x54, 0x64,
+    0x87, 0x8b, 0x14, 0x68, 0x54, 0x02, 0x71, 0x34,
+    0x42, 0x86, 0x02, 0xd1, 0x39, 0xa8, 0x13, 0x02,
+    0x45, 0x36, 0x40, 0x86, 0x03, 0x69, 0x54, 0x64,
+    0x87, 0x68, 0x54, 0x03, 0x69, 0x54, 0x64, 0x87,
+    0x69, 0x54, 0x03, 0xce, 0x39, 0x40, 0x86, 0xa1,
+    0x87, 0x02, 0xd8, 0x39, 0x40, 0x86, 0x03, 0xc3,
+    0x33, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x4d, 0x36,
+    0x42, 0x86, 0x02, 0xd1, 0x19, 0x92, 0x16, 0x02,
+    0xd1, 0x39, 0xeb, 0x13, 0x02, 0x68, 0x34, 0xbc,
+    0x14, 0x02, 0xd1, 0x39, 0xbc, 0x14, 0x02, 0x3d,
+    0x39, 0x40, 0x86, 0x02, 0xb8, 0x39, 0x42, 0x86,
+    0x02, 0xa3, 0x36, 0x40, 0x86, 0x02, 0x75, 0x35,
+    0x40, 0x86, 0x02, 0xd8, 0x39, 0x42, 0x86, 0x02,
+    0x69, 0x34, 0x93, 0x13, 0x02, 0x35, 0x39, 0x40,
+    0x86, 0x02, 0x4b, 0x36, 0x40, 0x86, 0x02, 0x3d,
+    0x39, 0x42, 0x86, 0x02, 0x38, 0x39, 0x42, 0x86,
+    0x02, 0xa3, 0x36, 0x42, 0x86, 0x03, 0x69, 0x14,
+    0x67, 0x14, 0x67, 0x14, 0x02, 0xb6, 0x36, 0x40,
+    0x86, 0x02, 0x69, 0x34, 0x7c, 0x13, 0x02, 0x75,
+    0x35, 0x42, 0x86, 0x02, 0xcc, 0x93, 0x40, 0x86,
+    0x02, 0xcc, 0x33, 0x40, 0x86, 0x03, 0xd1, 0x39,
+    0xbd, 0x19, 0xa1, 0x87, 0x02, 0x82, 0x34, 0x40,
+    0x86, 0x02, 0x87, 0x34, 0x40, 0x86, 0x02, 0x69,
+    0x14, 0x3e, 0x13, 0x02, 0xd6, 0x39, 0x40, 0x86,
+    0x02, 0x68, 0x14, 0xbd, 0x19, 0x02, 0x46, 0x36,
+    0x42, 0x86, 0x02, 0x4b, 0x36, 0x42, 0x86, 0x02,
+    0x69, 0x34, 0x2c, 0x15, 0x03, 0xb6, 0x36, 0x42,
+    0x86, 0xa1, 0x87, 0x02, 0xc4, 0x33, 0x40, 0x86,
+    0x02, 0x26, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14,
+    0xb0, 0x19, 0x02, 0xde, 0x19, 0x42, 0x86, 0x02,
+    0x69, 0x34, 0xa8, 0x13, 0x02, 0xcc, 0x33, 0x42,
+    0x86, 0x02, 0x82, 0x34, 0x42, 0x86, 0x02, 0xd1,
+    0x19, 0x93, 0x13, 0x02, 0x81, 0x14, 0x42, 0x86,
+    0x02, 0x69, 0x34, 0x95, 0x86, 0x02, 0x68, 0x34,
+    0xbb, 0x14, 0x02, 0xd1, 0x39, 0xbb, 0x14, 0x02,
+    0x69, 0x34, 0xeb, 0x13, 0x02, 0xd1, 0x39, 0x84,
+    0x13, 0x02, 0x69, 0x34, 0xbc, 0x14, 0x04, 0x69,
+    0x54, 0x64, 0x87, 0x8b, 0x14, 0x69, 0x54, 0x02,
+    0x26, 0x39, 0x40, 0x86, 0x02, 0xb4, 0x36, 0x40,
+    0x86, 0x02, 0x47, 0x16, 0x42, 0x86, 0x02, 0xdc,
+    0x39, 0x40, 0x86, 0x02, 0xca, 0x33, 0x40, 0x86,
+    0x02, 0xf9, 0x26, 0x40, 0x86, 0x02, 0x69, 0x34,
+    0x08, 0x87, 0x03, 0x69, 0x14, 0x69, 0x14, 0x66,
+    0x14, 0x03, 0xd1, 0x59, 0x1d, 0x19, 0xd1, 0x59,
+    0x02, 0xd4, 0x39, 0x40, 0x86, 0x02, 0xcf, 0x39,
+    0x40, 0x86, 0x02, 0x68, 0x34, 0xa4, 0x13, 0x02,
+    0xd1, 0x39, 0xa4, 0x13, 0x02, 0xd1, 0x19, 0xa8,
+    0x13, 0x02, 0xd7, 0x39, 0x42, 0x86, 0x03, 0x69,
+    0x34, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x14,
+    0xb0, 0x19, 0x02, 0x68, 0x14, 0x73, 0x13, 0x04,
+    0x69, 0x14, 0x69, 0x14, 0x66, 0x14, 0x66, 0x14,
+    0x03, 0x68, 0x34, 0xaf, 0x19, 0xa1, 0x87, 0x02,
+    0x68, 0x34, 0x80, 0x16, 0x02, 0x73, 0x34, 0x42,
+    0x86, 0x02, 0xd1, 0x39, 0x80, 0x16, 0x02, 0x68,
+    0x34, 0xb0, 0x19, 0x02, 0x86, 0x34, 0x40, 0x86,
+    0x02, 0x38, 0x19, 0x42, 0x86, 0x02, 0x69, 0x34,
+    0xbb, 0x14, 0x02, 0xb5, 0x36, 0x42, 0x86, 0x02,
+    0xcd, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34, 0x95,
+    0x86, 0x02, 0x68, 0x34, 0x27, 0x15, 0x03, 0x68,
+    0x14, 0x68, 0x14, 0x66, 0x14, 0x02, 0x71, 0x34,
+    0x40, 0x86, 0x02, 0xd1, 0x39, 0x27, 0x15, 0x02,
+    0x2e, 0x16, 0xa8, 0x14, 0x02, 0xc3, 0x33, 0x42,
+    0x86, 0x02, 0x69, 0x14, 0x66, 0x14, 0x02, 0x68,
+    0x34, 0x96, 0x86, 0x02, 0x69, 0x34, 0xa4, 0x13,
+    0x03, 0x69, 0x14, 0x64, 0x87, 0x68, 0x14, 0x02,
+    0xb8, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34, 0x3e,
+    0x13, 0x03, 0xd1, 0x19, 0xaf, 0x19, 0xa1, 0x87,
+    0x02, 0xd1, 0x39, 0x3e, 0x13, 0x02, 0x68, 0x34,
+    0xbd, 0x19, 0x02, 0xd1, 0x19, 0xbb, 0x14, 0x02,
+    0xd1, 0x19, 0x95, 0x86, 0x02, 0xdb, 0x39, 0x42,
+    0x86, 0x02, 0x38, 0x39, 0x40, 0x86, 0x02, 0x69,
+    0x34, 0x80, 0x16, 0x02, 0x69, 0x14, 0xeb, 0x13,
+    0x04, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x67,
+    0x14, 0x02, 0x77, 0x34, 0x42, 0x86, 0x02, 0x46,
+    0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0x92, 0x16,
+    0x02, 0x4e, 0x36, 0x42, 0x86, 0x03, 0x69, 0x14,
+    0xbd, 0x19, 0xa1, 0x87, 0x02, 0xde, 0x19, 0x40,
+    0x86, 0x02, 0x69, 0x34, 0x27, 0x15, 0x03, 0xc3,
+    0x13, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x81, 0x14,
+    0x40, 0x86, 0x03, 0xd1, 0x39, 0xaf, 0x19, 0xa1,
+    0x87, 0x02, 0x68, 0x34, 0xbc, 0x19, 0x02, 0xd1,
+    0x19, 0x80, 0x16, 0x02, 0xd9, 0x39, 0x42, 0x86,
+    0x02, 0xd1, 0x39, 0xbc, 0x19, 0x02, 0xdc, 0x19,
+    0x42, 0x86, 0x02, 0x68, 0x34, 0x73, 0x13, 0x02,
+    0x69, 0x34, 0x3e, 0x13, 0x02, 0x47, 0x16, 0x40,
+    0x86, 0x02, 0xd1, 0x39, 0xbd, 0x19, 0x02, 0x3e,
+    0x39, 0x42, 0x86, 0x02, 0x69, 0x14, 0x95, 0x86,
+    0x02, 0x68, 0x14, 0x96, 0x86, 0x03, 0x69, 0x34,
+    0xbd, 0x19, 0xa1, 0x87, 0x02, 0xd7, 0x39, 0x40,
+    0x86, 0x02, 0x45, 0x16, 0x42, 0x86, 0x02, 0x68,
+    0x34, 0xed, 0x13, 0x03, 0x68, 0x34, 0xbc, 0x19,
+    0xa1, 0x87, 0x02, 0xd1, 0x39, 0xed, 0x13, 0x02,
+    0xd1, 0x39, 0x92, 0x16, 0x02, 0x73, 0x34, 0x40,
+    0x86, 0x02, 0x38, 0x19, 0x40, 0x86, 0x02, 0xb5,
+    0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0xaf, 0x19,
+    0x02, 0xd1, 0x39, 0xaf, 0x19, 0x02, 0x69, 0x34,
+    0xbc, 0x19, 0x02, 0xb6, 0x16, 0x42, 0x86, 0x02,
+    0x26, 0x14, 0x25, 0x15, 0x02, 0xc3, 0x33, 0x40,
+    0x86, 0x02, 0xdd, 0x39, 0x42, 0x86, 0x02, 0xcb,
+    0x93, 0x42, 0x86, 0x02, 0xcb, 0x33, 0x42, 0x86,
+    0x02, 0x81, 0x34, 0x42, 0x86, 0x02, 0xce, 0x39,
+    0xa1, 0x87, 0x02, 0xdb, 0x39, 0x40, 0x86, 0x02,
+    0x68, 0x34, 0x08, 0x87, 0x02, 0xd1, 0x19, 0xb0,
+    0x19, 0x02, 0x77, 0x34, 0x40, 0x86, 0x02, 0x4e,
+    0x36, 0x40, 0x86, 0x02, 0xce, 0x39, 0x42, 0x86,
+    0x02, 0x4e, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x39,
+    0x40, 0x86, 0x02, 0xdc, 0x19, 0x40, 0x86, 0x02,
+    0x3e, 0x39, 0x40, 0x86, 0x02, 0xb9, 0x39, 0x42,
+    0x86, 0x02, 0xda, 0x19, 0x42, 0x86, 0x02, 0x42,
+    0x16, 0x94, 0x81, 0x02, 0x45, 0x16, 0x40, 0x86,
+    0x02, 0x69, 0x14, 0xbd, 0x19, 0x02, 0x70, 0x34,
+    0x42, 0x86, 0x02, 0xce, 0x19, 0xa1, 0x87, 0x02,
+    0xc3, 0x13, 0x42, 0x86, 0x02, 0x68, 0x14, 0x08,
+    0x87, 0x02, 0xd1, 0x19, 0x7c, 0x13, 0x02, 0x68,
+    0x14, 0x92, 0x16, 0x02, 0xb6, 0x16, 0x40, 0x86,
+    0x02, 0x37, 0x39, 0x42, 0x86, 0x03, 0xce, 0x19,
+    0x42, 0x86, 0xa1, 0x87, 0x03, 0x68, 0x14, 0x67,
+    0x14, 0x67, 0x14, 0x02, 0xdd, 0x39, 0x40, 0x86,
+    0x02, 0xcf, 0x19, 0x42, 0x86, 0x02, 0xd1, 0x19,
+    0x2c, 0x15, 0x02, 0x4b, 0x13, 0xe9, 0x17, 0x02,
+    0x68, 0x14, 0x67, 0x14, 0x02, 0xcb, 0x93, 0x40,
+    0x86, 0x02, 0x6e, 0x34, 0x42, 0x86, 0x02, 0xcb,
+    0x33, 0x40, 0x86, 0x02, 0x81, 0x34, 0x40, 0x86,
+    0x02, 0xb6, 0x36, 0xa1, 0x87, 0x02, 0x45, 0x36,
+    0x42, 0x86, 0x02, 0xb4, 0x16, 0x42, 0x86, 0x02,
+    0x69, 0x14, 0x73, 0x13, 0x04, 0x69, 0x14, 0x69,
+    0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x35, 0x39,
+    0x42, 0x86, 0x02, 0x68, 0x14, 0x93, 0x13, 0x02,
+    0xb6, 0x36, 0x42, 0x86, 0x03, 0x68, 0x14, 0x69,
+    0x14, 0x66, 0x14, 0x02, 0xce, 0x39, 0x40, 0x86,
+    0x02, 0x4e, 0x16, 0x40, 0x86, 0x02, 0x87, 0x34,
+    0x42, 0x86, 0x02, 0x86, 0x14, 0x42, 0x86, 0x02,
+    0xd6, 0x39, 0x42, 0x86, 0x02, 0xc4, 0x33, 0x42,
+    0x86, 0x02, 0x69, 0x34, 0x96, 0x86, 0x02, 0xb9,
+    0x39, 0x40, 0x86, 0x02, 0x68, 0x14, 0xa8, 0x13,
+    0x02, 0xd1, 0x19, 0x84, 0x13, 0x02, 0xda, 0x19,
+    0x40, 0x86, 0x02, 0xd8, 0x19, 0x42, 0x86, 0x02,
+    0xc3, 0x13, 0x40, 0x86, 0x02, 0xb9, 0x19, 0x42,
+    0x86, 0x02, 0x3d, 0x19, 0x42, 0x86, 0x02, 0xcf,
+    0x19, 0x40, 0x86, 0x04, 0x68, 0x14, 0x68, 0x14,
+    0x67, 0x14, 0x67, 0x14, 0x03, 0xd1, 0x19, 0xd1,
+    0x19, 0xd2, 0x19, 0x02, 0x68, 0x14, 0xbb, 0x14,
+    0x02, 0x3b, 0x14, 0x44, 0x87, 0x02, 0xd1, 0x19,
+    0x27, 0x15, 0x02, 0xb4, 0x16, 0x40, 0x86, 0x02,
+    0xcd, 0x19, 0x42, 0x86, 0x02, 0xd3, 0x86, 0xa5,
+    0x14, 0x02, 0x70, 0x14, 0x42, 0x86, 0x03, 0xb6,
+    0x16, 0x42, 0x86, 0xa1, 0x87, 0x04, 0x69, 0x14,
+    0x64, 0x87, 0x8b, 0x14, 0x69, 0x14, 0x02, 0x36,
+    0x16, 0x2b, 0x93, 0x02, 0x68, 0x14, 0x80, 0x16,
+    0x02, 0x86, 0x14, 0x40, 0x86, 0x02, 0x08, 0x14,
+    0x1b, 0x0b, 0x02, 0xd1, 0x19, 0xbc, 0x19, 0x02,
+    0xca, 0x13, 0x42, 0x86, 0x02, 0x41, 0x94, 0xe8,
+    0x95, 0x02, 0xd8, 0x19, 0x40, 0x86, 0x02, 0xb9,
+    0x19, 0x40, 0x86, 0x02, 0xd1, 0x19, 0xed, 0x13,
+    0x02, 0xf9, 0x86, 0x42, 0x86, 0x03, 0xd1, 0x19,
+    0xbd, 0x19, 0xa1, 0x87, 0x02, 0x3d, 0x19, 0x40,
+    0x86, 0x02, 0xd6, 0x19, 0x42, 0x86, 0x03, 0x69,
+    0x14, 0x66, 0x14, 0x66, 0x14, 0x02, 0xd1, 0x19,
+    0xaf, 0x19, 0x03, 0x69, 0x14, 0x69, 0x14, 0x67,
+    0x14, 0x02, 0xcd, 0x19, 0x40, 0x86, 0x02, 0x70,
+    0x14, 0x40, 0x86, 0x03, 0x68, 0x14, 0xbc, 0x19,
+    0xa1, 0x87, 0x02, 0x6e, 0x14, 0x42, 0x86, 0x02,
+    0x69, 0x14, 0x92, 0x16, 0x03, 0x68, 0x14, 0x68,
+    0x14, 0x67, 0x14, 0x02, 0x69, 0x14, 0x67, 0x14,
+    0x02, 0x75, 0x95, 0x42, 0x86, 0x03, 0x69, 0x14,
+    0x64, 0x87, 0x69, 0x14, 0x02, 0xd1, 0x19, 0xbc,
+    0x14, 0x02, 0xdf, 0x19, 0x42, 0x86, 0x02, 0xca,
+    0x13, 0x40, 0x86, 0x02, 0x82, 0x14, 0x42, 0x86,
+    0x02, 0x69, 0x14, 0x93, 0x13, 0x02, 0x68, 0x14,
+    0x7c, 0x13, 0x02, 0xf9, 0x86, 0x40, 0x86, 0x02,
+    0xd6, 0x19, 0x40, 0x86, 0x02, 0x68, 0x14, 0x2c,
+    0x15, 0x02, 0x69, 0x14, 0xa8, 0x13, 0x02, 0xd4,
+    0x19, 0x42, 0x86, 0x04, 0x68, 0x14, 0x69, 0x14,
+    0x66, 0x14, 0x66, 0x14, 0x02, 0x77, 0x14, 0x42,
+    0x86, 0x02, 0x39, 0x19, 0x42, 0x86, 0x02, 0xd1,
+    0x19, 0xa4, 0x13, 0x02, 0x6e, 0x14, 0x40, 0x86,
+    0x03, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02,
+    0x69, 0x14, 0xbb, 0x14, 0x02, 0xd1, 0x19, 0x96,
+    0x86, 0x02, 0x75, 0x95, 0x40, 0x86, 0x04, 0x68,
+    0x14, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x14, 0x02,
+    0xd1, 0x19, 0x3e, 0x13, 0x02, 0xdf, 0x19, 0x40,
+    0x86, 0x02, 0x82, 0x14, 0x40, 0x86, 0x02, 0x44,
+    0x13, 0xeb, 0x17, 0x02, 0xdd, 0x19, 0x42, 0x86,
+    0x02, 0x69, 0x14, 0x80, 0x16, 0x03, 0x68, 0x14,
+    0xaf, 0x19, 0xa1, 0x87, 0x02, 0xa3, 0x16, 0x42,
+    0x86, 0x02, 0x69, 0x14, 0x96, 0x86, 0x02, 0x46,
+    0x16, 0x42, 0x86, 0x02, 0xb6, 0x16, 0xa1, 0x87,
+    0x02, 0x68, 0x14, 0x27, 0x15, 0x02, 0x26, 0x14,
+    0x1b, 0x0b, 0x02, 0xd4, 0x19, 0x40, 0x86, 0x02,
+    0x77, 0x14, 0x40, 0x86, 0x02, 0x39, 0x19, 0x40,
+    0x86, 0x02, 0x37, 0x19, 0x42, 0x86, 0x03, 0x69,
+    0x14, 0x67, 0x14, 0x66, 0x14, 0x03, 0xc3, 0x13,
+    0x42, 0x86, 0xa1, 0x87, 0x02, 0x68, 0x14, 0xbc,
+    0x19, 0x02, 0xd1, 0x19, 0xeb, 0x13, 0x04, 0x69,
+    0x14, 0x69, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02,
+    0xd1, 0x19, 0x08, 0x87, 0x02, 0x68, 0x14, 0xed,
+    0x13, 0x03, 0x69, 0x14, 0xbc, 0x19, 0xa1, 0x87,
+    0x02, 0xdd, 0x19, 0x40, 0x86, 0x02, 0xc3, 0x13,
+    0xa1, 0x87, 0x03, 0x68, 0x14, 0x66, 0x14, 0x66,
+    0x14, 0x03, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14,
+    0x02, 0xa3, 0x16, 0x40, 0x86, 0x02, 0xdb, 0x19,
+    0x42, 0x86, 0x02, 0x68, 0x14, 0xaf, 0x19, 0x02,
+    0x46, 0x16, 0x40, 0x86, 0x02, 0x35, 0x16, 0xab,
+    0x14, 0x02, 0x68, 0x14, 0x95, 0x86, 0x02, 0x42,
+    0x16, 0x95, 0x81, 0x02, 0xc4, 0x13, 0x42, 0x86,
+    0x02, 0x15, 0x14, 0xba, 0x19, 0x02, 0x69, 0x14,
+    0x08, 0x87, 0x03, 0xd1, 0x19, 0x1d, 0x19, 0xd1,
+    0x19, 0x02, 0x69, 0x14, 0x7c, 0x13, 0x02, 0x37,
+    0x19, 0x40, 0x86, 0x02, 0x73, 0x14, 0x42, 0x86,
+    0x02, 0x69, 0x14, 0x2c, 0x15, 0x02, 0xb5, 0x16,
+    0x42, 0x86, 0x02, 0x35, 0x19, 0x42, 0x86, 0x04,
+    0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x66, 0x14,
+    0x02, 0x64, 0x87, 0x25, 0x15, 0x02, 0x64, 0x87,
+    0x79, 0x1a, 0x02, 0x68, 0x14, 0xbc, 0x14, 0x03,
+    0xce, 0x19, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x87,
+    0x14, 0x42, 0x86, 0x02, 0x4d, 0x16, 0x42, 0x86,
+    0x04, 0x68, 0x14, 0x68, 0x14, 0x66, 0x14, 0x66,
+    0x14, 0x02, 0xdb, 0x19, 0x40, 0x86, 0x02, 0xd9,
+    0x19, 0x42, 0x86, 0x02, 0xc4, 0x13, 0x40, 0x86,
+    0x02, 0xd1, 0x19, 0xbd, 0x19, 0x02, 0x68, 0x14,
+    0xa4, 0x13, 0x02, 0x3e, 0x19, 0x42, 0x86, 0x02,
+    0xf3, 0x93, 0xa7, 0x86, 0x03, 0x69, 0x14, 0xaf,
+    0x19, 0xa1, 0x87, 0x02, 0xf3, 0x93, 0x08, 0x13,
+    0x02, 0xd1, 0x19, 0xd2, 0x19, 0x02, 0x73, 0x14,
+    0x40, 0x86, 0x02, 0xb5, 0x16, 0x40, 0x86, 0x02,
+    0x35, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14, 0x27,
+    0x15, 0x02, 0xce, 0x19, 0x42, 0x86, 0x02, 0x71,
+    0x14, 0x42, 0x86, 0x02, 0xd1, 0x19, 0x73, 0x13,
+    0x02, 0x68, 0x14, 0x3e, 0x13, 0x02, 0xf4, 0x13,
+    0x20, 0x86, 0x02, 0x87, 0x14, 0x40, 0x86, 0x03,
+    0xb6, 0x16, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x4d,
+    0x16, 0x40, 0x86, 0x02, 0x69, 0x14, 0xbc, 0x19,
+    0x02, 0x4b, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x19,
+    0x40, 0x86, 0x02, 0x3e, 0x19, 0x40, 0x86, 0x02,
+    0x69, 0x14, 0xed, 0x13, 0x02, 0xd7, 0x19, 0x42,
+    0x86, 0x02, 0xb8, 0x19, 0x42, 0x86, 0x03, 0x68,
+    0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x3c, 0x19,
+    0x42, 0x86, 0x02, 0x68, 0x14, 0x66, 0x14, 0x03,
+    0x68, 0x14, 0x64, 0x87, 0x68, 0x14, 0x02, 0x69,
+    0x14, 0xaf, 0x19, 0x02, 0xce, 0x19, 0x40, 0x86,
+    0x02, 0x71, 0x14, 0x40, 0x86, 0x02, 0x68, 0x14,
+    0xeb, 0x13, 0x03, 0x68, 0x14, 0xbd, 0x19, 0xa1,
+    0x87, 0x02, 0x6f, 0x14, 0x42, 0x86, 0x04, 0xd1,
+    0x19, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02,
+    0x69, 0x14, 0xbc, 0x14, 0x02, 0xcc, 0x93, 0x42,
+    0x86, 0x02, 0x4b, 0x16, 0x40, 0x86, 0x02, 0x26,
+    0x19, 0x42, 0x86, 0x02, 0xd7, 0x19, 0x40, 0x86,
+};
+
 #endif /* CONFIG_ALL_UNICODE */
+/* 71 tables / 36311 bytes, 5 index / 351 bytes */
diff --git a/quickjs/libunicode.c b/quickjs/libunicode.c
index 63c12a0771..3791523d6a 100644
--- a/quickjs/libunicode.c
+++ b/quickjs/libunicode.c
@@ -1,6 +1,6 @@
 /*
  * Unicode utilities
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -43,15 +43,115 @@ enum {
     RUN_TYPE_UF_D1_EXT,
     RUN_TYPE_U_EXT,
     RUN_TYPE_LF_EXT,
-    RUN_TYPE_U_EXT2,
-    RUN_TYPE_L_EXT2,
-    RUN_TYPE_U_EXT3,
+    RUN_TYPE_UF_EXT2,
+    RUN_TYPE_LF_EXT2,
+    RUN_TYPE_UF_EXT3,
 };
 
+static int lre_case_conv1(uint32_t c, int conv_type)
+{
+    uint32_t res[LRE_CC_RES_LEN_MAX];
+    lre_case_conv(res, c, conv_type);
+    return res[0];
+}
+
+/* case conversion using the table entry 'idx' with value 'v' */
+static int lre_case_conv_entry(uint32_t *res, uint32_t c, int conv_type, uint32_t idx, uint32_t v)
+{
+    uint32_t code, data, type, a, is_lower;
+    is_lower = (conv_type != 0);
+    type = (v >> (32 - 17 - 7 - 4)) & 0xf;
+    data = ((v & 0xf) << 8) | case_conv_table2[idx];
+    code = v >> (32 - 17);
+    switch(type) {
+    case RUN_TYPE_U:
+    case RUN_TYPE_L:
+    case RUN_TYPE_UF:
+    case RUN_TYPE_LF:
+        if (conv_type == (type & 1) ||
+            (type >= RUN_TYPE_UF && conv_type == 2)) {
+            c = c - code + (case_conv_table1[data] >> (32 - 17));
+        }
+        break;
+    case RUN_TYPE_UL:
+        a = c - code;
+        if ((a & 1) != (1 - is_lower))
+            break;
+        c = (a ^ 1) + code;
+        break;
+    case RUN_TYPE_LSU:
+        a = c - code;
+        if (a == 1) {
+            c += 2 * is_lower - 1;
+        } else if (a == (1 - is_lower) * 2) {
+            c += (2 * is_lower - 1) * 2;
+        }
+        break;
+    case RUN_TYPE_U2L_399_EXT2:
+        if (!is_lower) {
+            res[0] = c - code + case_conv_ext[data >> 6];
+            res[1] = 0x399;
+            return 2;
+        } else {
+            c = c - code + case_conv_ext[data & 0x3f];
+        }
+        break;
+    case RUN_TYPE_UF_D20:
+        if (conv_type == 1)
+            break;
+        c = data + (conv_type == 2) * 0x20;
+        break;
+    case RUN_TYPE_UF_D1_EXT:
+        if (conv_type == 1)
+            break;
+        c = case_conv_ext[data] + (conv_type == 2);
+        break;
+    case RUN_TYPE_U_EXT:
+    case RUN_TYPE_LF_EXT:
+        if (is_lower != (type - RUN_TYPE_U_EXT))
+            break;
+        c = case_conv_ext[data];
+        break;
+    case RUN_TYPE_LF_EXT2:
+        if (!is_lower)
+            break;
+        res[0] = c - code + case_conv_ext[data >> 6];
+        res[1] = case_conv_ext[data & 0x3f];
+        return 2;
+    case RUN_TYPE_UF_EXT2:
+        if (conv_type == 1)
+            break;
+        res[0] = c - code + case_conv_ext[data >> 6];
+        res[1] = case_conv_ext[data & 0x3f];
+        if (conv_type == 2) {
+            /* convert to lower */
+            res[0] = lre_case_conv1(res[0], 1);
+            res[1] = lre_case_conv1(res[1], 1);
+        }
+        return 2;
+    default:
+    case RUN_TYPE_UF_EXT3:
+        if (conv_type == 1)
+            break;
+        res[0] = case_conv_ext[data >> 8];
+        res[1] = case_conv_ext[(data >> 4) & 0xf];
+        res[2] = case_conv_ext[data & 0xf];
+        if (conv_type == 2) {
+            /* convert to lower */
+            res[0] = lre_case_conv1(res[0], 1);
+            res[1] = lre_case_conv1(res[1], 1);
+            res[2] = lre_case_conv1(res[2], 1);
+        }
+        return 3;
+    }
+    res[0] = c;
+    return 1;
+}
+
 /* conv_type:
-   0 = to upper 
+   0 = to upper
    1 = to lower
-   2 = case folding (= to lower with modifications) 
+   2 = case folding (= to lower with modifications)
 */
 int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
 {
@@ -66,10 +166,9 @@ int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
             }
         }
     } else {
-        uint32_t v, code, data, type, len, a, is_lower;
+        uint32_t v, code, len;
         int idx, idx_min, idx_max;
-        
-        is_lower = (conv_type != 0);
+
         idx_min = 0;
         idx_max = countof(case_conv_table1) - 1;
         while (idx_min <= idx_max) {
@@ -82,74 +181,7 @@ int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
             } else if (c >= code + len) {
                 idx_min = idx + 1;
             } else {
-                type = (v >> (32 - 17 - 7 - 4)) & 0xf;
-                data = ((v & 0xf) << 8) | case_conv_table2[idx];
-                switch(type) {
-                case RUN_TYPE_U:
-                case RUN_TYPE_L:
-                case RUN_TYPE_UF:
-                case RUN_TYPE_LF:
-                    if (conv_type == (type & 1) ||
-                        (type >= RUN_TYPE_UF && conv_type == 2)) {
-                        c = c - code + (case_conv_table1[data] >> (32 - 17));
-                    }
-                    break;
-                case RUN_TYPE_UL:
-                    a = c - code;
-                    if ((a & 1) != (1 - is_lower))
-                        break;
-                    c = (a ^ 1) + code;
-                    break;
-                case RUN_TYPE_LSU:
-                    a = c - code;
-                    if (a == 1) {
-                        c += 2 * is_lower - 1;
-                    } else if (a == (1 - is_lower) * 2) {
-                        c += (2 * is_lower - 1) * 2;
-                    }
-                    break;
-                case RUN_TYPE_U2L_399_EXT2:
-                    if (!is_lower) {
-                        res[0] = c - code + case_conv_ext[data >> 6];
-                        res[1] = 0x399;
-                        return 2;
-                    } else {
-                        c = c - code + case_conv_ext[data & 0x3f];
-                    }
-                    break;
-                case RUN_TYPE_UF_D20:
-                    if (conv_type == 1)
-                        break;
-                    c = data + (conv_type == 2) * 0x20;
-                    break;
-                case RUN_TYPE_UF_D1_EXT:
-                    if (conv_type == 1)
-                        break;
-                    c = case_conv_ext[data] + (conv_type == 2);
-                    break;
-                case RUN_TYPE_U_EXT:
-                case RUN_TYPE_LF_EXT:
-                    if (is_lower != (type - RUN_TYPE_U_EXT))
-                        break;
-                    c = case_conv_ext[data];
-                    break;
-                case RUN_TYPE_U_EXT2:
-                case RUN_TYPE_L_EXT2:
-                    if (conv_type != (type - RUN_TYPE_U_EXT2))
-                        break;
-                    res[0] = c - code + case_conv_ext[data >> 6];
-                    res[1] = case_conv_ext[data & 0x3f];
-                    return 2;
-                default:
-                case RUN_TYPE_U_EXT3:
-                    if (conv_type != 0)
-                        break;
-                    res[0] = case_conv_ext[data >> 8];
-                    res[1] = case_conv_ext[(data >> 4) & 0xf];
-                    res[2] = case_conv_ext[data & 0xf];
-                    return 3;
-                }
-                break;
+                return lre_case_conv_entry(res, c, conv_type, idx, v);
             }
         }
     }
@@ -157,13 +189,80 @@ int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
     return 1;
 }
 
+static int lre_case_folding_entry(uint32_t c, uint32_t idx, uint32_t v, BOOL is_unicode)
+{
+    uint32_t res[LRE_CC_RES_LEN_MAX];
+    int len;
+
+    if (is_unicode) {
+        len = lre_case_conv_entry(res, c, 2, idx, v);
+        if (len == 1) {
+            c = res[0];
+        } else {
+            /* handle the few specific multi-character cases (see
+               unicode_gen.c:dump_case_folding_special_cases()) */
+            if (c == 0xfb06) {
+                c = 0xfb05;
+            } else if (c == 0x01fd3) {
+                c = 0x390;
+            } else if (c == 0x01fe3) {
+                c = 0x3b0;
+            }
+        }
+    } else {
+        if (likely(c < 128)) {
+            if (c >= 'a' && c <= 'z')
+                c = c - 'a' + 'A';
+        } else {
+            /* legacy regexp: to upper case if single char >= 128 */
+            len = lre_case_conv_entry(res, c, FALSE, idx, v);
+            if (len == 1 && res[0] >= 128)
+                c = res[0];
+        }
+    }
+    return c;
+}
+
+/* JS regexp specific rules for case folding */
+int lre_canonicalize(uint32_t c, BOOL is_unicode)
+{
+    if (c < 128) {
+        /* fast case */
+        if (is_unicode) {
+            if (c >= 'A' && c <= 'Z') {
+                c = c - 'A' + 'a';
+            }
+        } else {
+            if (c >= 'a' && c <= 'z') {
+                c = c - 'a' + 'A';
+            }
+        }
+    } else {
+        uint32_t v, code, len;
+        int idx, idx_min, idx_max;
+
+        idx_min = 0;
+        idx_max = countof(case_conv_table1) - 1;
+        while (idx_min <= idx_max) {
+            idx = (unsigned)(idx_max + idx_min) / 2;
+            v = case_conv_table1[idx];
+            code = v >> (32 - 17);
+            len = (v >> (32 - 17 - 7)) & 0x7f;
+            if (c < code) {
+                idx_max = idx - 1;
+            } else if (c >= code + len) {
+                idx_min = idx + 1;
+            } else {
+                return lre_case_folding_entry(c, idx, v, is_unicode);
+            }
+        }
+    }
+    return c;
+}
+
 static uint32_t get_le24(const uint8_t *ptr)
 {
-#if defined(__x86__) || defined(__x86_64__)
-    return *(uint16_t *)ptr | (ptr[2] << 16);
-#else
     return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16);
-#endif
 }
 
 #define UNICODE_INDEX_BLOCK_LEN 32
@@ -208,12 +307,20 @@ static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
     uint32_t code, b, bit;
     int pos;
     const uint8_t *p;
-    
+
     pos = get_index_pos(&code, c, index_table, index_table_len);
     if (pos < 0)
         return FALSE; /* outside the table */
     p = table + pos;
     bit = 0;
+    /* Compressed run length encoding:
+       00..3F: 2 packed lengths: 3-bit + 3-bit
+       40..5F: 5-bits plus extra byte for length
+       60..7F: 5-bits plus 2 extra bytes for length
+       80..FF: 7-bit length
+       lengths must be incremented to get character count
+       Ranges alternate between false and true return value.
+     */
     for(;;) {
         b = *p++;
         if (b < 64) {
@@ -241,7 +348,7 @@ BOOL lre_is_cased(uint32_t c)
 {
     uint32_t v, code, len;
     int idx, idx_min, idx_max;
-        
+
     idx_min = 0;
     idx_max = countof(case_conv_table1) - 1;
     while (idx_min <= idx_max) {
@@ -300,7 +407,7 @@ int cr_realloc(CharRange *cr, int size)
 {
     int new_size;
     uint32_t *new_buf;
-    
+
     if (size > cr->size) {
         new_size = max_int(size, cr->size * 3 / 2);
         new_buf = cr->realloc_func(cr->mem_opaque, cr->points,
@@ -327,7 +434,7 @@ static void cr_compress(CharRange *cr)
 {
     int i, j, k, len;
     uint32_t *pt;
-    
+
     pt = cr->points;
     len = cr->len;
     i = 0;
@@ -357,7 +464,7 @@ int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
 {
     int a_idx, b_idx, is_in;
     uint32_t v;
-    
+
     a_idx = 0;
     b_idx = 0;
     for(;;) {
@@ -392,6 +499,9 @@ int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
         case CR_OP_XOR:
             is_in = (a_idx & 1) ^ (b_idx & 1);
             break;
+        case CR_OP_SUB:
+            is_in = (a_idx & 1) & ((b_idx & 1) ^ 1);
+            break;
         default:
             abort();
         }
@@ -404,14 +514,14 @@ int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
     return 0;
 }
 
-int cr_union1(CharRange *cr, const uint32_t *b_pt, int b_len)
+int cr_op1(CharRange *cr, const uint32_t *b_pt, int b_len, int op)
 {
     CharRange a = *cr;
     int ret;
     cr->len = 0;
     cr->size = 0;
     cr->points = NULL;
-    ret = cr_op(cr, a.points, a.len, b_pt, b_len, CR_OP_UNION);
+    ret = cr_op(cr, a.points, a.len, b_pt, b_len, op);
     cr_free(&a);
     return ret;
 }
@@ -430,6 +540,207 @@ int cr_invert(CharRange *cr)
     return 0;
 }
 
+#define CASE_U (1 << 0)
+#define CASE_L (1 << 1)
+#define CASE_F (1 << 2)
+
+/* use the case conversion table to generate range of characters.
+   CASE_U: set char if modified by uppercasing,
+   CASE_L: set char if modified by lowercasing,
+   CASE_F: set char if modified by case folding,
+ */
+static int unicode_case1(CharRange *cr, int case_mask)
+{
+#define MR(x) (1 << RUN_TYPE_ ## x)
+    const uint32_t tab_run_mask[3] = {
+        MR(U) | MR(UF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(UF_D20) |
+        MR(UF_D1_EXT) | MR(U_EXT) | MR(UF_EXT2) | MR(UF_EXT3),
+
+        MR(L) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(LF_EXT2),
+
+        MR(UF) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(LF_EXT2) | MR(UF_D20) | MR(UF_D1_EXT) | MR(LF_EXT) | MR(UF_EXT2) | MR(UF_EXT3),
+    };
+#undef MR
+    uint32_t mask, v, code, type, len, i, idx;
+
+    if (case_mask == 0)
+        return 0;
+    mask = 0;
+    for(i = 0; i < 3; i++) {
+        if ((case_mask >> i) & 1)
+            mask |= tab_run_mask[i];
+    }
+    for(idx = 0; idx < countof(case_conv_table1); idx++) {
+        v = case_conv_table1[idx];
+        type = (v >> (32 - 17 - 7 - 4)) & 0xf;
+        code = v >> (32 - 17);
+        len = (v >> (32 - 17 - 7)) & 0x7f;
+        if ((mask >> type) & 1) {
+            //            printf("%d: type=%d %04x %04x\n", idx, type, code, code + len - 1);
+            switch(type) {
+            case RUN_TYPE_UL:
+                if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
+                    goto def_case;
+                code += ((case_mask & CASE_U) != 0);
+                for(i = 0; i < len; i += 2) {
+                    if (cr_add_interval(cr, code + i, code + i + 1))
+                        return -1;
+                }
+                break;
+            case RUN_TYPE_LSU:
+                if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
+                    goto def_case;
+                if (!(case_mask & CASE_U)) {
+                    if (cr_add_interval(cr, code, code + 1))
+                        return -1;
+                }
+                if (cr_add_interval(cr, code + 1, code + 2))
+                    return -1;
+                if (case_mask & CASE_U) {
+                    if (cr_add_interval(cr, code + 2, code + 3))
+                        return -1;
+                }
+                break;
+            default:
+            def_case:
+                if (cr_add_interval(cr, code, code + len))
+                    return -1;
+                break;
+            }
+        }
+    }
+    return 0;
+}
+
+static int point_cmp(const void *p1, const void *p2, void *arg)
+{
+    uint32_t v1 = *(uint32_t *)p1;
+    uint32_t v2 = *(uint32_t *)p2;
+    return (v1 > v2) - (v1 < v2);
+}
+
+static void cr_sort_and_remove_overlap(CharRange *cr)
+{
+    uint32_t start, end, start1, end1, i, j;
+
+    /* the resulting ranges are not necessarily sorted and may overlap */
+    rqsort(cr->points, cr->len / 2, sizeof(cr->points[0]) * 2, point_cmp, NULL);
+    j = 0;
+    for(i = 0; i < cr->len; ) {
+        start = cr->points[i];
+        end = cr->points[i + 1];
+        i += 2;
+        while (i < cr->len) {
+            start1 = cr->points[i];
+            end1 = cr->points[i + 1];
+            if (start1 > end) {
+                /* |------|
+                 *           |-------| */
+                break;
+            } else if (end1 <= end) {
+                /* |------|
+                 *    |--| */
+                i += 2;
+            } else {
+                /* |------|
+                 *     |-------| */
+                end = end1;
+                i += 2;
+            }
+        }
+        cr->points[j] = start;
+        cr->points[j + 1] = end;
+        j += 2;
+    }
+    cr->len = j;
+}
+
+/* canonicalize a character set using the JS regex case folding rules
+   (see lre_canonicalize()) */
+int cr_regexp_canonicalize(CharRange *cr, BOOL is_unicode)
+{
+    CharRange cr_inter, cr_mask, cr_result, cr_sub;
+    uint32_t v, code, len, i, idx, start, end, c, d_start, d_end, d;
+
+    cr_init(&cr_mask, cr->mem_opaque, cr->realloc_func);
+    cr_init(&cr_inter, cr->mem_opaque, cr->realloc_func);
+    cr_init(&cr_result, cr->mem_opaque, cr->realloc_func);
+    cr_init(&cr_sub, cr->mem_opaque, cr->realloc_func);
+
+    if (unicode_case1(&cr_mask, is_unicode ? CASE_F : CASE_U))
+        goto fail;
+    if (cr_op(&cr_inter, cr_mask.points, cr_mask.len, cr->points, cr->len, CR_OP_INTER))
+        goto fail;
+
+    if (cr_invert(&cr_mask))
+        goto fail;
+    if (cr_op(&cr_sub, cr_mask.points, cr_mask.len, cr->points, cr->len, CR_OP_INTER))
+        goto fail;
+
+    /* cr_inter = cr & cr_mask */
+    /* cr_sub = cr & ~cr_mask */
+
+    /* use the case conversion table to compute the result */
+    d_start = -1;
+    d_end = -1;
+    idx = 0;
+    v = case_conv_table1[idx];
+    code = v >> (32 - 17);
+    len = (v >> (32 - 17 - 7)) & 0x7f;
+    for(i = 0; i < cr_inter.len; i += 2) {
+        start = cr_inter.points[i];
+        end = cr_inter.points[i + 1];
+
+        for(c = start; c < end; c++) {
+            for(;;) {
+                if (c >= code && c < code + len)
+                    break;
+                idx++;
+                assert(idx < countof(case_conv_table1));
+                v = case_conv_table1[idx];
+                code = v >> (32 - 17);
+                len = (v >> (32 - 17 - 7)) & 0x7f;
+            }
+            d = lre_case_folding_entry(c, idx, v, is_unicode);
+            /* try to merge with the current interval */
+            if (d_start == -1) {
+                d_start = d;
+                d_end = d + 1;
+            } else if (d_end == d) {
+                d_end++;
+            } else {
+                cr_add_interval(&cr_result, d_start, d_end);
+                d_start = d;
+                d_end = d + 1;
+            }
+        }
+    }
+    if (d_start != -1) {
+        if (cr_add_interval(&cr_result, d_start, d_end))
+            goto fail;
+    }
+
+    /* the resulting ranges are not necessarily sorted and may overlap */
+    cr_sort_and_remove_overlap(&cr_result);
+
+    /* or with the character not affected by the case folding */
+    cr->len = 0;
+    if (cr_op(cr, cr_result.points, cr_result.len, cr_sub.points, cr_sub.len, CR_OP_UNION))
+        goto fail;
+
+    cr_free(&cr_inter);
+    cr_free(&cr_mask);
+    cr_free(&cr_result);
+    cr_free(&cr_sub);
+    return 0;
+ fail:
+    cr_free(&cr_inter);
+    cr_free(&cr_mask);
+    cr_free(&cr_result);
+    cr_free(&cr_sub);
+    return -1;
+}
+
 #ifdef CONFIG_ALL_UNICODE
 
 BOOL lre_is_id_start(uint32_t c)
@@ -658,7 +969,7 @@ static int unicode_decomp_char(uint32_t *res, uint32_t c, BOOL is_compat1)
 {
     uint32_t v, type, is_compat, code, len;
     int idx_min, idx_max, idx;
-    
+
     idx_min = 0;
     idx_max = countof(unicode_decomp_table1) - 1;
     while (idx_min <= idx_max) {
@@ -688,7 +999,7 @@ static int unicode_compose_pair(uint32_t c0, uint32_t c1)
     uint32_t code, len, type, v, idx1, d_idx, d_offset, ch;
     int idx_min, idx_max, idx, d;
     uint32_t pair[2];
-    
+
     idx_min = 0;
     idx_max = countof(unicode_comp_table) - 1;
     while (idx_min <= idx_max) {
@@ -724,12 +1035,19 @@ static int unicode_get_cc(uint32_t c)
     uint32_t code, n, type, cc, c1, b;
     int pos;
     const uint8_t *p;
-    
+
     pos = get_index_pos(&code, c,
                         unicode_cc_index, sizeof(unicode_cc_index) / 3);
     if (pos < 0)
         return 0;
     p = unicode_cc_table + pos;
+    /* Compressed run length encoding:
+       - 2 high order bits are combining class type
+       -         0:0, 1:230, 2:extra byte linear progression, 3:extra byte
+       - 00..2F: range length (add 1)
+       - 30..37: 3-bit range-length + 1 extra byte
+       - 38..3F: 3-bit range-length + 2 extra byte
+     */
     for(;;) {
         b = *p++;
         type = b >> 6;
@@ -773,7 +1091,7 @@ static int unicode_get_cc(uint32_t c)
 static void sort_cc(int *buf, int len)
 {
     int i, j, k, cc, cc1, start, ch1;
-    
+
     for(i = 0; i < len; i++) {
         cc = unicode_get_cc(buf[i]);
         if (cc != 0) {
@@ -812,7 +1130,7 @@ static void to_nfd_rec(DynBuf *dbuf,
     uint32_t c, v;
     int i, l;
     uint32_t res[UNICODE_DECOMP_LEN_MAX];
-    
+
     for(i = 0; i < src_len; i++) {
         c = src[i];
         if (c >= 0xac00 && c < 0xd7a4) {
@@ -857,7 +1175,7 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
     int *buf, buf_len, i, p, starter_pos, cc, last_cc, out_len;
     BOOL is_compat;
     DynBuf dbuf_s, *dbuf = &dbuf_s;
-    
+
     is_compat = n_type >> 1;
 
     dbuf_init2(dbuf, opaque, realloc_func);
@@ -885,15 +1203,15 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
     }
     buf = (int *)dbuf->buf;
     buf_len = dbuf->size / sizeof(int);
-        
+
     sort_cc(buf, buf_len);
-    
+
     if (buf_len <= 1 || (n_type & 1) != 0) {
         /* NFD / NFKD */
         *pdst = (uint32_t *)buf;
         return buf_len;
     }
-    
+
     i = 1;
     out_len = 1;
     while (i < buf_len) {
@@ -930,7 +1248,7 @@ static int unicode_find_name(const char *name_table, const char *name)
     const char *p, *r;
     int pos;
     size_t name_len, len;
-    
+
     p = name_table;
     pos = 0;
     name_len = strlen(name);
@@ -963,13 +1281,11 @@ int unicode_script(CharRange *cr,
     CharRange cr1_s, *cr1;
     CharRange cr2_s, *cr2 = &cr2_s;
     BOOL is_common;
-    
+
     script_idx = unicode_find_name(unicode_script_name_table, script_name);
     if (script_idx < 0)
         return -2;
-    /* Note: we remove the "Unknown" Script */
-    script_idx += UNICODE_SCRIPT_Unknown + 1;
-        
+
     is_common = (script_idx == UNICODE_SCRIPT_Common ||
                  script_idx == UNICODE_SCRIPT_Inherited);
     if (is_ext) {
@@ -998,17 +1314,21 @@ int unicode_script(CharRange *cr,
             n |= *p++;
             n += 96 + (1 << 12);
         }
-        if (type == 0)
-            v = 0;
-        else
-            v = *p++;
         c1 = c + n + 1;
-        if (v == script_idx) {
-            if (cr_add_interval(cr1, c, c1))
-                goto fail;
+        if (type != 0) {
+            v = *p++;
+            if (v == script_idx || script_idx == UNICODE_SCRIPT_Unknown) {
+                if (cr_add_interval(cr1, c, c1))
+                    goto fail;
+            }
         }
         c = c1;
     }
+    if (script_idx == UNICODE_SCRIPT_Unknown) {
+        /* Unknown is all the characters outside scripts */
+        if (cr_invert(cr1))
+            goto fail;
+    }
 
     if (is_ext) {
         /* add the script extensions */
@@ -1082,6 +1402,15 @@ static int unicode_general_category1(CharRange *cr, uint32_t gc_mask)
     p = unicode_gc_table;
     p_end = unicode_gc_table + countof(unicode_gc_table);
     c = 0;
+    /* Compressed range encoding:
+       initial byte:
+       bits 0..4: category number (special case 31)
+       bits 5..7: range length (add 1)
+       special case bits 5..7 == 7: read an extra byte
+       - 00..7F: range length (add 7 + 1)
+       - 80..BF: 6-bits plus extra byte for range length (add 7 + 128)
+       - C0..FF: 6-bits plus 2 extra bytes for range length (add 7 + 128 + 16384)
+     */
     while (p < p_end) {
         b = *p++;
         n = b >> 5;
@@ -1135,6 +1464,14 @@ static int unicode_prop1(CharRange *cr, int prop_idx)
     p_end = p + unicode_prop_len_table[prop_idx];
     c = 0;
     bit = 0;
+    /* Compressed range encoding:
+       00..3F: 2 packed lengths: 3-bit + 3-bit
+       40..5F: 5-bits plus extra byte for length
+       60..7F: 5-bits plus 2 extra bytes for length
+       80..FF: 7-bit length
+       lengths must be incremented to get character count
+       Ranges alternate between false and true return value.
+     */
     while (p < p_end) {
         c0 = c;
         b = *p++;
@@ -1165,78 +1502,6 @@ static int unicode_prop1(CharRange *cr, int prop_idx)
     return 0;
 }
 
-#define CASE_U (1 << 0)
-#define CASE_L (1 << 1)
-#define CASE_F (1 << 2)
-
-/* use the case conversion table to generate range of characters.
-   CASE_U: set char if modified by uppercasing,
-   CASE_L: set char if modified by lowercasing,
-   CASE_F: set char if modified by case folding,
- */
-static int unicode_case1(CharRange *cr, int case_mask)
-{
-#define MR(x) (1 << RUN_TYPE_ ## x)
-    const uint32_t tab_run_mask[3] = {
-        MR(U) | MR(UF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(UF_D20) |
-        MR(UF_D1_EXT) | MR(U_EXT) | MR(U_EXT2) | MR(U_EXT3),
-
-        MR(L) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(L_EXT2),
-
-        MR(UF) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(UF_D20) | MR(UF_D1_EXT) | MR(LF_EXT),
-    };
-#undef MR
-    uint32_t mask, v, code, type, len, i, idx;
-
-    if (case_mask == 0)
-        return 0;
-    mask = 0;
-    for(i = 0; i < 3; i++) {
-        if ((case_mask >> i) & 1)
-            mask |= tab_run_mask[i];
-    }
-    for(idx = 0; idx < countof(case_conv_table1); idx++) {
-        v = case_conv_table1[idx];
-        type = (v >> (32 - 17 - 7 - 4)) & 0xf;
-        code = v >> (32 - 17);
-        len = (v >> (32 - 17 - 7)) & 0x7f;
-        if ((mask >> type) & 1) {
-            //            printf("%d: type=%d %04x %04x\n", idx, type, code, code + len - 1);
-            switch(type) {
-            case RUN_TYPE_UL:
-                if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
-                    goto def_case;
-                code += ((case_mask & CASE_U) != 0);
-                for(i = 0; i < len; i += 2) {
-                    if (cr_add_interval(cr, code + i, code + i + 1))
-                        return -1;
-                }
-                break;
-            case RUN_TYPE_LSU:
-                if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
-                    goto def_case;
-                if (!(case_mask & CASE_U)) {
-                    if (cr_add_interval(cr, code, code + 1))
-                        return -1;
-                }
-                if (cr_add_interval(cr, code + 1, code + 2))
-                    return -1;
-                if (case_mask & CASE_U) {
-                    if (cr_add_interval(cr, code + 2, code + 3))
-                        return -1;
-                }
-                break;
-            default:
-            def_case:
-                if (cr_add_interval(cr, code, code + len))
-                    return -1;
-                break;
-            }
-        }
-    }
-    return 0;
-}
-        
 typedef enum {
     POP_GC,
     POP_PROP,
@@ -1256,7 +1521,7 @@ static int unicode_prop_ops(CharRange *cr, ...)
     CharRange stack[POP_STACK_LEN_MAX];
     int stack_len, op, ret, i;
     uint32_t a;
-    
+
     va_start(ap, cr);
     stack_len = 0;
     for(;;) {
@@ -1294,6 +1559,7 @@ static int unicode_prop_ops(CharRange *cr, ...)
                 cr2 = &stack[stack_len - 1];
                 cr3 = &stack[stack_len++];
                 cr_init(cr3, cr->mem_opaque, cr->realloc_func);
+                /* CR_OP_XOR may be used here */
                 if (cr_op(cr3, cr1->points, cr1->len,
                           cr2->points, cr2->len, op - POP_UNION + CR_OP_UNION))
                     goto fail;
@@ -1342,7 +1608,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
 {
     int gc_idx;
     uint32_t gc_mask;
-    
+
     gc_idx = unicode_find_name(unicode_gc_name_table, gc_name);
     if (gc_idx < 0)
         return -2;
@@ -1360,7 +1626,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
 int unicode_prop(CharRange *cr, const char *prop_name)
 {
     int prop_idx, ret;
-    
+
     prop_idx = unicode_find_name(unicode_prop_name_table, prop_name);
     if (prop_idx < 0)
         return -2;
@@ -1554,3 +1820,304 @@ int unicode_prop(CharRange *cr, const char *prop_name)
 }
 
 #endif /* CONFIG_ALL_UNICODE */
+
+/*---- lre codepoint categorizing functions ----*/
+
+#define S  UNICODE_C_SPACE
+#define D  UNICODE_C_DIGIT
+#define X  UNICODE_C_XDIGIT
+#define U  UNICODE_C_UPPER
+#define L  UNICODE_C_LOWER
+#define _  UNICODE_C_UNDER
+#define d  UNICODE_C_DOLLAR
+
+uint8_t const lre_ctype_bits[256] = {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, S, S, S, S, S, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    S, 0, 0, 0, d, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    X|D, X|D, X|D, X|D, X|D, X|D, X|D, X|D,
+    X|D, X|D, 0, 0, 0, 0, 0, 0,
+
+    0, X|U, X|U, X|U, X|U, X|U, X|U, U,
+    U, U, U, U, U, U, U, U,
+    U, U, U, U, U, U, U, U,
+    U, U, U, 0, 0, 0, 0, _,
+
+    0, X|L, X|L, X|L, X|L, X|L, X|L, L,
+    L, L, L, L, L, L, L, L,
+    L, L, L, L, L, L, L, L,
+    L, L, L, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    S, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+#undef S
+#undef D
+#undef X
+#undef U
+#undef L
+#undef _
+#undef d
+
+/* code point ranges for Zs,Zl or Zp property */
+static const uint16_t char_range_s[] = {
+    10,
+    0x0009, 0x000D + 1,
+    0x0020, 0x0020 + 1,
+    0x00A0, 0x00A0 + 1,
+    0x1680, 0x1680 + 1,
+    0x2000, 0x200A + 1,
+    /* 2028;LINE SEPARATOR;Zl;0;WS;;;;;N;;;;; */
+    /* 2029;PARAGRAPH SEPARATOR;Zp;0;B;;;;;N;;;;; */
+    0x2028, 0x2029 + 1,
+    0x202F, 0x202F + 1,
+    0x205F, 0x205F + 1,
+    0x3000, 0x3000 + 1,
+    /* FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;; */
+    0xFEFF, 0xFEFF + 1,
+};
+
+BOOL lre_is_space_non_ascii(uint32_t c)
+{
+    size_t i, n;
+
+    n = countof(char_range_s);
+    for(i = 5; i < n; i += 2) {
+        uint32_t low = char_range_s[i];
+        uint32_t high = char_range_s[i + 1];
+        if (c < low)
+            return FALSE;
+        if (c < high)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+#define SEQ_MAX_LEN 16
+
+static int unicode_sequence_prop1(int seq_prop_idx, UnicodeSequencePropCB *cb, void *opaque,
+                                  CharRange *cr)
+{
+    int i, c, j;
+    uint32_t seq[SEQ_MAX_LEN];
+    
+    switch(seq_prop_idx) {
+    case UNICODE_SEQUENCE_PROP_Basic_Emoji:
+        if (unicode_prop1(cr, UNICODE_PROP_Basic_Emoji1) < 0)
+            return -1;
+        for(i = 0; i < cr->len; i += 2) {
+            for(c = cr->points[i]; c < cr->points[i + 1]; c++) {
+                seq[0] = c;
+                cb(opaque, seq, 1);
+            }
+        }
+
+        cr->len = 0;
+
+        if (unicode_prop1(cr, UNICODE_PROP_Basic_Emoji2) < 0)
+            return -1;
+        for(i = 0; i < cr->len; i += 2) {
+            for(c = cr->points[i]; c < cr->points[i + 1]; c++) {
+                seq[0] = c;
+                seq[1] = 0xfe0f;
+                cb(opaque, seq, 2);
+            }
+        }
+
+        break;
+    case UNICODE_SEQUENCE_PROP_RGI_Emoji_Modifier_Sequence:
+        if (unicode_prop1(cr, UNICODE_PROP_Emoji_Modifier_Base) < 0)
+            return -1;
+        for(i = 0; i < cr->len; i += 2) {
+            for(c = cr->points[i]; c < cr->points[i + 1]; c++) {
+                for(j = 0; j < 5; j++) {
+                    seq[0] = c;
+                    seq[1] = 0x1f3fb + j;
+                    cb(opaque, seq, 2);
+                }
+            }
+        }
+        break;
+    case UNICODE_SEQUENCE_PROP_RGI_Emoji_Flag_Sequence:
+        if (unicode_prop1(cr, UNICODE_PROP_RGI_Emoji_Flag_Sequence) < 0)
+            return -1;
+        for(i = 0; i < cr->len; i += 2) {
+            for(c = cr->points[i]; c < cr->points[i + 1]; c++) {
+                int c0, c1;
+                c0 = c / 26;
+                c1 = c % 26;
+                seq[0] = 0x1F1E6 + c0;
+                seq[1] = 0x1F1E6 + c1;
+                cb(opaque, seq, 2);
+            }
+        }
+        break;
+    case UNICODE_SEQUENCE_PROP_RGI_Emoji_ZWJ_Sequence:
+        {
+            int len, code, pres, k, mod, mod_count, mod_pos[2], hc_pos, n_mod, n_hc, mod1;
+            int mod_idx, hc_idx, i0, i1;
+            const uint8_t *tab = unicode_rgi_emoji_zwj_sequence;
+            
+            for(i = 0; i < countof(unicode_rgi_emoji_zwj_sequence);) {
+                len = tab[i++];
+                k = 0;
+                mod = 0;
+                mod_count = 0;
+                hc_pos = -1;
+                for(j = 0; j < len; j++) {
+                    code = tab[i++];
+                    code |= tab[i++] << 8;
+                    pres = code >> 15;
+                    mod1 = (code >> 13) & 3;
+                    code &= 0x1fff;
+                    if (code < 0x1000) {
+                        c = code + 0x2000;
+                    } else {
+                        c = 0x1f000 + (code - 0x1000);
+                    }
+                    if (c == 0x1f9b0)
+                        hc_pos = k;
+                    seq[k++] = c;
+                    if (mod1 != 0) {
+                        assert(mod_count < 2);
+                        mod = mod1;
+                        mod_pos[mod_count++] = k;
+                        seq[k++] = 0; /* will be filled later */
+                    }
+                    if (pres) {
+                        seq[k++] = 0xfe0f;
+                    }
+                    if (j < len - 1) {
+                        seq[k++] = 0x200d;
+                    }
+                }
+
+                /* genrate all the variants */
+                switch(mod) {
+                case 1:
+                    n_mod = 5;
+                    break;
+                case 2:
+                    n_mod = 25;
+                    break;
+                case 3:
+                    n_mod = 20;
+                    break;
+                default:
+                    n_mod = 1;
+                    break;
+                }
+                if (hc_pos >= 0)
+                    n_hc = 4;
+                else
+                    n_hc = 1;
+                for(hc_idx = 0; hc_idx < n_hc; hc_idx++) {
+                    for(mod_idx = 0; mod_idx < n_mod; mod_idx++) {
+                        if (hc_pos >= 0)
+                            seq[hc_pos] = 0x1f9b0 + hc_idx;
+                        
+                        switch(mod) {
+                        case 1:
+                            seq[mod_pos[0]] = 0x1f3fb + mod_idx;
+                            break;
+                        case 2:
+                        case 3:
+                            i0 = mod_idx / 5;
+                            i1 = mod_idx % 5;
+                            /* avoid identical values */
+                            if (mod == 3 && i0 >= i1)
+                                i0++;
+                            seq[mod_pos[0]] = 0x1f3fb + i0;
+                            seq[mod_pos[1]] = 0x1f3fb + i1;
+                            break;
+                        default:
+                            break;
+                        }
+#if 0
+                        for(j = 0; j < k; j++)
+                            printf(" %04x", seq[j]);
+                        printf("\n");
+#endif                
+                        cb(opaque, seq, k);
+                    }
+                }
+            }
+        }
+        break;
+    case UNICODE_SEQUENCE_PROP_RGI_Emoji_Tag_Sequence:
+        {
+            for(i = 0; i < countof(unicode_rgi_emoji_tag_sequence);) {
+                j = 0;
+                seq[j++] = 0x1F3F4;
+                for(;;) {
+                    c = unicode_rgi_emoji_tag_sequence[i++];
+                    if (c == 0x00)
+                        break;
+                    seq[j++] = 0xe0000 + c;
+                }
+                seq[j++] = 0xe007f;
+                cb(opaque, seq, j);
+            }
+        }
+        break;
+    case UNICODE_SEQUENCE_PROP_Emoji_Keycap_Sequence:
+        if (unicode_prop1(cr, UNICODE_PROP_Emoji_Keycap_Sequence) < 0)
+            return -1;
+        for(i = 0; i < cr->len; i += 2) {
+            for(c = cr->points[i]; c < cr->points[i + 1]; c++) {
+                seq[0] = c;
+                seq[1] = 0xfe0f;
+                seq[2] = 0x20e3;
+                cb(opaque, seq, 3);
+            }
+        }
+        break;
+    case UNICODE_SEQUENCE_PROP_RGI_Emoji:
+        /* all prevous sequences */
+        for(i = UNICODE_SEQUENCE_PROP_Basic_Emoji; i <= UNICODE_SEQUENCE_PROP_RGI_Emoji_ZWJ_Sequence; i++) {
+            int ret;
+            ret = unicode_sequence_prop1(i, cb, opaque, cr);
+            if (ret < 0)
+                return ret;
+            cr->len = 0;
+        }
+        break;
+    default:
+        return -2;
+    }
+    return 0;
+}
+
+/* build a unicode sequence property */
+/* return -2 if not found, -1 if other error. 'cr' is used as temporary memory. */
+int unicode_sequence_prop(const char *prop_name, UnicodeSequencePropCB *cb, void *opaque,
+                          CharRange *cr)
+{
+    int seq_prop_idx;
+    seq_prop_idx = unicode_find_name(unicode_sequence_prop_name_table, prop_name);
+    if (seq_prop_idx < 0)
+        return -2;
+    return unicode_sequence_prop1(seq_prop_idx, cb, opaque, cr);
+}
diff --git a/quickjs/libunicode.h b/quickjs/libunicode.h
index cfa600a50d..5d964e40f7 100644
--- a/quickjs/libunicode.h
+++ b/quickjs/libunicode.h
@@ -1,6 +1,6 @@
 /*
  * Unicode utilities
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -24,26 +24,13 @@
 #ifndef LIBUNICODE_H
 #define LIBUNICODE_H
 
-#include <inttypes.h>
-
-#define LRE_BOOL  int       /* for documentation purposes */
+#include <stdint.h>
 
 /* define it to include all the unicode tables (40KB larger) */
 #define CONFIG_ALL_UNICODE
 
 #define LRE_CC_RES_LEN_MAX 3
 
-typedef enum {
-    UNICODE_NFC,
-    UNICODE_NFD,
-    UNICODE_NFKC,
-    UNICODE_NFKD,
-} UnicodeNormalizationEnum;
-
-int lre_case_conv(uint32_t *res, uint32_t c, int conv_type);
-LRE_BOOL lre_is_cased(uint32_t c);
-LRE_BOOL lre_is_case_ignorable(uint32_t c);
-
 /* char ranges */
 
 typedef struct {
@@ -58,6 +45,7 @@ typedef enum {
     CR_OP_UNION,
     CR_OP_INTER,
     CR_OP_XOR,
+    CR_OP_SUB,
 } CharRangeOpEnum;
 
 void cr_init(CharRange *cr, void *mem_opaque, void *(*realloc_func)(void *opaque, void *ptr, size_t size));
@@ -86,25 +74,28 @@ static inline int cr_add_interval(CharRange *cr, uint32_t c1, uint32_t c2)
     return 0;
 }
 
-int cr_union1(CharRange *cr, const uint32_t *b_pt, int b_len);
+int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
+          const uint32_t *b_pt, int b_len, int op);
+int cr_op1(CharRange *cr, const uint32_t *b_pt, int b_len, int op);
 
 static inline int cr_union_interval(CharRange *cr, uint32_t c1, uint32_t c2)
 {
     uint32_t b_pt[2];
     b_pt[0] = c1;
     b_pt[1] = c2 + 1;
-    return cr_union1(cr, b_pt, 2);
+    return cr_op1(cr, b_pt, 2, CR_OP_UNION);
 }
 
-int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
-          const uint32_t *b_pt, int b_len, int op);
-
 int cr_invert(CharRange *cr);
 
-#ifdef CONFIG_ALL_UNICODE
+int cr_regexp_canonicalize(CharRange *cr, int is_unicode);
 
-LRE_BOOL lre_is_id_start(uint32_t c);
-LRE_BOOL lre_is_id_continue(uint32_t c);
+typedef enum {
+    UNICODE_NFC,
+    UNICODE_NFD,
+    UNICODE_NFKC,
+    UNICODE_NFKD,
+} UnicodeNormalizationEnum;
 
 int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
                       UnicodeNormalizationEnum n_type,
@@ -112,13 +103,84 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
 
 /* Unicode character range functions */
 
-int unicode_script(CharRange *cr,
-                   const char *script_name, LRE_BOOL is_ext);
+int unicode_script(CharRange *cr, const char *script_name, int is_ext);
 int unicode_general_category(CharRange *cr, const char *gc_name);
 int unicode_prop(CharRange *cr, const char *prop_name);
 
-#endif /* CONFIG_ALL_UNICODE */
+typedef void UnicodeSequencePropCB(void *opaque, const uint32_t *buf, int len);
+int unicode_sequence_prop(const char *prop_name, UnicodeSequencePropCB *cb, void *opaque,
+                          CharRange *cr);
+
+int lre_case_conv(uint32_t *res, uint32_t c, int conv_type);
+int lre_canonicalize(uint32_t c, int is_unicode);
+
+/* Code point type categories */
+enum {
+    UNICODE_C_SPACE  = (1 << 0),
+    UNICODE_C_DIGIT  = (1 << 1),
+    UNICODE_C_UPPER  = (1 << 2),
+    UNICODE_C_LOWER  = (1 << 3),
+    UNICODE_C_UNDER  = (1 << 4),
+    UNICODE_C_DOLLAR = (1 << 5),
+    UNICODE_C_XDIGIT = (1 << 6),
+};
+extern uint8_t const lre_ctype_bits[256];
+
+/* zero or non-zero return value */
+int lre_is_cased(uint32_t c);
+int lre_is_case_ignorable(uint32_t c);
+int lre_is_id_start(uint32_t c);
+int lre_is_id_continue(uint32_t c);
+
+static inline int lre_is_space_byte(uint8_t c) {
+    return lre_ctype_bits[c] & UNICODE_C_SPACE;
+}
+
+static inline int lre_is_id_start_byte(uint8_t c) {
+    return lre_ctype_bits[c] & (UNICODE_C_UPPER | UNICODE_C_LOWER |
+                                UNICODE_C_UNDER | UNICODE_C_DOLLAR);
+}
+
+static inline int lre_is_id_continue_byte(uint8_t c) {
+    return lre_ctype_bits[c] & (UNICODE_C_UPPER | UNICODE_C_LOWER |
+                                UNICODE_C_UNDER | UNICODE_C_DOLLAR |
+                                UNICODE_C_DIGIT);
+}
+
+int lre_is_space_non_ascii(uint32_t c);
+
+static inline int lre_is_space(uint32_t c) {
+    if (c < 256)
+        return lre_is_space_byte(c);
+    else
+        return lre_is_space_non_ascii(c);
+}
+
+static inline int lre_js_is_ident_first(uint32_t c) {
+    if (c < 128) {
+        return lre_is_id_start_byte(c);
+    } else {
+#ifdef CONFIG_ALL_UNICODE
+        return lre_is_id_start(c);
+#else
+        return !lre_is_space_non_ascii(c);
+#endif
+    }
+}
 
-#undef LRE_BOOL
+static inline int lre_js_is_ident_next(uint32_t c) {
+    if (c < 128) {
+        return lre_is_id_continue_byte(c);
+    } else {
+        /* ZWNJ and ZWJ are accepted in identifiers */
+        if (c >= 0x200C && c <= 0x200D)
+            return TRUE;
+#ifdef CONFIG_ALL_UNICODE
+        return lre_is_id_continue(c);
+#else
+        return !lre_is_space_non_ascii(c);
+#endif
+    }
+}
 
 #endif /* LIBUNICODE_H */
diff --git a/quickjs/list.h b/quickjs/list.h
index 0a1bc5a493..809831115f 100644
--- a/quickjs/list.h
+++ b/quickjs/list.h
@@ -1,6 +1,6 @@
 /*
  * Linux klist like system
- * 
+ *
  * Copyright (c) 2016-2017 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -36,8 +36,7 @@ struct list_head {
 #define LIST_HEAD_INIT(el) { &(el), &(el) }
 
 /* return the pointer of type 'type *' containing 'el' as field 'member' */
-#define list_entry(el, type, member) \
-    ((type *)((uint8_t *)(el) - offsetof(type, member)))
+#define list_entry(el, type, member) container_of(el, type, member)
 
 static inline void init_list_head(struct list_head *head)
 {
@@ -46,7 +45,7 @@ static inline void init_list_head(struct list_head *head)
 }
 
 /* insert 'el' between 'prev' and 'next' */
-static inline void __list_add(struct list_head *el, 
+static inline void __list_add(struct list_head *el,
                               struct list_head *prev, struct list_head *next)
 {
     prev->next = el;
diff --git a/quickjs/patches/2025-04-26-freebsd.patch b/quickjs/patches/2025-04-26-freebsd.patch
new file mode 100644
index 0000000000..abd4ce0ee3
--- /dev/null
+++ b/quickjs/patches/2025-04-26-freebsd.patch
@@ -0,0 +1,14 @@
+diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
+index 023d895..2387a45 100644
+--- a/quickjs/quickjs-libc.c
++++ b/quickjs/quickjs-libc.c
+@@ -48,7 +48,9 @@
+ #include <sys/wait.h>
+ 
+ #if defined(__FreeBSD__)
++__BEGIN_DECLS
+ extern char **environ;
++__END_DECLS
+ #endif
+ 
+ #if defined(__APPLE__) || defined(__FreeBSD__)
diff --git a/quickjs/patches/getclassid.patch b/quickjs/patches/2025-04-26-getclassid-const.patch
similarity index 51%
rename from quickjs/patches/getclassid.patch
rename to quickjs/patches/2025-04-26-getclassid-const.patch
index bfe6f218fa..d17cf11398 100644
--- a/quickjs/patches/getclassid.patch
+++ b/quickjs/patches/2025-04-26-getclassid-const.patch
@@ -1,30 +1,25 @@
 diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
-index 48aeffc62..8afc4caa1 100644
+index fa7c24a..0535169 100644
 --- a/quickjs/quickjs.c
 +++ b/quickjs/quickjs.c
-@@ -54034,3 +54034,14 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
-     JS_AddIntrinsicAtomics(ctx);
- #endif
+@@ -3320,7 +3320,7 @@ JSClassID JS_NewClassID(JSClassID *pclass_id)
+     return class_id;
  }
-+
+ 
+-JSClassID JS_GetClassID(JSValue v)
 +JSClassID JS_GetClassID(JSValueConst v)
-+{
-+    JSObject *p;
-+
-+    if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
-+        return 0;
-+    p = JS_VALUE_GET_OBJ(v);
-+    assert(p != 0);
-+    return p->class_id;
-+}
+ {
+     JSObject *p;
+     if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
 diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
-index d4a5cd311..054019147 100644
+index 2083f73..80aacc4 100644
 --- a/quickjs/quickjs.h
 +++ b/quickjs/quickjs.h
-@@ -497,6 +497,7 @@ typedef struct JSClassDef {
- } JSClassDef;
- 
+@@ -544,7 +544,7 @@ typedef struct JSClassDef {
+ #define JS_INVALID_CLASS_ID 0
  JSClassID JS_NewClassID(JSClassID *pclass_id);
+ /* Returns the class ID if `v` is an object, otherwise returns JS_INVALID_CLASS_ID. */
+-JSClassID JS_GetClassID(JSValue v);
 +JSClassID JS_GetClassID(JSValueConst v);
  int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);
  int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
diff --git a/quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch b/quickjs/patches/2025-04-26-getpropertyvalue_uninitialized_read_fix.patch
similarity index 61%
rename from quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch
rename to quickjs/patches/2025-04-26-getpropertyvalue_uninitialized_read_fix.patch
index 559a1ae8fd..06c1e2dce7 100644
--- a/quickjs/patches/getpropertyvalue_uninitialized_read_fix.patch
+++ b/quickjs/patches/2025-04-26-getpropertyvalue_uninitialized_read_fix.patch
@@ -1,13 +1,13 @@
 diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
-index c3f98e2e0..3b59284e6 100644
+index caad931..325c6dd 100644
 --- a/quickjs/quickjs.c
 +++ b/quickjs/quickjs.c
-@@ -7858,6 +7858,8 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
-         uint32_t idx, len;
+@@ -8367,6 +8367,8 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
+         uint32_t idx;
          /* fast path for array access */
          p = JS_VALUE_GET_OBJ(this_obj);
 +        if (unlikely(!p->fast_array))
 +            goto slow_path;
          idx = JS_VALUE_GET_INT(prop);
-         len = (uint32_t)p->u.array.count;
-         if (unlikely(idx >= len))
+         switch(p->class_id) {
+         case JS_CLASS_ARRAY:
diff --git a/quickjs/patches/unhandled_rejection.patch b/quickjs/patches/2025-04-26-unhandled_rejection.patch
similarity index 84%
rename from quickjs/patches/unhandled_rejection.patch
rename to quickjs/patches/2025-04-26-unhandled_rejection.patch
index 45ae58da9d..d8f4c4fa46 100644
--- a/quickjs/patches/unhandled_rejection.patch
+++ b/quickjs/patches/2025-04-26-unhandled_rejection.patch
@@ -1,18 +1,18 @@
 diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
-index 8afc4ca..c3f98e2 100644
+index 325c6dd..0535169 100644
 --- a/quickjs/quickjs.c
 +++ b/quickjs/quickjs.c
-@@ -282,6 +282,9 @@ struct JSRuntime {
- 
+@@ -278,6 +278,9 @@ struct JSRuntime {
      JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
      void *host_promise_rejection_tracker_opaque;
-+
+ 
 +    JSHostPromiseRejectionTracker *host_unhandled_promise_rejection_tracker;
 +    void *host_unhandled_promise_rejection_tracker_opaque;
-     
++
      struct list_head job_list; /* list of JSJobEntry.link */
  
-@@ -46255,6 +46258,7 @@ typedef struct JSPromiseData {
+     JSModuleNormalizeFunc *module_normalize_func;
+@@ -49246,6 +49249,7 @@ typedef struct JSPromiseData {
      struct list_head promise_reactions[2];
      BOOL is_handled; /* Note: only useful to debug */
      JSValue promise_result;
@@ -20,7 +20,7 @@ index 8afc4ca..c3f98e2 100644
  } JSPromiseData;
  
  typedef struct JSPromiseFunctionDataResolved {
-@@ -46335,6 +46339,14 @@ void JS_SetHostPromiseRejectionTracker(JSRuntime *rt,
+@@ -49342,6 +49346,14 @@ void JS_SetHostPromiseRejectionTracker(JSRuntime *rt,
      rt->host_promise_rejection_tracker_opaque = opaque;
  }
  
@@ -35,7 +35,7 @@ index 8afc4ca..c3f98e2 100644
  static void fulfill_or_reject_promise(JSContext *ctx, JSValueConst promise,
                                        JSValueConst value, BOOL is_reject)
  {
-@@ -46539,6 +46551,14 @@ static void js_promise_finalizer(JSRuntime *rt, JSValue val)
+@@ -49546,6 +49558,14 @@ static void js_promise_finalizer(JSRuntime *rt, JSValue val)
  
      if (!s)
          return;
@@ -50,7 +50,7 @@ index 8afc4ca..c3f98e2 100644
      for(i = 0; i < 2; i++) {
          list_for_each_safe(el, el1, &s->promise_reactions[i]) {
              JSPromiseReactionData *rd =
-@@ -46589,6 +46609,7 @@ static JSValue js_promise_constructor(JSContext *ctx, JSValueConst new_target,
+@@ -49596,6 +49616,7 @@ static JSValue js_promise_constructor(JSContext *ctx, JSValueConst new_target,
      s = js_mallocz(ctx, sizeof(*s));
      if (!s)
          goto fail;
@@ -59,10 +59,10 @@ index 8afc4ca..c3f98e2 100644
      s->is_handled = FALSE;
      for(i = 0; i < 2; i++)
 diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
-index 0540191..215e7b2 100644
+index 4570c6d..80aacc4 100644
 --- a/quickjs/quickjs.h
 +++ b/quickjs/quickjs.h
-@@ -839,6 +839,7 @@ typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
+@@ -912,6 +912,7 @@ typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
                                             JSValueConst reason,
                                             JS_BOOL is_handled, void *opaque);
  void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
diff --git a/quickjs/patches/freebsd.patch b/quickjs/patches/freebsd.patch
deleted file mode 100644
index 5c3eabd798..0000000000
--- a/quickjs/patches/freebsd.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
-index e180dd0cd3..f0c61be66f 100644
---- a/quickjs/quickjs-libc.c
-+++ b/quickjs/quickjs-libc.c
-@@ -55,6 +55,13 @@ typedef sig_t sighandler_t;
- #endif
- #endif /* __APPLE__ */
-
-+#if defined(__FreeBSD__)
-+typedef sig_t sighandler_t;
-+__BEGIN_DECLS
-+extern char **environ;
-+__END_DECLS
-+#endif  /* __FreeBSD__ */
-+
- #endif
-
- #if !defined(_WIN32)
diff --git a/quickjs/quickjs-atom.h b/quickjs/quickjs-atom.h
index 81c65b99d8..425c2e909a 100644
--- a/quickjs/quickjs-atom.h
+++ b/quickjs/quickjs-atom.h
@@ -1,6 +1,6 @@
 /*
  * QuickJS atom definitions
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  * Copyright (c) 2017-2018 Charlie Gordon
  *
@@ -81,7 +81,9 @@ DEF(empty_string, "")
 DEF(length, "length")
 DEF(fileName, "fileName")
 DEF(lineNumber, "lineNumber")
+DEF(columnNumber, "columnNumber")
 DEF(message, "message")
+DEF(cause, "cause")
 DEF(errors, "errors")
 DEF(stack, "stack")
 DEF(name, "name")
@@ -166,22 +168,26 @@ DEF(revoke, "revoke")
 DEF(async, "async")
 DEF(exec, "exec")
 DEF(groups, "groups")
+DEF(indices, "indices")
 DEF(status, "status")
 DEF(reason, "reason")
 DEF(globalThis, "globalThis")
 DEF(bigint, "bigint")
-#ifdef CONFIG_BIGNUM
-DEF(bigfloat, "bigfloat")
-DEF(bigdecimal, "bigdecimal")
-DEF(roundingMode, "roundingMode")
-DEF(maximumSignificantDigits, "maximumSignificantDigits")
-DEF(maximumFractionDigits, "maximumFractionDigits")
-#endif
-#ifdef CONFIG_ATOMICS
+DEF(minus_zero, "-0")
+DEF(Infinity, "Infinity")
+DEF(minus_Infinity, "-Infinity")
+DEF(NaN, "NaN")
+DEF(hasIndices, "hasIndices")
+DEF(ignoreCase, "ignoreCase")
+DEF(multiline, "multiline")
+DEF(dotAll, "dotAll")
+DEF(sticky, "sticky")
+DEF(unicodeSets, "unicodeSets")
+/* the following 3 atoms are only used with CONFIG_ATOMICS */
 DEF(not_equal, "not-equal")
 DEF(timed_out, "timed-out")
 DEF(ok, "ok")
-#endif
+/* */
 DEF(toJSON, "toJSON")
 /* class names */
 DEF(Object, "Object")
@@ -202,7 +208,7 @@ DEF(RegExp, "RegExp")
 DEF(ArrayBuffer, "ArrayBuffer")
 DEF(SharedArrayBuffer, "SharedArrayBuffer")
 /* must keep same order as class IDs for typed arrays */
-DEF(Uint8ClampedArray, "Uint8ClampedArray") 
+DEF(Uint8ClampedArray, "Uint8ClampedArray")
 DEF(Int8Array, "Int8Array")
 DEF(Uint8Array, "Uint8Array")
 DEF(Int16Array, "Int16Array")
@@ -211,17 +217,13 @@ DEF(Int32Array, "Int32Array")
 DEF(Uint32Array, "Uint32Array")
 DEF(BigInt64Array, "BigInt64Array")
 DEF(BigUint64Array, "BigUint64Array")
+DEF(Float16Array, "Float16Array")
 DEF(Float32Array, "Float32Array")
 DEF(Float64Array, "Float64Array")
 DEF(DataView, "DataView")
 DEF(BigInt, "BigInt")
-#ifdef CONFIG_BIGNUM
-DEF(BigFloat, "BigFloat")
-DEF(BigFloatEnv, "BigFloatEnv")
-DEF(BigDecimal, "BigDecimal")
-DEF(OperatorSet, "OperatorSet")
-DEF(Operators, "Operators")
-#endif
+DEF(WeakRef, "WeakRef")
+DEF(FinalizationRegistry, "FinalizationRegistry")
 DEF(Map, "Map")
 DEF(Set, "Set") /* Map + 1 */
 DEF(WeakMap, "WeakMap") /* Map + 2 */
@@ -264,8 +266,5 @@ DEF(Symbol_hasInstance, "Symbol.hasInstance")
 DEF(Symbol_species, "Symbol.species")
 DEF(Symbol_unscopables, "Symbol.unscopables")
 DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
-#ifdef CONFIG_BIGNUM
-DEF(Symbol_operatorSet, "Symbol.operatorSet")
-#endif
-    
+
 #endif /* DEF */
diff --git a/quickjs/quickjs-libc.c b/quickjs/quickjs-libc.c
index f0c61be66f..2387a45c1c 100644
--- a/quickjs/quickjs-libc.c
+++ b/quickjs/quickjs-libc.c
@@ -1,6 +1,6 @@
 /*
  * QuickJS C library
- * 
+ *
  * Copyright (c) 2017-2021 Fabrice Bellard
  * Copyright (c) 2017-2021 Charlie Gordon
  *
@@ -47,27 +47,27 @@
 #include <sys/ioctl.h>
 #include <sys/wait.h>
 
-#if defined(__APPLE__)
+#if defined(__FreeBSD__)
+__BEGIN_DECLS
+extern char **environ;
+__END_DECLS
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
 typedef sig_t sighandler_t;
+#endif
+
+#if defined(__APPLE__)
 #if !defined(environ)
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
 #endif
 #endif /* __APPLE__ */
 
-#if defined(__FreeBSD__)
-typedef sig_t sighandler_t;
-__BEGIN_DECLS
-extern char **environ;
-__END_DECLS
-#endif  /* __FreeBSD__ */
-
 #endif
 
-#if !defined(_WIN32)
-/* enable the os.Worker API. IT relies on POSIX threads */
+/* enable the os.Worker API. It relies on POSIX threads */
 #define USE_WORKER
-#endif
 
 #ifdef USE_WORKER
 #include <pthread.h>
@@ -78,6 +78,10 @@ __END_DECLS
 #include "list.h"
 #include "quickjs-libc.h"
 
+#if !defined(PATH_MAX)
+#define PATH_MAX 4096
+#endif
+
 /* TODO:
    - add socket calls
 */
@@ -96,7 +100,7 @@ typedef struct {
 
 typedef struct {
     struct list_head link;
-    BOOL has_object;
+    int timer_id;
     int64_t timeout;
     JSValue func;
 } JSOSTimer;
@@ -110,14 +114,22 @@ typedef struct {
     size_t sab_tab_len;
 } JSWorkerMessage;
 
+typedef struct JSWaker {
+#ifdef _WIN32
+    HANDLE handle;
+#else
+    int read_fd;
+    int write_fd;
+#endif
+} JSWaker;
+
 typedef struct {
     int ref_count;
 #ifdef USE_WORKER
     pthread_mutex_t mutex;
 #endif
     struct list_head msg_queue; /* list of JSWorkerMessage.link */
-    int read_fd;
-    int write_fd;
+    JSWaker waker;
 } JSWorkerMessagePipe;
 
 typedef struct {
@@ -126,12 +138,20 @@ typedef struct {
     JSValue on_message_func;
 } JSWorkerMessageHandler;
 
+typedef struct {
+    struct list_head link;
+    JSValue promise;
+    JSValue reason;
+} JSRejectedPromiseEntry;
+
 typedef struct JSThreadState {
     struct list_head os_rw_handlers; /* list of JSOSRWHandler.link */
     struct list_head os_signal_handlers; /* list JSOSSignalHandler.link */
     struct list_head os_timers; /* list of JSOSTimer.link */
     struct list_head port_list; /* list of JSWorkerMessageHandler.link */
+    struct list_head rejected_promise_list; /* list of JSRejectedPromiseEntry.link */
     int eval_script_recurse; /* only used in the main thread */
+    int next_timer_id; /* for setTimeout() */
     /* not used in the main thread */
     JSWorkerMessagePipe *recv_pipe, *send_pipe;
 } JSThreadState;
@@ -149,6 +169,7 @@ static BOOL my_isdigit(int c)
     return (c >= '0' && c <= '9');
 }
 
+/* XXX: use 'o' and 'O' for object using JS_PrintValue() ? */
 static JSValue js_printf_internal(JSContext *ctx,
                                   int argc, JSValueConst *argv, FILE *fp)
 {
@@ -156,7 +177,7 @@ static JSValue js_printf_internal(JSContext *ctx,
     uint8_t cbuf[UTF8_CHAR_LEN_MAX+1];
     JSValue res;
     DynBuf dbuf;
-    const char *fmt_str;
+    const char *fmt_str = NULL;
     const uint8_t *fmt, *fmt_end;
     const uint8_t *p;
     char *q;
@@ -187,7 +208,7 @@ static JSValue js_printf_internal(JSContext *ctx,
                 break;
             q = fmtbuf;
             *q++ = *fmt++;  /* copy '%' */
-            
+
             /* flags */
             for(;;) {
                 c = *fmt;
@@ -241,14 +262,14 @@ static JSValue js_printf_internal(JSContext *ctx,
             if (*fmt == 'l') {
                 mod = *fmt++;
             }
-            
+
             /* type */
             c = *fmt++;
             if (q >= fmtbuf + sizeof(fmtbuf) - 1)
                 goto invalid;
             *q++ = c;
             *q = '\0';
-            
+
             switch (c) {
             case 'c':
                 if (i >= argc)
@@ -257,7 +278,7 @@ static JSValue js_printf_internal(JSContext *ctx,
                     string_arg = JS_ToCString(ctx, argv[i++]);
                     if (!string_arg)
                         goto fail;
-                    int32_arg = unicode_from_utf8((uint8_t *)string_arg, UTF8_CHAR_LEN_MAX, &p);
+                    int32_arg = unicode_from_utf8((const uint8_t *)string_arg, UTF8_CHAR_LEN_MAX, &p);
                     JS_FreeCString(ctx, string_arg);
                 } else {
                     if (JS_ToInt32(ctx, &int32_arg, argv[i++]))
@@ -270,7 +291,7 @@ static JSValue js_printf_internal(JSContext *ctx,
                 len = unicode_to_utf8(cbuf, int32_arg);
                 dbuf_put(&dbuf, cbuf, len);
                 break;
-                
+
             case 'd':
             case 'i':
             case 'o':
@@ -315,7 +336,7 @@ static JSValue js_printf_internal(JSContext *ctx,
                 dbuf_printf_fun(&dbuf, fmtbuf, string_arg);
                 JS_FreeCString(ctx, string_arg);
                 break;
-                
+
             case 'e':
             case 'f':
             case 'g':
@@ -330,11 +351,11 @@ static JSValue js_printf_internal(JSContext *ctx,
                     goto fail;
                 dbuf_printf_fun(&dbuf, fmtbuf, double_arg);
                 break;
-                
+
             case '%':
                 dbuf_putc(&dbuf, '%');
                 break;
-                
+
             default:
                 /* XXX: should support an extension mechanism */
             invalid:
@@ -361,6 +382,7 @@ static JSValue js_printf_internal(JSContext *ctx,
     return res;
 
 fail:
+    JS_FreeCString(ctx, fmt_str);
     dbuf_free(&dbuf);
     return JS_EXCEPTION;
 }
@@ -371,7 +393,7 @@ uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
     uint8_t *buf;
     size_t buf_len;
     long lret;
-    
+
     f = fopen(filename, "rb");
     if (!f)
         return NULL;
@@ -418,7 +440,7 @@ static JSValue js_loadScript(JSContext *ctx, JSValueConst this_val,
     const char *filename;
     JSValue ret;
     size_t buf_len;
-    
+
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         return JS_EXCEPTION;
@@ -443,7 +465,7 @@ static JSValue js_std_loadFile(JSContext *ctx, JSValueConst this_val,
     const char *filename;
     JSValue ret;
     size_t buf_len;
-    
+
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         return JS_EXCEPTION;
@@ -475,7 +497,7 @@ static JSModuleDef *js_module_loader_so(JSContext *ctx,
     void *hd;
     JSInitModuleFunc *init;
     char *filename;
-    
+
     if (!strchr(module_name, '/')) {
         /* must add a '/' so that the DLL is not searched in the
            system library paths */
@@ -487,7 +509,7 @@ static JSModuleDef *js_module_loader_so(JSContext *ctx,
     } else {
         filename = (char *)module_name;
     }
-    
+
     /* C module */
     hd = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
     if (filename != module_name)
@@ -526,7 +548,7 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
     JSValue meta_obj;
     JSAtom module_name_atom;
     const char *module_name;
-    
+
     assert(JS_VALUE_GET_TAG(func_val) == JS_TAG_MODULE);
     m = JS_VALUE_GET_PTR(func_val);
 
@@ -557,7 +579,7 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
         pstrcpy(buf, sizeof(buf), module_name);
     }
     JS_FreeCString(ctx, module_name);
-    
+
     meta_obj = JS_GetImportMeta(ctx, m);
     if (JS_IsException(meta_obj))
         return -1;
@@ -571,36 +593,138 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
     return 0;
 }
 
-JSModuleDef *js_module_loader(JSContext *ctx,
-                              const char *module_name, void *opaque)
+static int json_module_init(JSContext *ctx, JSModuleDef *m)
+{
+    JSValue val;
+    val = JS_GetModulePrivateValue(ctx, m);
+    JS_SetModuleExport(ctx, m, "default", val);
+    return 0;
+}
+
+static JSModuleDef *create_json_module(JSContext *ctx, const char *module_name, JSValue val)
 {
     JSModuleDef *m;
+    m = JS_NewCModule(ctx, module_name, json_module_init);
+    if (!m) {
+        JS_FreeValue(ctx, val);
+        return NULL;
+    }
+    /* only export the "default" symbol which will contain the JSON object */
+    JS_AddModuleExport(ctx, m, "default");
+    JS_SetModulePrivateValue(ctx, m, val);
+    return m;
+}
+
+/* in order to conform with the specification, only the keys should be
+   tested and not the associated values. */
+int js_module_check_attributes(JSContext *ctx, void *opaque,
+                               JSValueConst attributes)
+{
+    JSPropertyEnum *tab;
+    uint32_t i, len;
+    int ret;
+    const char *cstr;
+    size_t cstr_len;
+    
+    if (JS_GetOwnPropertyNames(ctx, &tab, &len, attributes, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK))
+        return -1;
+    ret = 0;
+    for(i = 0; i < len; i++) {
+        cstr = JS_AtomToCStringLen(ctx, &cstr_len, tab[i].atom);
+        if (!cstr) {
+            ret = -1;
+            break;
+        }
+        if (!(cstr_len == 4 && !memcmp(cstr, "type", cstr_len))) {
+            JS_ThrowTypeError(ctx, "import attribute '%s' is not supported", cstr);
+            ret = -1;
+        }
+        JS_FreeCString(ctx, cstr);
+        if (ret)
+            break;
+    }
+    JS_FreePropertyEnum(ctx, tab, len);
+    return ret;
+}
+
+/* return > 0 if the attributes indicate a JSON module */
+int js_module_test_json(JSContext *ctx, JSValueConst attributes)
+{
+    JSValue str;
+    const char *cstr;
+    size_t len;
+    BOOL res;
+
+    if (JS_IsUndefined(attributes))
+        return FALSE;
+    str = JS_GetPropertyStr(ctx, attributes, "type");
+    if (!JS_IsString(str))
+        return FALSE;
+    cstr = JS_ToCStringLen(ctx, &len, str);
+    JS_FreeValue(ctx, str);
+    if (!cstr)
+        return FALSE;
+    /* XXX: raise an error if unknown type ? */
+    if (len == 4 && !memcmp(cstr, "json", len)) {
+        res = 1;
+    } else if (len == 5 && !memcmp(cstr, "json5", len)) {
+        res = 2;
+    } else {
+        res = 0;
+    }
+    JS_FreeCString(ctx, cstr);
+    return res;
+}
 
+JSModuleDef *js_module_loader(JSContext *ctx,
+                              const char *module_name, void *opaque,
+                              JSValueConst attributes)
+{
+    JSModuleDef *m;
+    int res;
+    
     if (has_suffix(module_name, ".so")) {
         m = js_module_loader_so(ctx, module_name);
     } else {
         size_t buf_len;
         uint8_t *buf;
-        JSValue func_val;
-    
+
         buf = js_load_file(ctx, &buf_len, module_name);
         if (!buf) {
             JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
                                    module_name);
             return NULL;
         }
-        
-        /* compile the module */
-        func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
-                           JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-        js_free(ctx, buf);
-        if (JS_IsException(func_val))
-            return NULL;
-        /* XXX: could propagate the exception */
-        js_module_set_import_meta(ctx, func_val, TRUE, FALSE);
-        /* the module is already referenced, so we must free it */
-        m = JS_VALUE_GET_PTR(func_val);
-        JS_FreeValue(ctx, func_val);
+        res = js_module_test_json(ctx, attributes);
+        if (has_suffix(module_name, ".json") || res > 0) {
+            /* compile as JSON or JSON5 depending on "type" */
+            JSValue val;
+            int flags;
+            if (res == 2)
+                flags = JS_PARSE_JSON_EXT;
+            else
+                flags = 0;
+            val = JS_ParseJSON2(ctx, (char *)buf, buf_len, module_name, flags);
+            js_free(ctx, buf);
+            if (JS_IsException(val))
+                return NULL;
+            m = create_json_module(ctx, module_name, val);
+            if (!m)
+                return NULL;
+        } else {
+            JSValue func_val;
+            /* compile the module */
+            func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
+                               JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+            js_free(ctx, buf);
+            if (JS_IsException(func_val))
+                return NULL;
+            /* XXX: could propagate the exception */
+            js_module_set_import_meta(ctx, func_val, TRUE, FALSE);
+            /* the module is already referenced, so we must free it */
+            m = JS_VALUE_GET_PTR(func_val);
+            JS_FreeValue(ctx, func_val);
+        }
     }
     return m;
 }
@@ -758,13 +882,17 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
     JSValue ret;
     JSValueConst options_obj;
     BOOL backtrace_barrier = FALSE;
+    BOOL is_async = FALSE;
     int flags;
-    
+
     if (argc >= 2) {
         options_obj = argv[1];
         if (get_bool_option(ctx, &backtrace_barrier, options_obj,
                             "backtrace_barrier"))
             return JS_EXCEPTION;
+        if (get_bool_option(ctx, &is_async, options_obj,
+                            "async"))
+            return JS_EXCEPTION;
     }
 
     str = JS_ToCStringLen(ctx, &len, argv[0]);
@@ -774,9 +902,11 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
         /* install the interrupt handler */
         JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
     }
-    flags = JS_EVAL_TYPE_GLOBAL; 
+    flags = JS_EVAL_TYPE_GLOBAL;
     if (backtrace_barrier)
         flags |= JS_EVAL_FLAG_BACKTRACE_BARRIER;
+    if (is_async)
+        flags |= JS_EVAL_FLAG_ASYNC;
     ret = JS_Eval(ctx, str, len, "<evalScript>", flags);
     JS_FreeCString(ctx, str);
     if (!ts->recv_pipe && --ts->eval_script_recurse == 0) {
@@ -786,7 +916,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
         /* convert the uncatchable "interrupted" error into a normal error
            so that it can be caught by the REPL */
         if (JS_IsException(ret))
-            JS_ResetUncatchableError(ctx);
+            JS_SetUncatchableException(ctx, FALSE);
     }
     return ret;
 }
@@ -878,7 +1008,7 @@ static JSValue js_std_open(JSContext *ctx, JSValueConst this_val,
     const char *filename, *mode = NULL;
     FILE *f;
     int err;
-    
+
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         goto fail;
@@ -914,7 +1044,7 @@ static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
     const char *filename, *mode = NULL;
     FILE *f;
     int err;
-    
+
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         goto fail;
@@ -1028,7 +1158,7 @@ static JSValue js_std_file_puts(JSContext *ctx, JSValueConst this_val,
         if (!f)
             return JS_EXCEPTION;
     }
-    
+
     for(i = 0; i < argc; i++) {
         str = JS_ToCStringLen(ctx, &len, argv[i]);
         if (!str)
@@ -1065,6 +1195,19 @@ static JSValue js_std_file_printf(JSContext *ctx, JSValueConst this_val,
     return js_printf_internal(ctx, argc, argv, f);
 }
 
+static void js_print_value_write(void *opaque, const char *buf, size_t len)
+{
+    FILE *fo = opaque;
+    fwrite(buf, 1, len, fo);
+}
+
+static JSValue js_std_file_printObject(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JS_PrintValue(ctx, js_print_value_write, stdout, argv[0], NULL);
+    return JS_UNDEFINED;
+}
+
 static JSValue js_std_file_flush(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
@@ -1082,7 +1225,7 @@ static JSValue js_std_file_tell(JSContext *ctx, JSValueConst this_val,
     int64_t pos;
     if (!f)
         return JS_EXCEPTION;
-#if defined(__linux__)
+#if defined(__linux__) || defined(__GLIBC__)
     pos = ftello(f);
 #else
     pos = ftell(f);
@@ -1105,7 +1248,7 @@ static JSValue js_std_file_seek(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &whence, argv[1]))
         return JS_EXCEPTION;
-#if defined(__linux__)
+#if defined(__linux__) || defined(__GLIBC__)
     ret = fseeko(f, pos, whence);
 #else
     ret = fseek(f, pos, whence);
@@ -1159,7 +1302,7 @@ static JSValue js_std_file_read_write(JSContext *ctx, JSValueConst this_val,
     uint64_t pos, len;
     size_t size, ret;
     uint8_t *buf;
-    
+
     if (!f)
         return JS_EXCEPTION;
     if (JS_ToIndex(ctx, &pos, argv[1]))
@@ -1186,7 +1329,7 @@ static JSValue js_std_file_getline(JSContext *ctx, JSValueConst this_val,
     int c;
     DynBuf dbuf;
     JSValue obj;
-    
+
     if (!f)
         return JS_EXCEPTION;
 
@@ -1225,7 +1368,7 @@ static JSValue js_std_file_readAsString(JSContext *ctx, JSValueConst this_val,
     uint64_t max_size64;
     size_t max_size;
     JSValueConst max_size_val;
-    
+
     if (!f)
         return JS_EXCEPTION;
 
@@ -1281,7 +1424,7 @@ static JSValue js_std_file_putByte(JSContext *ctx, JSValueConst this_val,
 
 /* urlGet */
 
-#define URL_GET_PROGRAM "curl -s -i"
+#define URL_GET_PROGRAM "curl -s -i --"
 #define URL_GET_BUF_SIZE 4096
 
 static int http_get_header_line(FILE *f, char *buf, size_t buf_size,
@@ -1289,7 +1432,7 @@ static int http_get_header_line(FILE *f, char *buf, size_t buf_size,
 {
     int c;
     char *p;
-    
+
     p = buf;
     for(;;) {
         c = fgetc(f);
@@ -1325,21 +1468,21 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     DynBuf cmd_buf;
     DynBuf data_buf_s, *data_buf = &data_buf_s;
     DynBuf header_buf_s, *header_buf = &header_buf_s;
-    char *buf; 
+    char *buf;
     size_t i, len;
-    int c, status;
+    int status;
     JSValue response = JS_UNDEFINED, ret_obj;
     JSValueConst options_obj;
     FILE *f;
     BOOL binary_flag, full_flag;
-    
+
     url = JS_ToCString(ctx, argv[0]);
     if (!url)
         return JS_EXCEPTION;
-    
+
     binary_flag = FALSE;
     full_flag = FALSE;
-    
+
     if (argc >= 2) {
         options_obj = argv[1];
 
@@ -1352,18 +1495,27 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
             return JS_EXCEPTION;
         }
     }
-    
+
     js_std_dbuf_init(ctx, &cmd_buf);
-    dbuf_printf(&cmd_buf, "%s ''", URL_GET_PROGRAM);
-    len = strlen(url);
-    for(i = 0; i < len; i++) {
-        c = url[i];
-        if (c == '\'' || c == '\\')
+    dbuf_printf(&cmd_buf, "%s '", URL_GET_PROGRAM);
+    for(i = 0; url[i] != '\0'; i++) {
+        unsigned char c = url[i];
+        switch (c) {
+        case '\'':
+            /* shell single quoted string does not support \' */
+            dbuf_putstr(&cmd_buf, "'\\''");
+            break;
+        case '[': case ']': case '{': case '}': case '\\':
+            /* prevent interpretation by curl as range or set specification */
             dbuf_putc(&cmd_buf, '\\');
-        dbuf_putc(&cmd_buf, c);
+            /* FALLTHROUGH */
+        default:
+            dbuf_putc(&cmd_buf, c);
+            break;
+        }
     }
     JS_FreeCString(ctx, url);
-    dbuf_putstr(&cmd_buf, "''");
+    dbuf_putstr(&cmd_buf, "'");
     dbuf_putc(&cmd_buf, '\0');
     if (dbuf_error(&cmd_buf)) {
         dbuf_free(&cmd_buf);
@@ -1378,7 +1530,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
 
     js_std_dbuf_init(ctx, data_buf);
     js_std_dbuf_init(ctx, header_buf);
-    
+
     buf = js_malloc(ctx, URL_GET_BUF_SIZE);
     if (!buf)
         goto fail;
@@ -1392,7 +1544,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
     if (!full_flag && !(status >= 200 && status <= 299)) {
         goto bad_header;
     }
-    
+
     /* wait until there is an empty line */
     for(;;) {
         if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, header_buf) < 0) {
@@ -1468,7 +1620,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
 static JSClassDef js_std_file_class = {
     "FILE",
     .finalizer = js_std_file_finalizer,
-}; 
+};
 
 static const JSCFunctionListEntry js_std_error_props[] = {
     /* various errno values */
@@ -1500,7 +1652,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
     JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
     JS_CFUNC_DEF("parseExtJSON", 1, js_std_parseExtJSON ),
-    
+
     /* FILE I/O */
     JS_CFUNC_DEF("open", 2, js_std_open ),
     JS_CFUNC_DEF("popen", 2, js_std_popen ),
@@ -1513,8 +1665,9 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_PROP_INT32_DEF("SEEK_CUR", SEEK_CUR, JS_PROP_CONFIGURABLE ),
     JS_PROP_INT32_DEF("SEEK_END", SEEK_END, JS_PROP_CONFIGURABLE ),
     JS_OBJECT_DEF("Error", js_std_error_props, countof(js_std_error_props), JS_PROP_CONFIGURABLE),
+    JS_CFUNC_DEF("__printObject", 1, js_std_file_printObject ),
 };
-    
+
 static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
     JS_CFUNC_DEF("close", 0, js_std_file_close ),
     JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 1 ),
@@ -1539,7 +1692,7 @@ static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
 static int js_std_init(JSContext *ctx, JSModuleDef *m)
 {
     JSValue proto;
-    
+
     /* FILE class */
     /* the class ID is created once */
     JS_NewClassID(&js_std_file_class_id);
@@ -1620,7 +1773,7 @@ static JSValue js_os_seek(JSContext *ctx, JSValueConst this_val,
     int fd, whence;
     int64_t pos, ret;
     BOOL is_bigint;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     is_bigint = JS_IsBigInt(ctx, argv[1]);
@@ -1638,14 +1791,14 @@ static JSValue js_os_seek(JSContext *ctx, JSValueConst this_val,
 }
 
 static JSValue js_os_read_write(JSContext *ctx, JSValueConst this_val,
-                                      int argc, JSValueConst *argv, int magic)
+                                int argc, JSValueConst *argv, int magic)
 {
     int fd;
     uint64_t pos, len;
     size_t size;
     ssize_t ret;
     uint8_t *buf;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     if (JS_ToIndex(ctx, &pos, argv[2]))
@@ -1670,7 +1823,7 @@ static JSValue js_os_isatty(JSContext *ctx, JSValueConst this_val,
     int fd;
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    return JS_NewBool(ctx, (isatty(fd) != 0));
+    return JS_NewBool(ctx, isatty(fd));
 }
 
 #if defined(_WIN32)
@@ -1685,7 +1838,7 @@ static JSValue js_os_ttyGetWinSize(JSContext *ctx, JSValueConst this_val,
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     handle = (HANDLE)_get_osfhandle(fd);
-    
+
     if (!GetConsoleScreenBufferInfo(handle, &info))
         return JS_NULL;
     obj = JS_NewArray(ctx);
@@ -1724,7 +1877,7 @@ static JSValue js_os_ttyGetWinSize(JSContext *ctx, JSValueConst this_val,
     int fd;
     struct winsize ws;
     JSValue obj;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     if (ioctl(fd, TIOCGWINSZ, &ws) == 0 &&
@@ -1753,10 +1906,10 @@ static JSValue js_os_ttySetRaw(JSContext *ctx, JSValueConst this_val,
 {
     struct termios tty;
     int fd;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
-    
+
     memset(&tty, 0, sizeof(tty));
     tcgetattr(fd, &tty);
     oldtty = tty;
@@ -1779,11 +1932,11 @@ static JSValue js_os_ttySetRaw(JSContext *ctx, JSValueConst this_val,
 #endif /* !_WIN32 */
 
 static JSValue js_os_remove(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv)
+                            int argc, JSValueConst *argv)
 {
     const char *filename;
     int ret;
-    
+
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
         return JS_EXCEPTION;
@@ -1809,7 +1962,7 @@ static JSValue js_os_rename(JSContext *ctx, JSValueConst this_val,
 {
     const char *oldpath, *newpath;
     int ret;
-    
+
     oldpath = JS_ToCString(ctx, argv[0]);
     if (!oldpath)
         return JS_EXCEPTION;
@@ -1861,7 +2014,7 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
     JSOSRWHandler *rh;
     int fd;
     JSValueConst func;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     func = argv[1];
@@ -1935,7 +2088,7 @@ static JSValue js_os_signal(JSContext *ctx, JSValueConst this_val,
 
     if (!is_main_thread(rt))
         return JS_ThrowTypeError(ctx, "signal handler can only be set in the main thread");
-    
+
     if (JS_ToUint32(ctx, &sig_num, argv[0]))
         return JS_EXCEPTION;
     if (sig_num >= 64)
@@ -1977,6 +2130,13 @@ static int64_t get_time_ms(void)
     clock_gettime(CLOCK_MONOTONIC, &ts);
     return (uint64_t)ts.tv_sec * 1000 + (ts.tv_nsec / 1000000);
 }
+
+static int64_t get_time_ns(void)
+{
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec;
+}
 #else
 /* more portable, but does not work if the date is updated */
 static int64_t get_time_ms(void)
@@ -1985,43 +2145,28 @@ static int64_t get_time_ms(void)
     gettimeofday(&tv, NULL);
     return (int64_t)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
 }
+
+static int64_t get_time_ns(void)
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (int64_t)tv.tv_sec * 1000000000 + (tv.tv_usec * 1000);
+}
 #endif
 
-static void unlink_timer(JSRuntime *rt, JSOSTimer *th)
+static JSValue js_os_now(JSContext *ctx, JSValue this_val,
+                         int argc, JSValue *argv)
 {
-    if (th->link.prev) {
-        list_del(&th->link);
-        th->link.prev = th->link.next = NULL;
-    }
+    return JS_NewFloat64(ctx, (double)get_time_ns() / 1e6);
 }
 
 static void free_timer(JSRuntime *rt, JSOSTimer *th)
 {
+    list_del(&th->link);
     JS_FreeValueRT(rt, th->func);
     js_free_rt(rt, th);
 }
 
-static JSClassID js_os_timer_class_id;
-
-static void js_os_timer_finalizer(JSRuntime *rt, JSValue val)
-{
-    JSOSTimer *th = JS_GetOpaque(val, js_os_timer_class_id);
-    if (th) {
-        th->has_object = FALSE;
-        if (!th->link.prev)
-            free_timer(rt, th);
-    }
-}
-
-static void js_os_timer_mark(JSRuntime *rt, JSValueConst val,
-                             JS_MarkFunc *mark_func)
-{
-    JSOSTimer *th = JS_GetOpaque(val, js_os_timer_class_id);
-    if (th) {
-        JS_MarkValue(rt, th->func, mark_func);
-    }
-}
-
 static JSValue js_os_setTimeout(JSContext *ctx, JSValueConst this_val,
                                 int argc, JSValueConst *argv)
 {
@@ -2030,44 +2175,87 @@ static JSValue js_os_setTimeout(JSContext *ctx, JSValueConst this_val,
     int64_t delay;
     JSValueConst func;
     JSOSTimer *th;
-    JSValue obj;
 
     func = argv[0];
     if (!JS_IsFunction(ctx, func))
         return JS_ThrowTypeError(ctx, "not a function");
     if (JS_ToInt64(ctx, &delay, argv[1]))
         return JS_EXCEPTION;
-    obj = JS_NewObjectClass(ctx, js_os_timer_class_id);
-    if (JS_IsException(obj))
-        return obj;
     th = js_mallocz(ctx, sizeof(*th));
-    if (!th) {
-        JS_FreeValue(ctx, obj);
+    if (!th)
         return JS_EXCEPTION;
-    }
-    th->has_object = TRUE;
+    th->timer_id = ts->next_timer_id;
+    if (ts->next_timer_id == INT32_MAX)
+        ts->next_timer_id = 1;
+    else
+        ts->next_timer_id++;
     th->timeout = get_time_ms() + delay;
     th->func = JS_DupValue(ctx, func);
     list_add_tail(&th->link, &ts->os_timers);
-    JS_SetOpaque(obj, th);
-    return obj;
+    return JS_NewInt32(ctx, th->timer_id);
+}
+
+static JSOSTimer *find_timer_by_id(JSThreadState *ts, int timer_id)
+{
+    struct list_head *el;
+    if (timer_id <= 0)
+        return NULL;
+    list_for_each(el, &ts->os_timers) {
+        JSOSTimer *th = list_entry(el, JSOSTimer, link);
+        if (th->timer_id == timer_id)
+            return th;
+    }
+    return NULL;
 }
 
 static JSValue js_os_clearTimeout(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv)
 {
-    JSOSTimer *th = JS_GetOpaque2(ctx, argv[0], js_os_timer_class_id);
-    if (!th)
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    JSOSTimer *th;
+    int timer_id;
+
+    if (JS_ToInt32(ctx, &timer_id, argv[0]))
         return JS_EXCEPTION;
-    unlink_timer(JS_GetRuntime(ctx), th);
+    th = find_timer_by_id(ts, timer_id);
+    if (!th)
+        return JS_UNDEFINED;
+    free_timer(rt, th);
     return JS_UNDEFINED;
 }
 
-static JSClassDef js_os_timer_class = {
-    "OSTimer",
-    .finalizer = js_os_timer_finalizer,
-    .gc_mark = js_os_timer_mark,
-}; 
+/* return a promise */
+static JSValue js_os_sleepAsync(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv)
+{
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    int64_t delay;
+    JSOSTimer *th;
+    JSValue promise, resolving_funcs[2];
+
+    if (JS_ToInt64(ctx, &delay, argv[0]))
+        return JS_EXCEPTION;
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return JS_EXCEPTION;
+
+    th = js_mallocz(ctx, sizeof(*th));
+    if (!th) {
+        JS_FreeValue(ctx, promise);
+        JS_FreeValue(ctx, resolving_funcs[0]);
+        JS_FreeValue(ctx, resolving_funcs[1]);
+        return JS_EXCEPTION;
+    }
+    th->timer_id = -1;
+    th->timeout = get_time_ms() + delay;
+    th->func = JS_DupValue(ctx, resolving_funcs[0]);
+    list_add_tail(&th->link, &ts->os_timers);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    return promise;
+}
 
 static void call_handler(JSContext *ctx, JSValueConst func)
 {
@@ -2082,84 +2270,81 @@ static void call_handler(JSContext *ctx, JSValueConst func)
     JS_FreeValue(ctx, ret);
 }
 
-#if defined(_WIN32)
+#ifdef USE_WORKER
 
-static int js_os_poll(JSContext *ctx)
+#ifdef _WIN32
+
+static int js_waker_init(JSWaker *w)
 {
-    JSRuntime *rt = JS_GetRuntime(ctx);
-    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
-    int min_delay, console_fd;
-    int64_t cur_time, delay;
-    JSOSRWHandler *rh;
-    struct list_head *el;
-    
-    /* XXX: handle signals if useful */
+    w->handle = CreateEvent(NULL, TRUE, FALSE, NULL);
+    return w->handle ? 0 : -1;
+}
 
-    if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers))
-        return -1; /* no more events */
-    
-    /* XXX: only timers and basic console input are supported */
-    if (!list_empty(&ts->os_timers)) {
-        cur_time = get_time_ms();
-        min_delay = 10000;
-        list_for_each(el, &ts->os_timers) {
-            JSOSTimer *th = list_entry(el, JSOSTimer, link);
-            delay = th->timeout - cur_time;
-            if (delay <= 0) {
-                JSValue func;
-                /* the timer expired */
-                func = th->func;
-                th->func = JS_UNDEFINED;
-                unlink_timer(rt, th);
-                if (!th->has_object)
-                    free_timer(rt, th);
-                call_handler(ctx, func);
-                JS_FreeValue(ctx, func);
-                return 0;
-            } else if (delay < min_delay) {
-                min_delay = delay;
-            }
-        }
-    } else {
-        min_delay = -1;
-    }
+static void js_waker_signal(JSWaker *w)
+{
+    SetEvent(w->handle);
+}
 
-    console_fd = -1;
-    list_for_each(el, &ts->os_rw_handlers) {
-        rh = list_entry(el, JSOSRWHandler, link);
-        if (rh->fd == 0 && !JS_IsNull(rh->rw_func[0])) {
-            console_fd = rh->fd;
+static void js_waker_clear(JSWaker *w)
+{
+    ResetEvent(w->handle);
+}
+
+static void js_waker_close(JSWaker *w)
+{
+    CloseHandle(w->handle);
+    w->handle = INVALID_HANDLE_VALUE;
+}
+
+#else // !_WIN32
+
+static int js_waker_init(JSWaker *w)
+{
+    int fds[2];
+
+    if (pipe(fds) < 0)
+        return -1;
+    w->read_fd = fds[0];
+    w->write_fd = fds[1];
+    return 0;
+}
+
+static void js_waker_signal(JSWaker *w)
+{
+    int ret;
+
+    for(;;) {
+        ret = write(w->write_fd, "", 1);
+        if (ret == 1)
+            break;
+        if (ret < 0 && (errno != EAGAIN || errno != EINTR))
             break;
-        }
     }
+}
 
-    if (console_fd >= 0) {
-        DWORD ti, ret;
-        HANDLE handle;
-        if (min_delay == -1)
-            ti = INFINITE;
-        else
-            ti = min_delay;
-        handle = (HANDLE)_get_osfhandle(console_fd);
-        ret = WaitForSingleObject(handle, ti);
-        if (ret == WAIT_OBJECT_0) {
-            list_for_each(el, &ts->os_rw_handlers) {
-                rh = list_entry(el, JSOSRWHandler, link);
-                if (rh->fd == console_fd && !JS_IsNull(rh->rw_func[0])) {
-                    call_handler(ctx, rh->rw_func[0]);
-                    /* must stop because the list may have been modified */
-                    break;
-                }
-            }
-        }
-    } else {
-        Sleep(min_delay);
+static void js_waker_clear(JSWaker *w)
+{
+    uint8_t buf[16];
+    int ret;
+
+    for(;;) {
+        ret = read(w->read_fd, buf, sizeof(buf));
+        if (ret >= 0)
+            break;
+        if (errno != EAGAIN && errno != EINTR)
+            break;
     }
-    return 0;
 }
-#else
 
-#ifdef USE_WORKER
+static void js_waker_close(JSWaker *w)
+{
+    close(w->read_fd);
+    close(w->write_fd);
+    w->read_fd = -1;
+    w->write_fd = -1;
+}
+
+#endif // _WIN32
 
 static void js_free_message(JSWorkerMessage *msg);
 
@@ -2172,7 +2357,7 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
     struct list_head *el;
     JSWorkerMessage *msg;
     JSValue obj, data_obj, func, retval;
-    
+
     pthread_mutex_lock(&ps->mutex);
     if (!list_empty(&ps->msg_queue)) {
         el = ps->msg_queue.next;
@@ -2181,17 +2366,8 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
         /* remove the message from the queue */
         list_del(&msg->link);
 
-        if (list_empty(&ps->msg_queue)) {
-            uint8_t buf[16];
-            int ret;
-            for(;;) {
-                ret = read(ps->read_fd, buf, sizeof(buf));
-                if (ret >= 0)
-                    break;
-                if (errno != EAGAIN && errno != EINTR)
-                    break;
-            }
-        }
+        if (list_empty(&ps->msg_queue))
+            js_waker_clear(&ps->waker);
 
         pthread_mutex_unlock(&ps->mutex);
 
@@ -2199,7 +2375,7 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
                                  JS_READ_OBJ_SAB | JS_READ_OBJ_REFERENCE);
 
         js_free_message(msg);
-        
+
         if (JS_IsException(data_obj))
             goto fail;
         obj = JS_NewObject(ctx);
@@ -2234,7 +2410,104 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
 {
     return 0;
 }
-#endif
+#endif /* !USE_WORKER */
+
+#if defined(_WIN32)
+
+static int js_os_poll(JSContext *ctx)
+{
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    int min_delay, count;
+    int64_t cur_time, delay;
+    JSOSRWHandler *rh;
+    struct list_head *el;
+    HANDLE handles[MAXIMUM_WAIT_OBJECTS]; // 64
+
+    /* XXX: handle signals if useful */
+
+    if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) &&
+        list_empty(&ts->port_list)) {
+        return -1; /* no more events */
+    }
+    
+    if (!list_empty(&ts->os_timers)) {
+        cur_time = get_time_ms();
+        min_delay = 10000;
+        list_for_each(el, &ts->os_timers) {
+            JSOSTimer *th = list_entry(el, JSOSTimer, link);
+            delay = th->timeout - cur_time;
+            if (delay <= 0) {
+                JSValue func;
+                /* the timer expired */
+                func = th->func;
+                th->func = JS_UNDEFINED;
+                free_timer(rt, th);
+                call_handler(ctx, func);
+                JS_FreeValue(ctx, func);
+                return 0;
+            } else if (delay < min_delay) {
+                min_delay = delay;
+            }
+        }
+    } else {
+        min_delay = -1;
+    }
+
+    count = 0;
+    list_for_each(el, &ts->os_rw_handlers) {
+        rh = list_entry(el, JSOSRWHandler, link);
+        if (rh->fd == 0 && !JS_IsNull(rh->rw_func[0])) {
+            handles[count++] = (HANDLE)_get_osfhandle(rh->fd); // stdin
+            if (count == (int)countof(handles))
+                break;
+        }
+    }
+
+    list_for_each(el, &ts->port_list) {
+        JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
+        if (JS_IsNull(port->on_message_func))
+            continue;
+        handles[count++] = port->recv_pipe->waker.handle;
+        if (count == (int)countof(handles))
+            break;
+    }
+
+    if (count > 0) {
+        DWORD ret, timeout = INFINITE;
+        if (min_delay != -1)
+            timeout = min_delay;
+        ret = WaitForMultipleObjects(count, handles, FALSE, timeout);
+
+        if (ret < count) {
+            list_for_each(el, &ts->os_rw_handlers) {
+                rh = list_entry(el, JSOSRWHandler, link);
+                if (rh->fd == 0 && !JS_IsNull(rh->rw_func[0])) {
+                    call_handler(ctx, rh->rw_func[0]);
+                    /* must stop because the list may have been modified */
+                    goto done;
+                }
+            }
+
+            list_for_each(el, &ts->port_list) {
+                JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
+                if (!JS_IsNull(port->on_message_func)) {
+                    JSWorkerMessagePipe *ps = port->recv_pipe;
+                    if (ps->waker.handle == handles[ret]) {
+                        if (handle_posted_message(rt, ctx, port))
+                            goto done;
+                    }
+                }
+            }
+        }
+    } else {
+        Sleep(min_delay);
+    }
+ done:
+    return 0;
+}
+
+#else
 
 static int js_os_poll(JSContext *ctx)
 {
@@ -2252,7 +2525,7 @@ static int js_os_poll(JSContext *ctx)
         unlikely(os_pending_signals != 0)) {
         JSOSSignalHandler *sh;
         uint64_t mask;
-        
+
         list_for_each(el, &ts->os_signal_handlers) {
             sh = list_entry(el, JSOSSignalHandler, link);
             mask = (uint64_t)1 << sh->sig_num;
@@ -2267,7 +2540,7 @@ static int js_os_poll(JSContext *ctx)
     if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) &&
         list_empty(&ts->port_list))
         return -1; /* no more events */
-    
+
     if (!list_empty(&ts->os_timers)) {
         cur_time = get_time_ms();
         min_delay = 10000;
@@ -2279,9 +2552,7 @@ static int js_os_poll(JSContext *ctx)
                 /* the timer expired */
                 func = th->func;
                 th->func = JS_UNDEFINED;
-                unlink_timer(rt, th);
-                if (!th->has_object)
-                    free_timer(rt, th);
+                free_timer(rt, th);
                 call_handler(ctx, func);
                 JS_FreeValue(ctx, func);
                 return 0;
@@ -2295,7 +2566,7 @@ static int js_os_poll(JSContext *ctx)
     } else {
         tvp = NULL;
     }
-    
+
     FD_ZERO(&rfds);
     FD_ZERO(&wfds);
     fd_max = -1;
@@ -2312,8 +2583,8 @@ static int js_os_poll(JSContext *ctx)
         JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
         if (!JS_IsNull(port->on_message_func)) {
             JSWorkerMessagePipe *ps = port->recv_pipe;
-            fd_max = max_int(fd_max, ps->read_fd);
-            FD_SET(ps->read_fd, &rfds);
+            fd_max = max_int(fd_max, ps->waker.read_fd);
+            FD_SET(ps->waker.read_fd, &rfds);
         }
     }
 
@@ -2339,14 +2610,14 @@ static int js_os_poll(JSContext *ctx)
             JSWorkerMessageHandler *port = list_entry(el, JSWorkerMessageHandler, link);
             if (!JS_IsNull(port->on_message_func)) {
                 JSWorkerMessagePipe *ps = port->recv_pipe;
-                if (FD_ISSET(ps->read_fd, &rfds)) {
+                if (FD_ISSET(ps->waker.read_fd, &rfds)) {
                     if (handle_posted_message(rt, ctx, port))
                         goto done;
                 }
             }
         }
     }
-    done:
+ done:
     return 0;
 }
 #endif /* !_WIN32 */
@@ -2381,7 +2652,7 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
 {
     char buf[PATH_MAX];
     int err;
-    
+
     if (!getcwd(buf, sizeof(buf))) {
         buf[0] = '\0';
         err = errno;
@@ -2410,7 +2681,7 @@ static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
 {
     int mode, ret;
     const char *path;
-    
+
     if (argc >= 2) {
         if (JS_ToInt32(ctx, &mode, argv[1]))
             return JS_EXCEPTION;
@@ -2440,7 +2711,7 @@ static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
     JSValue obj;
     int err;
     uint32_t len;
-    
+
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
@@ -2501,12 +2772,14 @@ static JSValue js_os_stat(JSContext *ctx, JSValueConst this_val,
     else
         res = stat(path, &st);
 #endif
+    if (res < 0)
+        err = errno;
+    else
+        err = 0;
     JS_FreeCString(ctx, path);
     if (res < 0) {
-        err = errno;
         obj = JS_NULL;
     } else {
-        err = 0;
         obj = JS_NewObject(ctx);
         if (JS_IsException(obj))
             return JS_EXCEPTION;
@@ -2588,7 +2861,7 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
     const char *path;
     int64_t atime, mtime;
     int ret;
-    
+
     if (JS_ToInt64(ctx, &atime, argv[1]))
         return JS_EXCEPTION;
     if (JS_ToInt64(ctx, &mtime, argv[2]))
@@ -2617,11 +2890,11 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
 
 /* sleep(delay_ms) */
 static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
-                          int argc, JSValueConst *argv)
+                           int argc, JSValueConst *argv)
 {
     int64_t delay;
     int ret;
-    
+
     if (JS_ToInt64(ctx, &delay, argv[0]))
         return JS_EXCEPTION;
     if (delay < 0)
@@ -2681,11 +2954,11 @@ static JSValue js_os_realpath(JSContext *ctx, JSValueConst this_val,
 
 #if !defined(_WIN32)
 static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
+                             int argc, JSValueConst *argv)
 {
     const char *target, *linkpath;
     int err;
-    
+
     target = JS_ToCString(ctx, argv[0]);
     if (!target)
         return JS_EXCEPTION;
@@ -2708,7 +2981,7 @@ static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
     char buf[PATH_MAX];
     int err;
     ssize_t res;
-    
+
     path = JS_ToCString(ctx, argv[0]);
     if (!path)
         return JS_EXCEPTION;
@@ -2732,7 +3005,7 @@ static char **build_envp(JSContext *ctx, JSValueConst obj)
     const char *key, *str;
     JSValue val;
     size_t key_len, str_len;
-    
+
     if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
                                JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
         return NULL;
@@ -2769,9 +3042,7 @@ static char **build_envp(JSContext *ctx, JSValueConst obj)
         JS_FreeCString(ctx, str);
     }
  done:
-    for(i = 0; i < len; i++)
-        JS_FreeAtom(ctx, tab[i].atom);
-    js_free(ctx, tab);
+    JS_FreePropertyEnum(ctx, tab, len);
     return envp;
  fail:
     if (envp) {
@@ -2790,7 +3061,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
     char buf[PATH_MAX];
     size_t filename_len, path_len;
     BOOL eacces_error;
-    
+
     filename_len = strlen(filename);
     if (filename_len == 0) {
         errno = ENOENT;
@@ -2798,7 +3069,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
     }
     if (strchr(filename, '/'))
         return execve(filename, argv, envp);
-    
+
     path = getenv("PATH");
     if (!path)
         path = (char *)"/bin:/usr/bin";
@@ -2820,7 +3091,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
         buf[path_len] = '/';
         memcpy(buf + path_len + 1, filename, filename_len);
         buf[path_len + 1 + filename_len] = '\0';
-        
+
         execve(buf, argv, envp);
 
         switch(errno) {
@@ -2853,7 +3124,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
     static const char *std_name[3] = { "stdin", "stdout", "stderr" };
     int std_fds[3];
     uint32_t uid = -1, gid = -1;
-    
+
     val = JS_GetPropertyStr(ctx, args, "length");
     if (JS_IsException(val))
         return JS_EXCEPTION;
@@ -2882,7 +3153,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
 
     for(i = 0; i < 3; i++)
         std_fds[i] = i;
-    
+
     /* get the options, if any */
     if (argc >= 2) {
         options = argv[1];
@@ -2891,7 +3162,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
             goto exception;
         if (get_bool_option(ctx, &use_path, options, "usePath"))
             goto exception;
-        
+
         val = JS_GetPropertyStr(ctx, options, "file");
         if (JS_IsException(val))
             goto exception;
@@ -2936,7 +3207,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
             if (!envp)
                 goto exception;
         }
-        
+
         val = JS_GetPropertyStr(ctx, options, "uid");
         if (JS_IsException(val))
             goto exception;
@@ -2965,7 +3236,6 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
     }
     if (pid == 0) {
         /* child */
-        int fd_max = sysconf(_SC_OPEN_MAX);
 
         /* remap the stdin/stdout/stderr handles if necessary */
         for(i = 0; i < 3; i++) {
@@ -2974,9 +3244,28 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
                     _exit(127);
             }
         }
-
-        for(i = 3; i < fd_max; i++)
-            close(i);
+#if defined(HAVE_CLOSEFROM)
+        /* closefrom() is available on many recent unix systems:
+           Linux with glibc 2.34+, Solaris 9+, FreeBSD 7.3+,
+           NetBSD 3.0+, OpenBSD 3.5+.
+           Linux with the musl libc and macOS don't have it.
+         */
+
+        closefrom(3);
+#else
+        {
+            /* Close the file handles manually, limit to 1024 to avoid
+               costly loop on linux Alpine where sysconf(_SC_OPEN_MAX)
+               returns a huge value 1048576.
+               Patch inspired by nicolas-duteil-nova. See also:
+               https://stackoverflow.com/questions/73229353/
+               https://stackoverflow.com/questions/899038/#918469
+             */
+            int fd_max = min_int(sysconf(_SC_OPEN_MAX), 1024);
+            for(i = 3; i < fd_max; i++)
+                close(i);
+        }
+#endif
         if (cwd) {
             if (chdir(cwd) < 0)
                 _exit(127);
@@ -3037,13 +3326,20 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
     goto done;
 }
 
+/* getpid() -> pid */
+static JSValue js_os_getpid(JSContext *ctx, JSValueConst this_val,
+                            int argc, JSValueConst *argv)
+{
+    return JS_NewInt32(ctx, getpid());
+}
+
 /* waitpid(pid, block) -> [pid, status] */
 static JSValue js_os_waitpid(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv)
 {
     int pid, status, options, ret;
     JSValue obj;
-    
+
     if (JS_ToInt32(ctx, &pid, argv[0]))
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &options, argv[1]))
@@ -3063,7 +3359,7 @@ static JSValue js_os_waitpid(JSContext *ctx, JSValueConst this_val,
     JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
                                  JS_PROP_C_W_E);
     return obj;
-}    
+}
 
 /* pipe() -> [read_fd, write_fd] or null if error */
 static JSValue js_os_pipe(JSContext *ctx, JSValueConst this_val,
@@ -3071,7 +3367,7 @@ static JSValue js_os_pipe(JSContext *ctx, JSValueConst this_val,
 {
     int pipe_fds[2], ret;
     JSValue obj;
-    
+
     ret = pipe(pipe_fds);
     if (ret < 0)
         return JS_NULL;
@@ -3090,7 +3386,7 @@ static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
                           int argc, JSValueConst *argv)
 {
     int pid, sig, ret;
-    
+
     if (JS_ToInt32(ctx, &pid, argv[0]))
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &sig, argv[1]))
@@ -3104,7 +3400,7 @@ static JSValue js_os_dup(JSContext *ctx, JSValueConst this_val,
                          int argc, JSValueConst *argv)
 {
     int fd, ret;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     ret = js_get_errno(dup(fd));
@@ -3116,7 +3412,7 @@ static JSValue js_os_dup2(JSContext *ctx, JSValueConst this_val,
                          int argc, JSValueConst *argv)
 {
     int fd, fd2, ret;
-    
+
     if (JS_ToInt32(ctx, &fd, argv[0]))
         return JS_EXCEPTION;
     if (JS_ToInt32(ctx, &fd2, argv[1]))
@@ -3141,6 +3437,7 @@ typedef struct {
     char *filename; /* module filename */
     char *basename; /* module base name */
     JSWorkerMessagePipe *recv_pipe, *send_pipe;
+    int strip_flags;
 } WorkerFuncArgs;
 
 typedef struct {
@@ -3189,22 +3486,17 @@ static void js_sab_dup(void *opaque, void *ptr)
 static JSWorkerMessagePipe *js_new_message_pipe(void)
 {
     JSWorkerMessagePipe *ps;
-    int pipe_fds[2];
-    
-    if (pipe(pipe_fds) < 0)
-        return NULL;
 
     ps = malloc(sizeof(*ps));
-    if (!ps) {
-        close(pipe_fds[0]);
-        close(pipe_fds[1]);
+    if (!ps)
+        return NULL;
+    if (js_waker_init(&ps->waker)) {
+        free(ps);
         return NULL;
     }
     ps->ref_count = 1;
     init_list_head(&ps->msg_queue);
     pthread_mutex_init(&ps->mutex, NULL);
-    ps->read_fd = pipe_fds[0];
-    ps->write_fd = pipe_fds[1];
     return ps;
 }
 
@@ -3231,10 +3523,10 @@ static void js_free_message_pipe(JSWorkerMessagePipe *ps)
     struct list_head *el, *el1;
     JSWorkerMessage *msg;
     int ref_count;
-    
+
     if (!ps)
         return;
-    
+
     ref_count = atomic_add_int(&ps->ref_count, -1);
     assert(ref_count >= 0);
     if (ref_count == 0) {
@@ -3243,8 +3535,7 @@ static void js_free_message_pipe(JSWorkerMessagePipe *ps)
             js_free_message(msg);
         }
         pthread_mutex_destroy(&ps->mutex);
-        close(ps->read_fd);
-        close(ps->write_fd);
+        js_waker_close(&ps->waker);
         free(ps);
     }
 }
@@ -3273,7 +3564,7 @@ static void js_worker_finalizer(JSRuntime *rt, JSValue val)
 static JSClassDef js_worker_class = {
     "Worker",
     .finalizer = js_worker_finalizer,
-}; 
+};
 
 static void *worker_func(void *opaque)
 {
@@ -3281,21 +3572,23 @@ static void *worker_func(void *opaque)
     JSRuntime *rt;
     JSThreadState *ts;
     JSContext *ctx;
-    
+    JSValue val;
+
     rt = JS_NewRuntime();
     if (rt == NULL) {
         fprintf(stderr, "JS_NewRuntime failure");
         exit(1);
-    }        
+    }
+    JS_SetStripInfo(rt, args->strip_flags);
     js_std_init_handlers(rt);
 
-    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
+    JS_SetModuleLoaderFunc2(rt, NULL, js_module_loader, js_module_check_attributes, NULL);
 
     /* set the pipe to communicate with the parent */
     ts = JS_GetRuntimeOpaque(rt);
     ts->recv_pipe = args->recv_pipe;
     ts->send_pipe = args->send_pipe;
-    
+
     /* function pointer to avoid linking the whole JS_NewContext() if
        not needed */
     ctx = js_worker_new_context_func(rt);
@@ -3307,11 +3600,14 @@ static void *worker_func(void *opaque)
 
     js_std_add_helpers(ctx, -1, NULL);
 
-    if (!JS_RunModule(ctx, args->basename, args->filename))
-        js_std_dump_error(ctx);
+    val = JS_LoadModule(ctx, args->basename, args->filename);
     free(args->filename);
     free(args->basename);
     free(args);
+    val = js_std_await(ctx, val);
+    if (JS_IsException(val))
+        js_std_dump_error(ctx);
+    JS_FreeValue(ctx, val);
 
     js_std_loop(ctx);
 
@@ -3327,7 +3623,7 @@ static JSValue js_worker_ctor_internal(JSContext *ctx, JSValueConst new_target,
 {
     JSValue obj = JS_UNDEFINED, proto;
     JSWorkerData *s;
-    
+
     /* create the object */
     if (JS_IsUndefined(new_target)) {
         proto = JS_GetClassProto(ctx, js_worker_class_id);
@@ -3364,7 +3660,7 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
     int ret;
     const char *filename = NULL, *basename;
     JSAtom basename_atom;
-    
+
     /* XXX: in order to avoid problems with resource liberation, we
        don't support creating workers inside workers */
     if (!is_main_thread(rt))
@@ -3380,7 +3676,7 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
     JS_FreeAtom(ctx, basename_atom);
     if (!basename)
         goto fail;
-    
+
     /* module name */
     filename = JS_ToCString(ctx, argv[0]);
     if (!filename)
@@ -3401,11 +3697,13 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
     if (!args->send_pipe)
         goto oom_fail;
 
+    args->strip_flags = JS_GetStripInfo(rt);
+    
     obj = js_worker_ctor_internal(ctx, new_target,
                                   args->send_pipe, args->recv_pipe);
     if (JS_IsException(obj))
         goto fail;
-    
+
     pthread_attr_init(&attr);
     /* no join at the end */
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
@@ -3443,10 +3741,10 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
     uint8_t *data;
     JSWorkerMessage *msg;
     uint8_t **sab_tab;
-    
+
     if (!worker)
         return JS_EXCEPTION;
-    
+
     data = JS_WriteObject2(ctx, &data_len, argv[0],
                            JS_WRITE_OBJ_SAB | JS_WRITE_OBJ_REFERENCE,
                            &sab_tab, &sab_tab_len);
@@ -3466,15 +3764,17 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
     memcpy(msg->data, data, data_len);
     msg->data_len = data_len;
 
-    msg->sab_tab = malloc(sizeof(msg->sab_tab[0]) * sab_tab_len);
-    if (!msg->sab_tab)
-        goto fail;
-    memcpy(msg->sab_tab, sab_tab, sizeof(msg->sab_tab[0]) * sab_tab_len);
+    if (sab_tab_len > 0) {
+        msg->sab_tab = malloc(sizeof(msg->sab_tab[0]) * sab_tab_len);
+        if (!msg->sab_tab)
+            goto fail;
+        memcpy(msg->sab_tab, sab_tab, sizeof(msg->sab_tab[0]) * sab_tab_len);
+    }
     msg->sab_tab_len = sab_tab_len;
 
     js_free(ctx, data);
     js_free(ctx, sab_tab);
-    
+
     /* increment the SAB reference counts */
     for(i = 0; i < msg->sab_tab_len; i++) {
         js_sab_dup(NULL, msg->sab_tab[i]);
@@ -3483,17 +3783,8 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
     ps = worker->send_pipe;
     pthread_mutex_lock(&ps->mutex);
     /* indicate that data is present */
-    if (list_empty(&ps->msg_queue)) {
-        uint8_t ch = '\0';
-        int ret;
-        for(;;) {
-            ret = write(ps->write_fd, &ch, 1);
-            if (ret == 1)
-                break;
-            if (ret < 0 && (errno != EAGAIN || errno != EINTR))
-                break;
-        }
-    }
+    if (list_empty(&ps->msg_queue))
+        js_waker_signal(&ps->waker);
     list_add_tail(&msg->link, &ps->msg_queue);
     pthread_mutex_unlock(&ps->mutex);
     return JS_UNDEFINED;
@@ -3506,7 +3797,7 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
     js_free(ctx, data);
     js_free(ctx, sab_tab);
     return JS_EXCEPTION;
-    
+
 }
 
 static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
@@ -3516,7 +3807,7 @@ static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
     JSThreadState *ts = JS_GetRuntimeOpaque(rt);
     JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
     JSWorkerMessageHandler *port;
-    
+
     if (!worker)
         return JS_EXCEPTION;
 
@@ -3628,8 +3919,10 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     OS_FLAG(SIGTTIN),
     OS_FLAG(SIGTTOU),
 #endif
+    JS_CFUNC_DEF("now", 0, js_os_now ),
     JS_CFUNC_DEF("setTimeout", 2, js_os_setTimeout ),
     JS_CFUNC_DEF("clearTimeout", 1, js_os_clearTimeout ),
+    JS_CFUNC_DEF("sleepAsync", 1, js_os_sleepAsync ),
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
     JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
     JS_CFUNC_DEF("chdir", 0, js_os_chdir ),
@@ -3657,6 +3950,7 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_CFUNC_DEF("symlink", 2, js_os_symlink ),
     JS_CFUNC_DEF("readlink", 1, js_os_readlink ),
     JS_CFUNC_DEF("exec", 1, js_os_exec ),
+    JS_CFUNC_DEF("getpid", 0, js_os_getpid ),
     JS_CFUNC_DEF("waitpid", 2, js_os_waitpid ),
     OS_FLAG(WNOHANG),
     JS_CFUNC_DEF("pipe", 0, js_os_pipe ),
@@ -3669,10 +3963,6 @@ static const JSCFunctionListEntry js_os_funcs[] = {
 static int js_os_init(JSContext *ctx, JSModuleDef *m)
 {
     os_poll_func = js_os_poll;
-    
-    /* OSTimer class */
-    JS_NewClassID(&js_os_timer_class_id);
-    JS_NewClass(JS_GetRuntime(ctx), js_os_timer_class_id, &js_os_timer_class);
 
 #ifdef USE_WORKER
     {
@@ -3684,20 +3974,20 @@ static int js_os_init(JSContext *ctx, JSModuleDef *m)
         JS_NewClass(JS_GetRuntime(ctx), js_worker_class_id, &js_worker_class);
         proto = JS_NewObject(ctx);
         JS_SetPropertyFunctionList(ctx, proto, js_worker_proto_funcs, countof(js_worker_proto_funcs));
-        
+
         obj = JS_NewCFunction2(ctx, js_worker_ctor, "Worker", 1,
                                JS_CFUNC_constructor, 0);
         JS_SetConstructor(ctx, obj, proto);
-        
+
         JS_SetClassProto(ctx, js_worker_class_id, proto);
-        
+
         /* set 'Worker.parent' if necessary */
         if (ts->recv_pipe && ts->send_pipe) {
             JS_DefinePropertyValueStr(ctx, obj, "parent",
                                       js_worker_ctor_internal(ctx, JS_UNDEFINED, ts->recv_pipe, ts->send_pipe),
                                       JS_PROP_C_W_E);
         }
-        
+
         JS_SetModuleExport(ctx, m, "Worker", obj);
     }
 #endif /* USE_WORKER */
@@ -3722,28 +4012,43 @@ JSModuleDef *js_init_module_os(JSContext *ctx, const char *module_name)
 /**********************************************************/
 
 static JSValue js_print(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
+                        int argc, JSValueConst *argv)
 {
     int i;
-    const char *str;
-    size_t len;
-
+    JSValueConst v;
+    
     for(i = 0; i < argc; i++) {
         if (i != 0)
             putchar(' ');
-        str = JS_ToCStringLen(ctx, &len, argv[i]);
-        if (!str)
-            return JS_EXCEPTION;
-        fwrite(str, 1, len, stdout);
-        JS_FreeCString(ctx, str);
+        v = argv[i];
+        if (JS_IsString(v)) {
+            const char *str;
+            size_t len;
+            str = JS_ToCStringLen(ctx, &len, v);
+            if (!str)
+                return JS_EXCEPTION;
+            fwrite(str, 1, len, stdout);
+            JS_FreeCString(ctx, str);
+        } else {
+            JS_PrintValue(ctx, js_print_value_write, stdout, v, NULL);
+        }
     }
     putchar('\n');
     return JS_UNDEFINED;
 }
 
+static JSValue js_console_log(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    JSValue ret;
+    ret = js_print(ctx, this_val, argc, argv);
+    fflush(stdout);
+    return ret;
+}
+
 void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
 {
-    JSValue global_obj, console, args;
+    JSValue global_obj, console, args, performance;
     int i;
 
     /* XXX: should these global definitions be enumerable? */
@@ -3751,9 +4056,14 @@ void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
 
     console = JS_NewObject(ctx);
     JS_SetPropertyStr(ctx, console, "log",
-                      JS_NewCFunction(ctx, js_print, "log", 1));
+                      JS_NewCFunction(ctx, js_console_log, "log", 1));
     JS_SetPropertyStr(ctx, global_obj, "console", console);
 
+    performance = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, performance, "now",
+                      JS_NewCFunction(ctx, js_os_now, "now", 0));
+    JS_SetPropertyStr(ctx, global_obj, "performance", performance);
+
     /* same methods as the mozilla JS shell */
     if (argc >= 0) {
         args = JS_NewArray(ctx);
@@ -3762,12 +4072,12 @@ void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
         }
         JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
     }
-    
+
     JS_SetPropertyStr(ctx, global_obj, "print",
                       JS_NewCFunction(ctx, js_print, "print", 1));
     JS_SetPropertyStr(ctx, global_obj, "__loadScript",
                       JS_NewCFunction(ctx, js_loadScript, "__loadScript", 1));
-    
+
     JS_FreeValue(ctx, global_obj);
 }
 
@@ -3785,6 +4095,8 @@ void js_std_init_handlers(JSRuntime *rt)
     init_list_head(&ts->os_signal_handlers);
     init_list_head(&ts->os_timers);
     init_list_head(&ts->port_list);
+    init_list_head(&ts->rejected_promise_list);
+    ts->next_timer_id = 1;
 
     JS_SetRuntimeOpaque(rt, ts);
 
@@ -3815,12 +4127,17 @@ void js_std_free_handlers(JSRuntime *rt)
         JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
         free_sh(rt, sh);
     }
-    
+
     list_for_each_safe(el, el1, &ts->os_timers) {
         JSOSTimer *th = list_entry(el, JSOSTimer, link);
-        unlink_timer(rt, th);
-        if (!th->has_object)
-            free_timer(rt, th);
+        free_timer(rt, th);
+    }
+
+    list_for_each_safe(el, el1, &ts->rejected_promise_list) {
+        JSRejectedPromiseEntry *rp = list_entry(el, JSRejectedPromiseEntry, link);
+        JS_FreeValueRT(rt, rp->promise);
+        JS_FreeValueRT(rt, rp->reason);
+        free(rp);
     }
 
 #ifdef USE_WORKER
@@ -3833,77 +4150,147 @@ void js_std_free_handlers(JSRuntime *rt)
     JS_SetRuntimeOpaque(rt, NULL); /* fail safe */
 }
 
-static void js_dump_obj(JSContext *ctx, FILE *f, JSValueConst val)
-{
-    const char *str;
-    
-    str = JS_ToCString(ctx, val);
-    if (str) {
-        fprintf(f, "%s\n", str);
-        JS_FreeCString(ctx, str);
-    } else {
-        fprintf(f, "[exception]\n");
-    }
-}
-
 static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val)
 {
-    JSValue val;
-    BOOL is_error;
-    
-    is_error = JS_IsError(ctx, exception_val);
-    js_dump_obj(ctx, stderr, exception_val);
-    if (is_error) {
-        val = JS_GetPropertyStr(ctx, exception_val, "stack");
-        if (!JS_IsUndefined(val)) {
-            js_dump_obj(ctx, stderr, val);
-        }
-        JS_FreeValue(ctx, val);
-    }
+    JS_PrintValue(ctx, js_print_value_write, stderr, exception_val, NULL);
+    fputc('\n', stderr);
 }
 
 void js_std_dump_error(JSContext *ctx)
 {
     JSValue exception_val;
-    
+
     exception_val = JS_GetException(ctx);
     js_std_dump_error1(ctx, exception_val);
     JS_FreeValue(ctx, exception_val);
 }
 
+static JSRejectedPromiseEntry *find_rejected_promise(JSContext *ctx, JSThreadState *ts,
+                                                     JSValueConst promise)
+{
+    struct list_head *el;
+
+    list_for_each(el, &ts->rejected_promise_list) {
+        JSRejectedPromiseEntry *rp = list_entry(el, JSRejectedPromiseEntry, link);
+        if (JS_SameValue(ctx, rp->promise, promise))
+            return rp;
+    }
+    return NULL;
+}
+
 void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                       JSValueConst reason,
                                       BOOL is_handled, void *opaque)
 {
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    JSRejectedPromiseEntry *rp;
+
     if (!is_handled) {
-        fprintf(stderr, "Possibly unhandled promise rejection: ");
-        js_std_dump_error1(ctx, reason);
+        /* add a new entry if needed */
+        rp = find_rejected_promise(ctx, ts, promise);
+        if (!rp) {
+            rp = malloc(sizeof(*rp));
+            if (rp) {
+                rp->promise = JS_DupValue(ctx, promise);
+                rp->reason = JS_DupValue(ctx, reason);
+                list_add_tail(&rp->link, &ts->rejected_promise_list);
+            }
+        }
+    } else {
+        /* the rejection is handled, so the entry can be removed if present */
+        rp = find_rejected_promise(ctx, ts, promise);
+        if (rp) {
+            JS_FreeValue(ctx, rp->promise);
+            JS_FreeValue(ctx, rp->reason);
+            list_del(&rp->link);
+            free(rp);
+        }
+    }
+}
+
+/* check if there are pending promise rejections. It must be done
+   asynchrously in case a rejected promise is handled later. Currently
+   we do it once the application is about to sleep. It could be done
+   more often if needed. */
+static void js_std_promise_rejection_check(JSContext *ctx)
+{
+    JSRuntime *rt = JS_GetRuntime(ctx);
+    JSThreadState *ts = JS_GetRuntimeOpaque(rt);
+    struct list_head *el;
+
+    if (unlikely(!list_empty(&ts->rejected_promise_list))) {
+        list_for_each(el, &ts->rejected_promise_list) {
+            JSRejectedPromiseEntry *rp = list_entry(el, JSRejectedPromiseEntry, link);
+            fprintf(stderr, "Possibly unhandled promise rejection: ");
+            js_std_dump_error1(ctx, rp->reason);
+        }
+        exit(1);
     }
 }
 
 /* main loop which calls the user JS callbacks */
 void js_std_loop(JSContext *ctx)
 {
-    JSContext *ctx1;
     int err;
 
     for(;;) {
         /* execute the pending jobs */
         for(;;) {
-            err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
+            err = JS_ExecutePendingJob(JS_GetRuntime(ctx), NULL);
             if (err <= 0) {
-                if (err < 0) {
-                    js_std_dump_error(ctx1);
-                }
+                if (err < 0)
+                    js_std_dump_error(ctx);
                 break;
             }
         }
 
+        js_std_promise_rejection_check(ctx);
+        
         if (!os_poll_func || os_poll_func(ctx))
             break;
     }
 }
 
+/* Wait for a promise and execute pending jobs while waiting for
+   it. Return the promise result or JS_EXCEPTION in case of promise
+   rejection. */
+JSValue js_std_await(JSContext *ctx, JSValue obj)
+{
+    JSValue ret;
+    int state;
+
+    for(;;) {
+        state = JS_PromiseState(ctx, obj);
+        if (state == JS_PROMISE_FULFILLED) {
+            ret = JS_PromiseResult(ctx, obj);
+            JS_FreeValue(ctx, obj);
+            break;
+        } else if (state == JS_PROMISE_REJECTED) {
+            ret = JS_Throw(ctx, JS_PromiseResult(ctx, obj));
+            JS_FreeValue(ctx, obj);
+            break;
+        } else if (state == JS_PROMISE_PENDING) {
+            int err;
+            err = JS_ExecutePendingJob(JS_GetRuntime(ctx), NULL);
+            if (err < 0) {
+                js_std_dump_error(ctx);
+            }
+            if (err == 0) {
+                js_std_promise_rejection_check(ctx);
+
+                if (os_poll_func)
+                    os_poll_func(ctx);
+            }
+        } else {
+            /* not a promise */
+            ret = obj;
+            break;
+        }
+    }
+    return ret;
+}
+
 void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                         int load_only)
 {
@@ -3922,8 +4309,11 @@ void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                 goto exception;
             }
             js_module_set_import_meta(ctx, obj, FALSE, TRUE);
+            val = JS_EvalFunction(ctx, obj);
+            val = js_std_await(ctx, val);
+        } else {
+            val = JS_EvalFunction(ctx, obj);
         }
-        val = JS_EvalFunction(ctx, obj);
         if (JS_IsException(val)) {
         exception:
             js_std_dump_error(ctx);
@@ -3932,3 +4322,22 @@ void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
         JS_FreeValue(ctx, val);
     }
 }
+
+void js_std_eval_binary_json_module(JSContext *ctx,
+                                    const uint8_t *buf, size_t buf_len,
+                                    const char *module_name)
+{
+    JSValue obj;
+    JSModuleDef *m;
+    
+    obj = JS_ReadObject(ctx, buf, buf_len, 0);
+    if (JS_IsException(obj))
+        goto exception;
+    m = create_json_module(ctx, module_name, obj);
+    if (!m) {
+    exception:
+        js_std_dump_error(ctx);
+        exit(1);
+    }
+}
+
diff --git a/quickjs/quickjs-libc.h b/quickjs/quickjs-libc.h
index fbbe5b0166..5c8301b717 100644
--- a/quickjs/quickjs-libc.h
+++ b/quickjs/quickjs-libc.h
@@ -1,6 +1,6 @@
 /*
  * QuickJS C library
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -37,21 +37,28 @@ JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name);
 JSModuleDef *js_init_module_os(JSContext *ctx, const char *module_name);
 void js_std_add_helpers(JSContext *ctx, int argc, char **argv);
 void js_std_loop(JSContext *ctx);
+JSValue js_std_await(JSContext *ctx, JSValue obj);
 void js_std_init_handlers(JSRuntime *rt);
 void js_std_free_handlers(JSRuntime *rt);
 void js_std_dump_error(JSContext *ctx);
 uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename);
 int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
                               JS_BOOL use_realpath, JS_BOOL is_main);
+int js_module_test_json(JSContext *ctx, JSValueConst attributes);
+int js_module_check_attributes(JSContext *ctx, void *opaque, JSValueConst attributes);
 JSModuleDef *js_module_loader(JSContext *ctx,
-                              const char *module_name, void *opaque);
+                              const char *module_name, void *opaque,
+                              JSValueConst attributes);
 void js_std_eval_binary(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                         int flags);
+void js_std_eval_binary_json_module(JSContext *ctx,
+                                    const uint8_t *buf, size_t buf_len,
+                                    const char *module_name);
 void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
                                       JSValueConst reason,
                                       JS_BOOL is_handled, void *opaque);
 void js_std_set_worker_new_context_func(JSContext *(*func)(JSRuntime *rt));
-                                        
+
 #ifdef __cplusplus
 } /* extern "C" { */
 #endif
diff --git a/quickjs/quickjs-opcode.h b/quickjs/quickjs-opcode.h
index 15a9fce6a3..814a7cbaaa 100644
--- a/quickjs/quickjs-opcode.h
+++ b/quickjs/quickjs-opcode.h
@@ -1,6 +1,6 @@
 /*
  * QuickJS opcode definitions
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  * Copyright (c) 2017-2018 Charlie Gordon
  *
@@ -110,6 +110,7 @@ DEF(         return, 1, 1, 0, none)
 DEF(   return_undef, 1, 0, 0, none)
 DEF(check_ctor_return, 1, 1, 2, none)
 DEF(     check_ctor, 1, 0, 0, none)
+DEF(      init_ctor, 1, 0, 1, none)
 DEF(    check_brand, 1, 2, 2, none) /* this_obj func -> this_obj func */
 DEF(      add_brand, 1, 2, 0, none) /* this_obj home_obj -> */
 DEF(   return_async, 1, 1, 0, none)
@@ -120,7 +121,7 @@ DEF(     apply_eval, 3, 2, 1, u16) /* func array -> ret_eval */
 DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern and a
                                        bytecode string */
 DEF(      get_super, 1, 1, 1, none)
-DEF(         import, 1, 1, 1, none) /* dynamic module import */
+DEF(         import, 1, 2, 1, none) /* dynamic module import */
 
 DEF(      check_var, 5, 0, 1, atom) /* check if a variable exists */
 DEF(  get_var_undef, 5, 0, 1, atom) /* push undefined if the variable does not exist */
@@ -143,6 +144,7 @@ DEF( put_private_field, 1, 3, 0, none) /* obj value prop -> */
 DEF(define_private_field, 1, 3, 1, none) /* obj prop value -> obj */
 DEF(   get_array_el, 1, 2, 1, none)
 DEF(  get_array_el2, 1, 2, 2, none) /* obj prop -> obj value */
+DEF(  get_array_el3, 1, 2, 3, none) /* obj prop -> obj prop1 value */
 DEF(   put_array_el, 1, 3, 0, none)
 DEF(get_super_value, 1, 3, 1, none) /* this obj prop -> value */
 DEF(put_super_value, 1, 4, 0, none) /* this obj prop value -> */
@@ -165,14 +167,15 @@ DEF(        set_loc, 3, 1, 1, loc) /* must come after put_loc */
 DEF(        get_arg, 3, 0, 1, arg)
 DEF(        put_arg, 3, 1, 0, arg) /* must come after get_arg */
 DEF(        set_arg, 3, 1, 1, arg) /* must come after put_arg */
-DEF(    get_var_ref, 3, 0, 1, var_ref) 
+DEF(    get_var_ref, 3, 0, 1, var_ref)
 DEF(    put_var_ref, 3, 1, 0, var_ref) /* must come after get_var_ref */
 DEF(    set_var_ref, 3, 1, 1, var_ref) /* must come after put_var_ref */
 DEF(set_loc_uninitialized, 3, 0, 0, loc)
 DEF(  get_loc_check, 3, 0, 1, loc)
 DEF(  put_loc_check, 3, 1, 0, loc) /* must come after get_loc_check */
 DEF(  put_loc_check_init, 3, 1, 0, loc)
-DEF(get_var_ref_check, 3, 0, 1, var_ref) 
+DEF(get_loc_checkthis, 3, 0, 1, loc)
+DEF(get_var_ref_check, 3, 0, 1, var_ref)
 DEF(put_var_ref_check, 3, 1, 0, var_ref) /* must come after get_var_ref_check */
 DEF(put_var_ref_check_init, 3, 1, 0, var_ref)
 DEF(      close_loc, 3, 0, 0, loc)
@@ -182,18 +185,17 @@ DEF(           goto, 5, 0, 0, label) /* must come after if_true */
 DEF(          catch, 5, 0, 1, label)
 DEF(          gosub, 5, 0, 0, label) /* used to execute the finally block */
 DEF(            ret, 1, 1, 0, none) /* used to return from the finally block */
+DEF(      nip_catch, 1, 2, 1, none) /* catch ... a -> a */
 
 DEF(      to_object, 1, 1, 1, none)
 //DEF(      to_string, 1, 1, 1, none)
 DEF(     to_propkey, 1, 1, 1, none)
-DEF(    to_propkey2, 1, 2, 2, none)
 
 DEF(   with_get_var, 10, 1, 0, atom_label_u8)     /* must be in the same order as scope_xxx */
 DEF(   with_put_var, 10, 2, 1, atom_label_u8)     /* must be in the same order as scope_xxx */
 DEF(with_delete_var, 10, 1, 0, atom_label_u8)     /* must be in the same order as scope_xxx */
 DEF(  with_make_ref, 10, 1, 0, atom_label_u8)     /* must be in the same order as scope_xxx */
 DEF(   with_get_ref, 10, 1, 0, atom_label_u8)     /* must be in the same order as scope_xxx */
-DEF(with_get_ref_undef, 10, 1, 0, atom_label_u8)
 
 DEF(   make_loc_ref, 7, 0, 2, atom_u16)
 DEF(   make_arg_ref, 7, 0, 2, atom_u16)
@@ -205,10 +207,10 @@ DEF(   for_of_start, 1, 1, 3, none)
 DEF(for_await_of_start, 1, 1, 3, none)
 DEF(    for_in_next, 1, 1, 3, none)
 DEF(    for_of_next, 2, 3, 5, u8)
+DEF(for_await_of_next, 1, 3, 4, none) /* iter next catch_offset -> iter next catch_offset obj */
 DEF(iterator_check_object, 1, 1, 1, none)
-DEF(iterator_get_value_done, 1, 1, 2, none)
+DEF(iterator_get_value_done, 1, 2, 3, none) /* catch_offset obj -> catch_offset value done */
 DEF( iterator_close, 1, 3, 0, none)
-DEF(iterator_close_return, 1, 4, 4, none)
 DEF(  iterator_next, 1, 4, 4, none)
 DEF(  iterator_call, 2, 4, 5, u8)
 DEF(  initial_yield, 1, 0, 0, none)
@@ -256,12 +258,10 @@ DEF(            and, 1, 2, 1, none)
 DEF(            xor, 1, 2, 1, none)
 DEF(             or, 1, 2, 1, none)
 DEF(is_undefined_or_null, 1, 1, 1, none)
-#ifdef CONFIG_BIGNUM
-DEF(      mul_pow10, 1, 2, 1, none)
-DEF(       math_mod, 1, 2, 1, none)
-#endif
+DEF(     private_in, 1, 2, 1, none)
+DEF(push_bigint_i32, 5, 0, 1, i32)
 /* must be the last non short and non temporary opcode */
-DEF(            nop, 1, 0, 0, none) 
+DEF(            nop, 1, 0, 0, none)
 
 /* temporary opcodes: never emitted in the final bytecode */
 
@@ -270,6 +270,8 @@ def(    leave_scope, 3, 0, 0, u16)  /* emitted in phase 1, removed in phase 2 */
 
 def(          label, 5, 0, 0, label) /* emitted in phase 1, removed in phase 3 */
 
+/* the following opcodes must be in the same order as the 'with_x' and
+   get_var_undef, get_var and put_var opcodes */
 def(scope_get_var_undef, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
 def(  scope_get_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
 def(  scope_put_var, 7, 1, 0, atom_u16) /* emitted in phase 1, removed in phase 2 */
@@ -277,12 +279,15 @@ def(scope_delete_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase
 def( scope_make_ref, 11, 0, 2, atom_label_u16) /* emitted in phase 1, removed in phase 2 */
 def(  scope_get_ref, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
 def(scope_put_var_init, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_get_var_checkthis, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2, only used to return 'this' in derived class constructors */
 def(scope_get_private_field, 7, 1, 1, atom_u16) /* obj -> value, emitted in phase 1, removed in phase 2 */
 def(scope_get_private_field2, 7, 1, 2, atom_u16) /* obj -> obj value, emitted in phase 1, removed in phase 2 */
 def(scope_put_private_field, 7, 2, 0, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
-
+def(scope_in_private_field, 7, 1, 1, atom_u16) /* obj -> res emitted in phase 1, removed in phase 2 */
+def(get_field_opt_chain, 5, 1, 1, atom) /* emitted in phase 1, removed in phase 2 */
+def(get_array_el_opt_chain, 1, 2, 1, none) /* emitted in phase 1, removed in phase 2 */
 def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
-    
+
 def(       line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
 
 #if SHORT_OPCODES
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
index f9fd091ac0..fa7c24aacd 100644
--- a/quickjs/quickjs.c
+++ b/quickjs/quickjs.c
@@ -1,8 +1,8 @@
 /*
  * QuickJS Javascript Engine
- * 
- * Copyright (c) 2017-2021 Fabrice Bellard
- * Copyright (c) 2017-2021 Charlie Gordon
+ *
+ * Copyright (c) 2017-2025 Fabrice Bellard
+ * Copyright (c) 2017-2025 Charlie Gordon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -34,7 +34,7 @@
 #include <math.h>
 #if defined(__APPLE__)
 #include <malloc/malloc.h>
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__GLIBC__)
 #include <malloc.h>
 #elif defined(__FreeBSD__)
 #include <malloc_np.h>
@@ -44,7 +44,8 @@
 #include "list.h"
 #include "quickjs.h"
 #include "libregexp.h"
-#include "libbf.h"
+#include "libunicode.h"
+#include "dtoa.h"
 
 #define OPTIMIZE         1
 #define SHORT_OPCODES    1
@@ -87,6 +88,7 @@
    8: dump stdlib functions
   16: dump bytecode in hex
   32: dump line number table
+  64: dump compute_stack_size
  */
 //#define DUMP_BYTECODE  (1)
 /* dump the occurence of the automatic GC */
@@ -101,8 +103,10 @@
 //#define DUMP_ATOMS      /* dump atoms in JS_FreeContext */
 //#define DUMP_SHAPES     /* dump shapes in JS_FreeContext */
 //#define DUMP_MODULE_RESOLVE
+//#define DUMP_MODULE_EXEC
 //#define DUMP_PROMISE
 //#define DUMP_READ_OBJECT
+//#define DUMP_ROPE_REBALANCE
 
 /* test the GC by forcing it before each object allocation */
 //#define FORCE_GC_AT_MALLOC
@@ -144,16 +148,11 @@ enum {
     JS_CLASS_UINT32_ARRAY,      /* u.array (typed_array) */
     JS_CLASS_BIG_INT64_ARRAY,   /* u.array (typed_array) */
     JS_CLASS_BIG_UINT64_ARRAY,  /* u.array (typed_array) */
+    JS_CLASS_FLOAT16_ARRAY,     /* u.array (typed_array) */
     JS_CLASS_FLOAT32_ARRAY,     /* u.array (typed_array) */
     JS_CLASS_FLOAT64_ARRAY,     /* u.array (typed_array) */
     JS_CLASS_DATAVIEW,          /* u.typed_array */
     JS_CLASS_BIG_INT,           /* u.object_data */
-#ifdef CONFIG_BIGNUM
-    JS_CLASS_BIG_FLOAT,         /* u.object_data */
-    JS_CLASS_FLOAT_ENV,         /* u.float_env */
-    JS_CLASS_BIG_DECIMAL,       /* u.object_data */
-    JS_CLASS_OPERATOR_SET,      /* u.operator_set */
-#endif
     JS_CLASS_MAP,               /* u.map_state */
     JS_CLASS_SET,               /* u.map_state */
     JS_CLASS_WEAKMAP,           /* u.map_state */
@@ -174,7 +173,9 @@ enum {
     JS_CLASS_ASYNC_FROM_SYNC_ITERATOR,  /* u.async_from_sync_iterator_data */
     JS_CLASS_ASYNC_GENERATOR_FUNCTION,  /* u.func */
     JS_CLASS_ASYNC_GENERATOR,   /* u.async_generator_data */
-
+    JS_CLASS_WEAK_REF,
+    JS_CLASS_FINALIZATION_REGISTRY,
+    
     JS_CLASS_INIT_COUNT, /* last entry for predefined classes */
 };
 
@@ -192,19 +193,34 @@ typedef enum JSErrorEnum {
     JS_URI_ERROR,
     JS_INTERNAL_ERROR,
     JS_AGGREGATE_ERROR,
-    
+
     JS_NATIVE_ERROR_COUNT, /* number of different NativeError objects */
 } JSErrorEnum;
 
-#define JS_MAX_LOCAL_VARS 65536
+/* the variable and scope indexes must fit on 16 bits. The (-1) and
+   ARG_SCOPE_END values are reserved. */
+#define JS_MAX_LOCAL_VARS 65534
 #define JS_STACK_SIZE_MAX 65534
 #define JS_STRING_LEN_MAX ((1 << 30) - 1)
 
+/* strings <= this length are not concatenated using ropes. if too
+   small, the rope memory overhead becomes high. */
+#define JS_STRING_ROPE_SHORT_LEN  512
+/* specific threshold for initial rope use */
+#define JS_STRING_ROPE_SHORT2_LEN 8192
+/* rope depth at which we rebalance */
+#define JS_STRING_ROPE_MAX_DEPTH 60
+
 #define __exception __attribute__((warn_unused_result))
 
 typedef struct JSShape JSShape;
 typedef struct JSString JSString;
 typedef struct JSString JSAtomStruct;
+typedef struct JSObject JSObject;
+
+#define JS_VALUE_GET_OBJ(v) ((JSObject *)JS_VALUE_GET_PTR(v))
+#define JS_VALUE_GET_STRING(v) ((JSString *)JS_VALUE_GET_PTR(v))
+#define JS_VALUE_GET_STRING_ROPE(v) ((JSStringRope *)JS_VALUE_GET_PTR(v))
 
 typedef enum {
     JS_GC_PHASE_NONE,
@@ -214,24 +230,6 @@ typedef enum {
 
 typedef enum OPCodeEnum OPCodeEnum;
 
-/* function pointers are used for numeric operations so that it is
-   possible to remove some numeric types */
-typedef struct {
-    JSValue (*to_string)(JSContext *ctx, JSValueConst val);
-    JSValue (*from_string)(JSContext *ctx, const char *buf,
-                           int radix, int flags, slimb_t *pexponent);
-    int (*unary_arith)(JSContext *ctx,
-                       JSValue *pres, OPCodeEnum op, JSValue op1);
-    int (*binary_arith)(JSContext *ctx, OPCodeEnum op,
-                        JSValue *pres, JSValue op1, JSValue op2);
-    int (*compare)(JSContext *ctx, OPCodeEnum op,
-                   JSValue op1, JSValue op2);
-    /* only for bigfloat: */
-    JSValue (*mul_pow10_to_float64)(JSContext *ctx, const bf_t *a,
-                                    int64_t exponent);
-    int (*mul_pow10)(JSContext *ctx, JSValue *sp);
-} JSNumericOperations;
-
 struct JSRuntime {
     JSMallocFunctions mf;
     JSMallocState malloc_state;
@@ -253,10 +251,11 @@ struct JSRuntime {
        by the garbage collector) */
     struct list_head gc_obj_list;
     /* list of JSGCObjectHeader.link. Used during JS_FreeValueRT() */
-    struct list_head gc_zero_ref_count_list; 
+    struct list_head gc_zero_ref_count_list;
     struct list_head tmp_obj_list; /* used during GC */
     JSGCPhaseEnum gc_phase : 8;
     size_t malloc_gc_threshold;
+    struct list_head weakref_list; /* list of JSWeakRefHeader.link */
 #ifdef DUMP_LEAKS
     struct list_head string_list; /* list of JSString.link */
 #endif
@@ -264,8 +263,10 @@ struct JSRuntime {
     uintptr_t stack_size; /* in bytes, 0 if no limit */
     uintptr_t stack_top;
     uintptr_t stack_limit; /* lower stack limit */
-    
+
     JSValue current_exception;
+    /* true if the current exception cannot be catched */
+    BOOL current_exception_is_uncatchable : 8;
     /* true if inside an out of memory error, to avoid recursing */
     BOOL in_out_of_memory : 8;
 
@@ -279,29 +280,31 @@ struct JSRuntime {
 
     JSHostPromiseRejectionTracker *host_unhandled_promise_rejection_tracker;
     void *host_unhandled_promise_rejection_tracker_opaque;
-    
+
     struct list_head job_list; /* list of JSJobEntry.link */
 
     JSModuleNormalizeFunc *module_normalize_func;
-    JSModuleLoaderFunc *module_loader_func;
+    BOOL module_loader_has_attr;
+    union {
+        JSModuleLoaderFunc *module_loader_func;
+        JSModuleLoaderFunc2 *module_loader_func2;
+    } u;
+    JSModuleCheckSupportedImportAttributes *module_check_attrs;
     void *module_loader_opaque;
+    /* timestamp for internal use in module evaluation */
+    int64_t module_async_evaluation_next_timestamp;
 
     BOOL can_block : 8; /* TRUE if Atomics.wait can block */
     /* used to allocate, free and clone SharedArrayBuffers */
     JSSharedArrayBufferFunctions sab_funcs;
+    /* see JS_SetStripInfo() */
+    uint8_t strip_flags;
     
     /* Shape hash table */
     int shape_hash_bits;
     int shape_hash_size;
     int shape_hash_count; /* number of hashed shapes */
     JSShape **shape_hash;
-    bf_context_t bf_ctx;
-    JSNumericOperations bigint_ops;
-#ifdef CONFIG_BIGNUM
-    JSNumericOperations bigfloat_ops;
-    JSNumericOperations bigdecimal_ops;
-    uint32_t operator_count;
-#endif
     void *user_opaque;
 };
 
@@ -316,21 +319,21 @@ struct JSClass {
 };
 
 #define JS_MODE_STRICT (1 << 0)
-#define JS_MODE_STRIP  (1 << 1)
-#define JS_MODE_MATH   (1 << 2)
+#define JS_MODE_ASYNC  (1 << 2) /* async function */
+#define JS_MODE_BACKTRACE_BARRIER (1 << 3) /* stop backtrace before this frame */
 
 typedef struct JSStackFrame {
     struct JSStackFrame *prev_frame; /* NULL if first stack frame */
     JSValue cur_func; /* current function, JS_UNDEFINED if the frame is detached */
     JSValue *arg_buf; /* arguments */
     JSValue *var_buf; /* variables */
-    struct list_head var_ref_list; /* list of JSVarRef.link */
+    struct list_head var_ref_list; /* list of JSVarRef.var_ref_link */
     const uint8_t *cur_pc; /* only used in bytecode functions : PC of the
                         instruction after the call */
     int arg_count;
-    int js_mode; /* 0 or JS_MODE_MATH for C functions */
+    int js_mode; /* not supported for C functions */
     /* only used in generators. Current stack pointer value. NULL if
-       the function is running. */ 
+       the function is running. */
     JSValue *cur_sp;
 } JSStackFrame;
 
@@ -341,6 +344,7 @@ typedef enum {
     JS_GC_OBJ_TYPE_VAR_REF,
     JS_GC_OBJ_TYPE_ASYNC_FUNCTION,
     JS_GC_OBJ_TYPE_JS_CONTEXT,
+    JS_GC_OBJ_TYPE_MODULE,
 } JSGCObjectTypeEnum;
 
 /* header for GC objects. GC objects are C data structures with a
@@ -355,48 +359,76 @@ struct JSGCObjectHeader {
     struct list_head link;
 };
 
+typedef enum {
+    JS_WEAKREF_TYPE_MAP,
+    JS_WEAKREF_TYPE_WEAKREF,
+    JS_WEAKREF_TYPE_FINREC,
+} JSWeakRefHeaderTypeEnum;
+
+typedef struct {
+    struct list_head link;
+    JSWeakRefHeaderTypeEnum weakref_type;
+} JSWeakRefHeader;
+
 typedef struct JSVarRef {
     union {
         JSGCObjectHeader header; /* must come first */
         struct {
             int __gc_ref_count; /* corresponds to header.ref_count */
             uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
-
-            /* 0 : the JSVarRef is on the stack. header.link is an element
-               of JSStackFrame.var_ref_list.
-               1 : the JSVarRef is detached. header.link has the normal meanning 
-            */
-            uint8_t is_detached : 1; 
-            uint8_t is_arg : 1;
-            uint16_t var_idx; /* index of the corresponding function variable on
-                                 the stack */
+            uint8_t is_detached;
         };
     };
     JSValue *pvalue; /* pointer to the value, either on the stack or
                         to 'value' */
-    JSValue value; /* used when the variable is no longer on the stack */
+    union {
+        JSValue value; /* used when is_detached = TRUE */
+        struct {
+            struct list_head var_ref_link; /* JSStackFrame.var_ref_list list */
+            struct JSAsyncFunctionState *async_func; /* != NULL if async stack frame */
+        }; /* used when is_detached = FALSE */
+    };
 } JSVarRef;
 
-/* the same structure is used for big integers and big floats. Big
-   integers are never infinite or NaNs */
-typedef struct JSBigFloat {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    bf_t num;
-} JSBigFloat;
+/* bigint */
 
-#ifdef CONFIG_BIGNUM
-typedef struct JSFloatEnv {
-    limb_t prec;
-    bf_flags_t flags;
-    unsigned int status;
-} JSFloatEnv;
+#if JS_LIMB_BITS == 32
+
+typedef int32_t js_slimb_t;
+typedef uint32_t js_limb_t;
+typedef int64_t js_sdlimb_t;
+typedef uint64_t js_dlimb_t;
+
+#define JS_LIMB_DIGITS 9
+
+#else
+
+typedef __int128 int128_t;
+typedef unsigned __int128 uint128_t;
+typedef int64_t js_slimb_t;
+typedef uint64_t js_limb_t;
+typedef int128_t js_sdlimb_t;
+typedef uint128_t js_dlimb_t;
+
+#define JS_LIMB_DIGITS 19
 
-typedef struct JSBigDecimal {
-    JSRefCountHeader header; /* must come first, 32-bit */
-    bfdec_t num;
-} JSBigDecimal;
 #endif
 
+typedef struct JSBigInt {
+    JSRefCountHeader header; /* must come first, 32-bit */
+    uint32_t len; /* number of limbs, >= 1 */
+    js_limb_t tab[]; /* two's complement representation, always
+                        normalized so that 'len' is the minimum
+                        possible length >= 1 */
+} JSBigInt;
+
+/* this bigint structure can hold a 64 bit integer */
+typedef struct {
+    js_limb_t big_int_buf[sizeof(JSBigInt) / sizeof(js_limb_t)]; /* for JSBigInt */
+    /* must come just after */
+    js_limb_t tab[(64 + JS_LIMB_BITS - 1) / JS_LIMB_BITS];
+} JSBigIntBuf;
+    
 typedef enum {
     JS_AUTOINIT_ID_PROTOTYPE,
     JS_AUTOINIT_ID_MODULE_NS,
@@ -434,15 +466,9 @@ struct JSContext {
     JSValue global_var_obj; /* contains the global let/const definitions */
 
     uint64_t random_state;
-    bf_context_t *bf_ctx;   /* points to rt->bf_ctx, shared by all contexts */
-#ifdef CONFIG_BIGNUM
-    JSFloatEnv fp_env; /* global FP environment */
-    BOOL bignum_ext : 8; /* enable math mode */
-    BOOL allow_operator_overloading : 8;
-#endif
+
     /* when the counter reaches zero, JSRutime.interrupt_handler is called */
     int interrupt_counter;
-    BOOL is_error_property_enabled;
 
     struct list_head loaded_modules; /* list of JSModuleDef.link */
 
@@ -469,11 +495,6 @@ enum {
     JS_ATOM_TYPE_PRIVATE,
 };
 
-enum {
-    JS_ATOM_HASH_SYMBOL,
-    JS_ATOM_HASH_PRIVATE,
-};
-
 typedef enum {
     JS_ATOM_KIND_STRING,
     JS_ATOM_KIND_SYMBOL,
@@ -481,13 +502,14 @@ typedef enum {
 } JSAtomKindEnum;
 
 #define JS_ATOM_HASH_MASK  ((1 << 30) - 1)
+#define JS_ATOM_HASH_PRIVATE JS_ATOM_HASH_MASK
 
 struct JSString {
     JSRefCountHeader header; /* must come first, 32-bit */
     uint32_t len : 31;
     uint8_t is_wide_char : 1; /* 0 = 8 bits, 1 = 16 bits characters */
-    /* for JS_ATOM_TYPE_SYMBOL: hash = 0, atom_type = 3,
-       for JS_ATOM_TYPE_PRIVATE: hash = 1, atom_type = 3
+    /* for JS_ATOM_TYPE_SYMBOL: hash = weakref_count, atom_type = 3,
+       for JS_ATOM_TYPE_PRIVATE: hash = JS_ATOM_HASH_PRIVATE, atom_type = 3
        XXX: could change encoding to have one more bit in hash */
     uint32_t hash : 30;
     uint8_t atom_type : 2; /* != 0 if atom, JS_ATOM_TYPE_x */
@@ -501,6 +523,17 @@ struct JSString {
     } u;
 };
 
+typedef struct JSStringRope {
+    JSRefCountHeader header; /* must come first, 32-bit */
+    uint32_t len;
+    uint8_t is_wide_char; /* 0 = 8 bits, 1 = 16 bits characters */
+    uint8_t depth; /* max depth of the rope tree */
+    /* XXX: could reduce memory usage by using a direct pointer with
+       bit 0 to select rope or string */
+    JSValue left;
+    JSValue right; /* might be the empty string */
+} JSStringRope;
+
 typedef struct JSClosureVar {
     uint8_t is_local : 1;
     uint8_t is_arg : 1;
@@ -543,7 +576,7 @@ typedef struct JSVarDef {
     JSAtom var_name;
     /* index into fd->scopes of this variable lexical scope */
     int scope_level;
-    /* during compilation: 
+    /* during compilation:
         - if scope_level = 0: scope in which the variable is defined
         - if scope_level != 0: index into fd->vars of the next
           variable in the same or enclosing lexical scope
@@ -551,7 +584,7 @@ typedef struct JSVarDef {
        index into fd->vars of the next
        variable in the same or enclosing lexical scope
     */
-    int scope_next;    
+    int scope_next;
     uint8_t is_const : 1;
     uint8_t is_lexical : 1;
     uint8_t is_captured : 1;
@@ -594,9 +627,9 @@ typedef struct JSFunctionBytecode {
     uint8_t super_allowed : 1;
     uint8_t arguments_allowed : 1;
     uint8_t has_debug : 1;
-    uint8_t backtrace_barrier : 1; /* stop backtrace on this function */
     uint8_t read_only_bytecode : 1;
-    /* XXX: 4 bits available */
+    uint8_t is_direct_or_indirect_eval : 1; /* used by JS_GetScriptOrModuleName() */
+    /* XXX: 10 bits available */
     uint8_t *byte_code_buf; /* (self pointer) */
     int byte_code_len;
     JSAtom func_name;
@@ -613,8 +646,7 @@ typedef struct JSFunctionBytecode {
     struct {
         /* debug info, move to separate structure to save memory? */
         JSAtom filename;
-        int line_num;
-        int source_len;
+        int source_len; 
         int pc2line_len;
         uint8_t *pc2line_buf;
         char *source;
@@ -636,9 +668,11 @@ typedef enum JSIteratorKindEnum {
 
 typedef struct JSForInIterator {
     JSValue obj;
-    BOOL is_array;
-    uint32_t array_length;
     uint32_t idx;
+    uint32_t atom_count;
+    uint8_t in_prototype_chain;
+    uint8_t is_array;
+    JSPropertyEnum *tab_atom; /* is_array = FALSE */
 } JSForInIterator;
 
 typedef struct JSRegExp {
@@ -672,21 +706,16 @@ typedef struct JSTypedArray {
 } JSTypedArray;
 
 typedef struct JSAsyncFunctionState {
-    JSValue this_val; /* 'this' generator argument */
+    JSGCObjectHeader header;
+    JSValue this_val; /* 'this' argument */
     int argc; /* number of function arguments */
     BOOL throw_flag; /* used to throw an exception in JS_CallInternal() */
+    BOOL is_completed; /* TRUE if the function has returned. The stack
+                          frame is no longer valid */
+    JSValue resolving_funcs[2]; /* only used in JS async functions */
     JSStackFrame frame;
 } JSAsyncFunctionState;
 
-/* XXX: could use an object instead to avoid the
-   JS_TAG_ASYNC_FUNCTION tag for the GC */
-typedef struct JSAsyncFunctionData {
-    JSGCObjectHeader header; /* must come first */
-    JSValue resolving_funcs[2];
-    BOOL is_active; /* true if the async function state is valid */
-    JSAsyncFunctionState func_state;
-} JSAsyncFunctionData;
-
 typedef enum {
    /* binary operators */
    JS_OVOP_ADD,
@@ -737,6 +766,7 @@ typedef struct {
 typedef struct JSReqModuleEntry {
     JSAtom module_name;
     JSModuleDef *module; /* used using resolution */
+    JSValue attributes; /* JS_UNDEFINED or an object contains the attributes as key/value */
 } JSReqModuleEntry;
 
 typedef enum JSExportTypeEnum {
@@ -764,12 +794,22 @@ typedef struct JSStarExportEntry {
 
 typedef struct JSImportEntry {
     int var_idx; /* closure variable index */
+    BOOL is_star; /* import_name = '*' is a valid import name, so need a flag */
     JSAtom import_name;
     int req_module_idx; /* in req_module_entries */
 } JSImportEntry;
 
+typedef enum {
+    JS_MODULE_STATUS_UNLINKED,
+    JS_MODULE_STATUS_LINKING,
+    JS_MODULE_STATUS_LINKED,
+    JS_MODULE_STATUS_EVALUATING,
+    JS_MODULE_STATUS_EVALUATING_ASYNC,
+    JS_MODULE_STATUS_EVALUATED,
+} JSModuleStatus;
+
 struct JSModuleDef {
-    JSRefCountHeader header; /* must come first, 32-bit */
+    JSGCObjectHeader header; /* must come first */
     JSAtom module_name;
     struct list_head link;
 
@@ -792,21 +832,36 @@ struct JSModuleDef {
     JSValue module_ns;
     JSValue func_obj; /* only used for JS modules */
     JSModuleInitFunc *init_func; /* only used for C modules */
+    BOOL has_tla : 8; /* true if func_obj contains await */
     BOOL resolved : 8;
     BOOL func_created : 8;
-    BOOL instantiated : 8;
-    BOOL evaluated : 8;
-    BOOL eval_mark : 8; /* temporary use during js_evaluate_module() */
+    JSModuleStatus status : 8;
+    /* temp use during js_module_link() & js_module_evaluate() */
+    int dfs_index, dfs_ancestor_index;
+    JSModuleDef *stack_prev;
+    /* temp use during js_module_evaluate() */
+    JSModuleDef **async_parent_modules;
+    int async_parent_modules_count;
+    int async_parent_modules_size;
+    int pending_async_dependencies;
+    BOOL async_evaluation; /* true: async_evaluation_timestamp corresponds to [[AsyncEvaluationOrder]] 
+                              false: [[AsyncEvaluationOrder]] is UNSET or DONE */
+    int64_t async_evaluation_timestamp;
+    JSModuleDef *cycle_root;
+    JSValue promise; /* corresponds to spec field: capability */
+    JSValue resolving_funcs[2]; /* corresponds to spec field: capability */
+
     /* true if evaluation yielded an exception. It is saved in
        eval_exception */
-    BOOL eval_has_exception : 8; 
+    BOOL eval_has_exception : 8;
     JSValue eval_exception;
     JSValue meta_obj; /* for import.meta */
+    JSValue private_value; /* private value for C modules */
 };
 
 typedef struct JSJobEntry {
     struct list_head link;
-    JSContext *ctx;
+    JSContext *realm;
     JSJobFunc *job_func;
     int argc;
     JSValue argv[0];
@@ -867,24 +922,24 @@ struct JSObject {
         struct {
             int __gc_ref_count; /* corresponds to header.ref_count */
             uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
-            
+
             uint8_t extensible : 1;
             uint8_t free_mark : 1; /* only used when freeing objects with cycles */
             uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
             uint8_t fast_array : 1; /* TRUE if u.array is used for get/put (for JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS and typed arrays) */
             uint8_t is_constructor : 1; /* TRUE if object is a constructor function */
-            uint8_t is_uncatchable_error : 1; /* if TRUE, error is not catchable */
+            uint8_t has_immutable_prototype : 1; /* cannot modify the prototype */
             uint8_t tmp_mark : 1; /* used in JS_WriteObjectRec() */
             uint8_t is_HTMLDDA : 1; /* specific annex B IsHtmlDDA behavior */
             uint16_t class_id; /* see JS_CLASS_x */
         };
     };
-    /* byte offsets: 16/24 */
+    /* count the number of weak references to this object. The object
+       structure is freed only if header.ref_count = 0 and
+       weakref_count = 0 */
+    uint32_t weakref_count; 
     JSShape *shape; /* prototype and property names + flag */
     JSProperty *prop; /* array of properties */
-    /* byte offsets: 24/40 */
-    struct JSMapRecord *first_weak_ref; /* XXX: use a bit and an external hash table? */
-    /* byte offsets: 28/48 */
     union {
         void *opaque;
         struct JSBoundFunction *bound_function; /* JS_CLASS_BOUND_FUNCTION */
@@ -892,10 +947,6 @@ struct JSObject {
         struct JSForInIterator *for_in_iterator; /* JS_CLASS_FOR_IN_ITERATOR */
         struct JSArrayBuffer *array_buffer; /* JS_CLASS_ARRAY_BUFFER, JS_CLASS_SHARED_ARRAY_BUFFER */
         struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_DATAVIEW */
-#ifdef CONFIG_BIGNUM
-        struct JSFloatEnv *float_env; /* JS_CLASS_FLOAT_ENV */
-        struct JSOperatorSetData *operator_set; /* JS_CLASS_OPERATOR_SET */
-#endif
         struct JSMapState *map_state;   /* JS_CLASS_MAP..JS_CLASS_WEAKSET */
         struct JSMapIteratorData *map_iterator_data; /* JS_CLASS_MAP_ITERATOR, JS_CLASS_SET_ITERATOR */
         struct JSArrayIteratorData *array_iterator_data; /* JS_CLASS_ARRAY_ITERATOR, JS_CLASS_STRING_ITERATOR */
@@ -904,7 +955,7 @@ struct JSObject {
         struct JSProxyData *proxy_data; /* JS_CLASS_PROXY */
         struct JSPromiseData *promise_data; /* JS_CLASS_PROMISE */
         struct JSPromiseFunctionData *promise_function_data; /* JS_CLASS_PROMISE_RESOLVE_FUNCTION, JS_CLASS_PROMISE_REJECT_FUNCTION */
-        struct JSAsyncFunctionData *async_function_data; /* JS_CLASS_ASYNC_FUNCTION_RESOLVE, JS_CLASS_ASYNC_FUNCTION_REJECT */
+        struct JSAsyncFunctionState *async_function_data; /* JS_CLASS_ASYNC_FUNCTION_RESOLVE, JS_CLASS_ASYNC_FUNCTION_REJECT */
         struct JSAsyncFromSyncIteratorData *async_from_sync_iterator_data; /* JS_CLASS_ASYNC_FROM_SYNC_ITERATOR */
         struct JSAsyncGeneratorData *async_generator_data; /* JS_CLASS_ASYNC_GENERATOR */
         struct { /* JS_CLASS_BYTECODE_FUNCTION: 12/24 bytes */
@@ -927,7 +978,7 @@ struct JSObject {
                 struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
             } u1;
             union {
-                JSValue *values;        /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */ 
+                JSValue *values;        /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */
                 void *ptr;              /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
                 int8_t *int8_ptr;       /* JS_CLASS_INT8_ARRAY */
                 uint8_t *uint8_ptr;     /* JS_CLASS_UINT8_ARRAY, JS_CLASS_UINT8C_ARRAY */
@@ -937,6 +988,7 @@ struct JSObject {
                 uint32_t *uint32_ptr;   /* JS_CLASS_UINT32_ARRAY */
                 int64_t *int64_ptr;     /* JS_CLASS_INT64_ARRAY */
                 uint64_t *uint64_ptr;   /* JS_CLASS_UINT64_ARRAY */
+                uint16_t *fp16_ptr;     /* JS_CLASS_FLOAT16_ARRAY */
                 float *float_ptr;       /* JS_CLASS_FLOAT32_ARRAY */
                 double *double_ptr;     /* JS_CLASS_FLOAT64_ARRAY */
             } u;
@@ -945,8 +997,29 @@ struct JSObject {
         JSRegExp regexp;    /* JS_CLASS_REGEXP: 8/16 bytes */
         JSValue object_data;    /* for JS_SetObjectData(): 8/16/16 bytes */
     } u;
-    /* byte sizes: 40/48/72 */
 };
+
+typedef struct JSMapRecord {
+    int ref_count; /* used during enumeration to avoid freeing the record */
+    BOOL empty : 8; /* TRUE if the record is deleted */
+    struct list_head link;
+    struct JSMapRecord *hash_next;
+    JSValue key;
+    JSValue value;
+} JSMapRecord;
+
+typedef struct JSMapState {
+    BOOL is_weak; /* TRUE if WeakSet/WeakMap */
+    struct list_head records; /* list of JSMapRecord.link */
+    uint32_t record_count;
+    JSMapRecord **hash_table;
+    int hash_bits;
+    uint32_t hash_size; /* = 2 ^ hash_bits */
+    uint32_t record_count_threshold; /* count at which a hash table
+                                        resize is needed */
+    JSWeakRefHeader weakref_header; /* only used if is_weak = TRUE */
+} JSMapState;
+
 enum {
     __JS_ATOM_NULL = JS_ATOM_NULL,
 #define DEF(name, str) JS_ATOM_ ## name,
@@ -1021,29 +1094,22 @@ static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
                              JSValueConst val, int flags, int scope_idx);
 JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
 static __maybe_unused void JS_DumpAtoms(JSRuntime *rt);
-static __maybe_unused void JS_DumpString(JSRuntime *rt,
-                                                  const JSString *p);
+static __maybe_unused void JS_DumpString(JSRuntime *rt, const JSString *p);
 static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt);
 static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p);
 static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p);
-static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
-                                                      JSValueConst val);
-static __maybe_unused void JS_DumpValue(JSContext *ctx, JSValueConst val);
-static __maybe_unused void JS_PrintValue(JSContext *ctx,
-                                                  const char *str,
-                                                  JSValueConst val);
+static __maybe_unused void JS_DumpValueRT(JSRuntime *rt, const char *str, JSValueConst val);
+static __maybe_unused void JS_DumpValue(JSContext *ctx, const char *str, JSValueConst val);
 static __maybe_unused void JS_DumpShapes(JSRuntime *rt);
+static void js_dump_value_write(void *opaque, const char *buf, size_t len);
 static JSValue js_function_apply(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv, int magic);
 static void js_array_finalizer(JSRuntime *rt, JSValue val);
-static void js_array_mark(JSRuntime *rt, JSValueConst val,
-                          JS_MarkFunc *mark_func);
+static void js_array_mark(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
 static void js_object_data_finalizer(JSRuntime *rt, JSValue val);
-static void js_object_data_mark(JSRuntime *rt, JSValueConst val,
-                                JS_MarkFunc *mark_func);
+static void js_object_data_mark(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
 static void js_c_function_finalizer(JSRuntime *rt, JSValue val);
-static void js_c_function_mark(JSRuntime *rt, JSValueConst val,
-                               JS_MarkFunc *mark_func);
+static void js_c_function_mark(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
 static void js_bytecode_function_finalizer(JSRuntime *rt, JSValue val);
 static void js_bytecode_function_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
@@ -1082,16 +1148,18 @@ static void js_promise_mark(JSRuntime *rt, JSValueConst val,
 static void js_promise_resolve_function_finalizer(JSRuntime *rt, JSValue val);
 static void js_promise_resolve_function_mark(JSRuntime *rt, JSValueConst val,
                                 JS_MarkFunc *mark_func);
-#ifdef CONFIG_BIGNUM
-static void js_operator_set_finalizer(JSRuntime *rt, JSValue val);
-static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
-                                 JS_MarkFunc *mark_func);
-#endif
+
+#define HINT_STRING  0
+#define HINT_NUMBER  1
+#define HINT_NONE    2
+#define HINT_FORCE_ORDINARY (1 << 4) // don't try Symbol.toPrimitive
+static JSValue JS_ToPrimitiveFree(JSContext *ctx, JSValue val, int hint);
 static JSValue JS_ToStringFree(JSContext *ctx, JSValue val);
 static int JS_ToBoolFree(JSContext *ctx, JSValue val);
 static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val);
 static int JS_ToFloat64Free(JSContext *ctx, double *pres, JSValue val);
 static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val);
+static JSValue js_new_string8_len(JSContext *ctx, const char *buf, int len);
 static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
                                  JSValueConst flags);
 static JSValue js_regexp_constructor_internal(JSContext *ctx, JSValueConst ctor,
@@ -1108,58 +1176,24 @@ typedef enum JSStrictEqModeEnum {
 
 static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
                           JSStrictEqModeEnum eq_mode);
-static BOOL js_strict_eq(JSContext *ctx, JSValue op1, JSValue op2);
+static BOOL js_strict_eq(JSContext *ctx, JSValueConst op1, JSValueConst op2);
 static BOOL js_same_value(JSContext *ctx, JSValueConst op1, JSValueConst op2);
 static BOOL js_same_value_zero(JSContext *ctx, JSValueConst op1, JSValueConst op2);
 static JSValue JS_ToObject(JSContext *ctx, JSValueConst val);
 static JSValue JS_ToObjectFree(JSContext *ctx, JSValue val);
 static JSProperty *add_property(JSContext *ctx,
                                 JSObject *p, JSAtom prop, int prop_flags);
-static JSValue JS_NewBigInt(JSContext *ctx);
-static inline bf_t *JS_GetBigInt(JSValueConst val)
-{
-    JSBigFloat *p = JS_VALUE_GET_PTR(val);
-    return &p->num;
-}
-static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
-                                 BOOL convert_to_safe_integer);
-static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val);
 static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val);
-static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val);
-static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf);
-#ifdef CONFIG_BIGNUM
-static void js_float_env_finalizer(JSRuntime *rt, JSValue val);
-static JSValue JS_NewBigFloat(JSContext *ctx);
-static inline bf_t *JS_GetBigFloat(JSValueConst val)
-{
-    JSBigFloat *p = JS_VALUE_GET_PTR(val);
-    return &p->num;
-}
-static JSValue JS_NewBigDecimal(JSContext *ctx);
-static inline bfdec_t *JS_GetBigDecimal(JSValueConst val)
-{
-    JSBigDecimal *p = JS_VALUE_GET_PTR(val);
-    return &p->num;
-}
-static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val);
-static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
-                                   BOOL allow_null_or_undefined);
-static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val);
-#endif
 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
 static JSValue JS_ThrowTypeErrorRevokedProxy(JSContext *ctx);
-static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj);
-static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
-                                   JSValueConst proto_val, BOOL throw_flag);
-static int js_proxy_isExtensible(JSContext *ctx, JSValueConst obj);
-static int js_proxy_preventExtensions(JSContext *ctx, JSValueConst obj);
-static int js_proxy_isArray(JSContext *ctx, JSValueConst obj);
+
+static int js_resolve_proxy(JSContext *ctx, JSValueConst *pval, int throw_exception);
 static int JS_CreateProperty(JSContext *ctx, JSObject *p,
                              JSAtom prop, JSValueConst val,
                              JSValueConst getter, JSValueConst setter,
                              int flags);
-static int js_string_memcmp(const JSString *p1, const JSString *p2, int len);
-static void reset_weak_ref(JSRuntime *rt, JSObject *p);
+static int js_string_memcmp(const JSString *p1, int pos1, const JSString *p2,
+                            int pos2, int len);
 static JSValue js_array_buffer_constructor3(JSContext *ctx,
                                             JSValueConst new_target,
                                             uint64_t len, JSClassID class_id,
@@ -1171,11 +1205,17 @@ static JSValue js_typed_array_constructor(JSContext *ctx,
                                           JSValueConst this_val,
                                           int argc, JSValueConst *argv,
                                           int classid);
+static JSValue js_typed_array_constructor_ta(JSContext *ctx,
+                                             JSValueConst new_target,
+                                             JSValueConst src_obj,
+                                             int classid);
 static BOOL typed_array_is_detached(JSContext *ctx, JSObject *p);
 static uint32_t typed_array_get_length(JSContext *ctx, JSObject *p);
 static JSValue JS_ThrowTypeErrorDetachedArrayBuffer(JSContext *ctx);
 static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf, int var_idx,
                              BOOL is_arg);
+static void __async_func_free(JSRuntime *rt, JSAsyncFunctionState *s);
+static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s);
 static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
                                           JSValueConst this_obj,
                                           int argc, JSValueConst *argv,
@@ -1186,11 +1226,11 @@ static void js_async_function_resolve_mark(JSRuntime *rt, JSValueConst val,
 static JSValue JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                const char *input, size_t input_len,
                                const char *filename, int flags, int scope_idx);
-static void js_free_module_def(JSContext *ctx, JSModuleDef *m);
+static void js_free_module_def(JSRuntime *rt, JSModuleDef *m);
 static void js_mark_module_def(JSRuntime *rt, JSModuleDef *m,
                                JS_MarkFunc *mark_func);
 static JSValue js_import_meta(JSContext *ctx);
-static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier);
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier, JSValueConst options);
 static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref);
 static JSValue js_new_promise_capability(JSContext *ctx,
                                          JSValue *resolving_funcs,
@@ -1201,6 +1241,8 @@ static __exception int perform_promise_then(JSContext *ctx,
                                             JSValueConst *cap_resolving_funcs);
 static JSValue js_promise_resolve(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv, int magic);
+static JSValue js_promise_then(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv);
 static int js_string_compare(JSContext *ctx,
                              const JSString *p1, const JSString *p2);
 static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val);
@@ -1212,8 +1254,6 @@ static JSValue JS_ToNumberFree(JSContext *ctx, JSValue val);
 static int JS_GetOwnPropertyInternal(JSContext *ctx, JSPropertyDescriptor *desc,
                                      JSObject *p, JSAtom prop);
 static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc);
-static void async_func_mark(JSRuntime *rt, JSAsyncFunctionState *s,
-                            JS_MarkFunc *mark_func);
 static void JS_AddIntrinsicBasicObjects(JSContext *ctx);
 static void js_free_shape(JSRuntime *rt, JSShape *sh);
 static void js_free_shape_null(JSRuntime *rt, JSShape *sh);
@@ -1241,13 +1281,26 @@ static JSAtom js_symbol_to_atom(JSContext *ctx, JSValue val);
 static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
                           JSGCObjectTypeEnum type);
 static void remove_gc_object(JSGCObjectHeader *h);
-static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s);
 static JSValue js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque);
 static JSValue js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
                                  void *opaque);
 static JSValue JS_InstantiateFunctionListItem2(JSContext *ctx, JSObject *p,
                                                JSAtom atom, void *opaque);
-void JS_SetUncatchableError(JSContext *ctx, JSValueConst val, BOOL flag);
+static JSValue js_object_groupBy(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv, int is_map);
+static void map_delete_weakrefs(JSRuntime *rt, JSWeakRefHeader *wh);
+static void weakref_delete_weakref(JSRuntime *rt, JSWeakRefHeader *wh);
+static void finrec_delete_weakref(JSRuntime *rt, JSWeakRefHeader *wh);
+static void JS_RunGCInternal(JSRuntime *rt, BOOL remove_weak_objects);
+static JSValue js_array_from_iterator(JSContext *ctx, uint32_t *plen,
+                                      JSValueConst obj, JSValueConst method);
+static int js_string_find_invalid_codepoint(JSString *p);
+static JSValue js_regexp_toString(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv);
+static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv, int magic);
+static JSValue js_error_toString(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv);
 
 static const JSClassExoticMethods js_arguments_exotic_methods;
 static const JSClassExoticMethods js_string_exotic_methods;
@@ -1309,13 +1362,6 @@ void *js_mallocz_rt(JSRuntime *rt, size_t size)
     return memset(ptr, 0, size);
 }
 
-/* called by libbf */
-static void *js_bf_realloc(void *opaque, void *ptr, size_t size)
-{
-    JSRuntime *rt = opaque;
-    return js_realloc_rt(rt, ptr, size);
-}
-
 /* Throw out of memory in case of error */
 void *js_malloc(JSContext *ctx, size_t size)
 {
@@ -1431,6 +1477,10 @@ static inline int is_digit(int c) {
     return c >= '0' && c <= '9';
 }
 
+static inline int string_get(const JSString *p, int idx) {
+    return p->is_wide_char ? p->u.str16[idx] : p->u.str8[idx];
+}
+
 typedef struct JSClassShortDef {
     JSAtom class_name;
     JSClassFinalizer *finalizer;
@@ -1467,16 +1517,11 @@ static JSClassShortDef const js_std_class_def[] = {
     { JS_ATOM_Uint32Array, js_typed_array_finalizer, js_typed_array_mark },     /* JS_CLASS_UINT32_ARRAY */
     { JS_ATOM_BigInt64Array, js_typed_array_finalizer, js_typed_array_mark },   /* JS_CLASS_BIG_INT64_ARRAY */
     { JS_ATOM_BigUint64Array, js_typed_array_finalizer, js_typed_array_mark },  /* JS_CLASS_BIG_UINT64_ARRAY */
+    { JS_ATOM_Float16Array, js_typed_array_finalizer, js_typed_array_mark },    /* JS_CLASS_FLOAT16_ARRAY */
     { JS_ATOM_Float32Array, js_typed_array_finalizer, js_typed_array_mark },    /* JS_CLASS_FLOAT32_ARRAY */
     { JS_ATOM_Float64Array, js_typed_array_finalizer, js_typed_array_mark },    /* JS_CLASS_FLOAT64_ARRAY */
     { JS_ATOM_DataView, js_typed_array_finalizer, js_typed_array_mark },        /* JS_CLASS_DATAVIEW */
     { JS_ATOM_BigInt, js_object_data_finalizer, js_object_data_mark },      /* JS_CLASS_BIG_INT */
-#ifdef CONFIG_BIGNUM
-    { JS_ATOM_BigFloat, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_FLOAT */
-    { JS_ATOM_BigFloatEnv, js_float_env_finalizer, NULL },      /* JS_CLASS_FLOAT_ENV */
-    { JS_ATOM_BigDecimal, js_object_data_finalizer, js_object_data_mark },    /* JS_CLASS_BIG_DECIMAL */
-    { JS_ATOM_OperatorSet, js_operator_set_finalizer, js_operator_set_mark },    /* JS_CLASS_OPERATOR_SET */
-#endif
     { JS_ATOM_Map, js_map_finalizer, js_map_mark },             /* JS_CLASS_MAP */
     { JS_ATOM_Set, js_map_finalizer, js_map_mark },             /* JS_CLASS_SET */
     { JS_ATOM_WeakMap, js_map_finalizer, js_map_mark },         /* JS_CLASS_WEAKMAP */
@@ -1506,61 +1551,6 @@ static int init_class_range(JSRuntime *rt, JSClassShortDef const *tab,
     return 0;
 }
 
-static JSValue JS_ThrowUnsupportedOperation(JSContext *ctx)
-{
-    return JS_ThrowTypeError(ctx, "unsupported operation");
-}
-
-static JSValue invalid_to_string(JSContext *ctx, JSValueConst val)
-{
-    return JS_ThrowUnsupportedOperation(ctx);
-}
-
-static JSValue invalid_from_string(JSContext *ctx, const char *buf,
-                                   int radix, int flags, slimb_t *pexponent)
-{
-    return JS_NAN;
-}
-
-static int invalid_unary_arith(JSContext *ctx,
-                               JSValue *pres, OPCodeEnum op, JSValue op1)
-{
-    JS_FreeValue(ctx, op1);
-    JS_ThrowUnsupportedOperation(ctx);
-    return -1;
-}
-
-static int invalid_binary_arith(JSContext *ctx, OPCodeEnum op,
-                                JSValue *pres, JSValue op1, JSValue op2)
-{
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    JS_ThrowUnsupportedOperation(ctx);
-    return -1;
-}
-
-static JSValue invalid_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
-                                            int64_t exponent)
-{
-    return JS_ThrowUnsupportedOperation(ctx);
-}
-
-static int invalid_mul_pow10(JSContext *ctx, JSValue *sp)
-{
-    JS_ThrowUnsupportedOperation(ctx);
-    return -1;
-}
-
-static void set_dummy_numeric_ops(JSNumericOperations *ops)
-{
-    ops->to_string = invalid_to_string;
-    ops->from_string = invalid_from_string;
-    ops->unary_arith = invalid_unary_arith;
-    ops->binary_arith = invalid_binary_arith;
-    ops->mul_pow10_to_float64 = invalid_mul_pow10_to_float64;
-    ops->mul_pow10 = invalid_mul_pow10;
-}
-
 #if !defined(CONFIG_STACK_CHECK)
 /* no stack limitation */
 static inline uintptr_t js_get_stack_pointer(void)
@@ -1608,18 +1598,12 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->malloc_state = ms;
     rt->malloc_gc_threshold = 256 * 1024;
 
-    bf_context_init(&rt->bf_ctx, js_bf_realloc, rt);
-    set_dummy_numeric_ops(&rt->bigint_ops);
-#ifdef CONFIG_BIGNUM
-    set_dummy_numeric_ops(&rt->bigfloat_ops);
-    set_dummy_numeric_ops(&rt->bigdecimal_ops);
-#endif
-
     init_list_head(&rt->context_list);
     init_list_head(&rt->gc_obj_list);
     init_list_head(&rt->gc_zero_ref_count_list);
     rt->gc_phase = JS_GC_PHASE_NONE;
-    
+    init_list_head(&rt->weakref_list);
+
 #ifdef DUMP_LEAKS
     init_list_head(&rt->string_list);
 #endif
@@ -1646,7 +1630,7 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     rt->stack_size = JS_DEFAULT_STACK_SIZE;
     JS_UpdateStackTop(rt);
 
-    rt->current_exception = JS_NULL;
+    rt->current_exception = JS_UNINITIALIZED;
 
     return rt;
  fail:
@@ -1665,19 +1649,19 @@ void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque)
 }
 
 /* default memory allocation functions with memory limitation */
-static inline size_t js_def_malloc_usable_size(void *ptr)
+static size_t js_def_malloc_usable_size(const void *ptr)
 {
 #if defined(__APPLE__)
     return malloc_size(ptr);
 #elif defined(_WIN32)
-    return _msize(ptr);
+    return _msize((void *)ptr);
 #elif defined(EMSCRIPTEN)
     return 0;
-#elif defined(__linux__)
-    return malloc_usable_size(ptr);
+#elif defined(__linux__) || defined(__GLIBC__)
+    return malloc_usable_size((void *)ptr);
 #else
     /* change this to `return 0;` if compilation fails */
-    return malloc_usable_size(ptr);
+    return malloc_usable_size((void *)ptr);
 #endif
 }
 
@@ -1741,18 +1725,7 @@ static const JSMallocFunctions def_malloc_funcs = {
     js_def_malloc,
     js_def_free,
     js_def_realloc,
-#if defined(__APPLE__)
-    malloc_size,
-#elif defined(_WIN32)
-    (size_t (*)(const void *))_msize,
-#elif defined(EMSCRIPTEN)
-    NULL,
-#elif defined(__linux__)
-    (size_t (*)(const void *))malloc_usable_size,
-#else
-    /* change this to `NULL,` if compilation fails */
-    malloc_usable_size,
-#endif
+    js_def_malloc_usable_size,
 };
 
 JSRuntime *JS_NewRuntime(void)
@@ -1792,6 +1765,16 @@ void JS_SetSharedArrayBufferFunctions(JSRuntime *rt,
     rt->sab_funcs = *sf;
 }
 
+void JS_SetStripInfo(JSRuntime *rt, int flags)
+{
+    rt->strip_flags = flags;
+}
+
+int JS_GetStripInfo(JSRuntime *rt)
+{
+    return rt->strip_flags;
+}
+
 /* return 0 if OK, < 0 if exception */
 int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
                   int argc, JSValueConst *argv)
@@ -1803,7 +1786,7 @@ int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
     e = js_malloc(ctx, sizeof(*e) + argc * sizeof(JSValue));
     if (!e)
         return -1;
-    e->ctx = ctx;
+    e->realm = JS_DupContext(ctx);
     e->job_func = job_func;
     e->argc = argc;
     for(i = 0; i < argc; i++) {
@@ -1819,7 +1802,10 @@ BOOL JS_IsJobPending(JSRuntime *rt)
 }
 
 /* return < 0 if exception, 0 if no job pending, 1 if a job was
-   executed successfully. the context of the job is stored in '*pctx' */
+   executed successfully. The context of the job is stored in '*pctx'
+   if pctx != NULL. It may be NULL if the context was already
+   destroyed or if no job was pending. The 'pctx' parameter is now
+   absolete. */
 int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
 {
     JSContext *ctx;
@@ -1828,15 +1814,16 @@ int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
     int i, ret;
 
     if (list_empty(&rt->job_list)) {
-        *pctx = NULL;
+        if (pctx)
+            *pctx = NULL;
         return 0;
     }
 
     /* get the first pending job and execute it */
     e = list_entry(rt->job_list.next, JSJobEntry, link);
     list_del(&e->link);
-    ctx = e->ctx;
-    res = e->job_func(e->ctx, e->argc, (JSValueConst *)e->argv);
+    ctx = e->realm;
+    res = e->job_func(ctx, e->argc, (JSValueConst *)e->argv);
     for(i = 0; i < e->argc; i++)
         JS_FreeValue(ctx, e->argv[i]);
     if (JS_IsException(res))
@@ -1845,7 +1832,13 @@ int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
         ret = 1;
     JS_FreeValue(ctx, res);
     js_free(ctx, e);
-    *pctx = ctx;
+    if (pctx) {
+        if (ctx->header.ref_count > 1)
+            *pctx = ctx;
+        else
+            *pctx = NULL;
+    }
+    JS_FreeContext(ctx);
     return ret;
 }
 
@@ -1926,11 +1919,14 @@ void JS_FreeRuntime(JSRuntime *rt)
         JSJobEntry *e = list_entry(el, JSJobEntry, link);
         for(i = 0; i < e->argc; i++)
             JS_FreeValueRT(rt, e->argv[i]);
+        JS_FreeContext(e->realm);
         js_free_rt(rt, e);
     }
     init_list_head(&rt->job_list);
 
-    JS_RunGC(rt);
+    /* don't remove the weak objects to avoid create new jobs with
+       FinalizationRegistry */
+    JS_RunGCInternal(rt, FALSE);
 
 #ifdef DUMP_LEAKS
     /* leaking objects */
@@ -1972,6 +1968,7 @@ void JS_FreeRuntime(JSRuntime *rt)
     }
 #endif
     assert(list_empty(&rt->gc_obj_list));
+    assert(list_empty(&rt->weakref_list));
 
     /* free the classes */
     for(i = 0; i < rt->class_count; i++) {
@@ -1982,8 +1979,6 @@ void JS_FreeRuntime(JSRuntime *rt)
     }
     js_free_rt(rt, rt->class_array);
 
-    bf_context_end(&rt->bf_ctx);
-
 #ifdef DUMP_LEAKS
     /* only the atoms defined in JS_InitAtoms() should be left */
     {
@@ -2018,7 +2013,7 @@ void JS_FreeRuntime(JSRuntime *rt)
                         printf(")");
                         break;
                     case JS_ATOM_TYPE_SYMBOL:
-                        if (p->hash == JS_ATOM_HASH_SYMBOL) {
+                        if (p->hash != JS_ATOM_HASH_PRIVATE) {
                             printf("Symbol(");
                             JS_DumpString(rt, p);
                             printf(")");
@@ -2120,11 +2115,6 @@ JSContext *JS_NewContextRaw(JSRuntime *rt)
     }
     ctx->rt = rt;
     list_add_tail(&ctx->link, &rt->context_list);
-    ctx->bf_ctx = &rt->bf_ctx;
-#ifdef CONFIG_BIGNUM
-    ctx->fp_env.prec = 113;
-    ctx->fp_env.flags = bf_set_exp_bits(15) | BF_RNDN | BF_FLAG_SUBNORMAL;
-#endif
     for(i = 0; i < rt->class_count; i++)
         ctx->class_proto[i] = JS_NULL;
     ctx->array_ctor = JS_NULL;
@@ -2154,7 +2144,7 @@ JSContext *JS_NewContext(JSRuntime *rt)
     JS_AddIntrinsicMapSet(ctx);
     JS_AddIntrinsicTypedArrays(ctx);
     JS_AddIntrinsicPromise(ctx);
-    JS_AddIntrinsicBigInt(ctx);
+    JS_AddIntrinsicWeakRef(ctx);
     return ctx;
 }
 
@@ -2195,7 +2185,6 @@ JSValue JS_GetClassProto(JSContext *ctx, JSClassID class_id)
 typedef enum JSFreeModuleEnum {
     JS_FREE_MODULE_ALL,
     JS_FREE_MODULE_NOT_RESOLVED,
-    JS_FREE_MODULE_NOT_EVALUATED,
 } JSFreeModuleEnum;
 
 /* XXX: would be more efficient with separate module lists */
@@ -2205,9 +2194,14 @@ static void js_free_modules(JSContext *ctx, JSFreeModuleEnum flag)
     list_for_each_safe(el, el1, &ctx->loaded_modules) {
         JSModuleDef *m = list_entry(el, JSModuleDef, link);
         if (flag == JS_FREE_MODULE_ALL ||
-            (flag == JS_FREE_MODULE_NOT_RESOLVED && !m->resolved) ||
-            (flag == JS_FREE_MODULE_NOT_EVALUATED && !m->evaluated)) {
-            js_free_module_def(ctx, m);
+            (flag == JS_FREE_MODULE_NOT_RESOLVED && !m->resolved)) {
+            /* warning: the module may be referenced elsewhere. It
+               could be simpler to use an array instead of a list for
+               'ctx->loaded_modules' */
+            list_del(&m->link);
+            m->link.prev = NULL;
+            m->link.next = NULL;
+            JS_FreeValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
         }
     }
 }
@@ -2225,11 +2219,9 @@ static void JS_MarkContext(JSRuntime *rt, JSContext *ctx,
     int i;
     struct list_head *el;
 
-    /* modules are not seen by the GC, so we directly mark the objects
-       referenced by each module */
     list_for_each(el, &ctx->loaded_modules) {
         JSModuleDef *m = list_entry(el, JSModuleDef, link);
-        js_mark_module_def(rt, m, mark_func);
+        JS_MarkValue(rt, JS_MKPTR(JS_TAG_MODULE, m), mark_func);
     }
 
     JS_MarkValue(rt, ctx->global_obj, mark_func);
@@ -2265,7 +2257,7 @@ void JS_FreeContext(JSContext *ctx)
     if (--ctx->header.ref_count > 0)
         return;
     assert(ctx->header.ref_count == 0);
-    
+
 #ifdef DUMP_ATOMS
     JS_DumpAtoms(ctx->rt);
 #endif
@@ -2356,19 +2348,6 @@ static inline BOOL is_strict_mode(JSContext *ctx)
     return (sf && (sf->js_mode & JS_MODE_STRICT));
 }
 
-#ifdef CONFIG_BIGNUM
-static inline BOOL is_math_mode(JSContext *ctx)
-{
-    JSStackFrame *sf = ctx->rt->current_stack_frame;
-    return (sf && (sf->js_mode & JS_MODE_MATH));
-}
-#else
-static inline BOOL is_math_mode(JSContext *ctx)
-{
-    return FALSE;
-}
-#endif
-
 /* JSAtom support */
 
 #define JS_ATOM_TAG_INT (1U << 31)
@@ -2417,10 +2396,7 @@ static inline BOOL is_num_string(uint32_t *pval, const JSString *p)
     len = p->len;
     if (len == 0 || len > 10)
         return FALSE;
-    if (p->is_wide_char)
-        c = p->u.str16[0];
-    else
-        c = p->u.str8[0];
+    c = string_get(p, 0);
     if (is_num(c)) {
         if (c == '0') {
             if (len != 1)
@@ -2429,10 +2405,7 @@ static inline BOOL is_num_string(uint32_t *pval, const JSString *p)
         } else {
             n = c - '0';
             for(i = 1; i < len; i++) {
-                if (p->is_wide_char)
-                    c = p->u.str16[i];
-                else
-                    c = p->u.str8[i];
+                c = string_get(p, i);
                 if (!is_num(c))
                     return FALSE;
                 n64 = (uint64_t)n * 10 + (c - '0');
@@ -2477,10 +2450,35 @@ static uint32_t hash_string(const JSString *str, uint32_t h)
     return h;
 }
 
-static __maybe_unused void JS_DumpString(JSRuntime *rt,
-                                                  const JSString *p)
+static uint32_t hash_string_rope(JSValueConst val, uint32_t h)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        return hash_string(JS_VALUE_GET_STRING(val), h);
+    } else {
+        JSStringRope *r = JS_VALUE_GET_STRING_ROPE(val);
+        h = hash_string_rope(r->left, h);
+        return hash_string_rope(r->right, h);
+    }
+}
+
+static __maybe_unused void JS_DumpChar(FILE *fo, int c, int sep)
+{
+    if (c == sep || c == '\\') {
+        fputc('\\', fo);
+        fputc(c, fo);
+    } else if (c >= ' ' && c <= 126) {
+        fputc(c, fo);
+    } else if (c == '\n') {
+        fputc('\\', fo);
+        fputc('n', fo);
+    } else {
+        fprintf(fo, "\\u%04x", c);
+    }
+}
+
+static __maybe_unused void JS_DumpString(JSRuntime *rt, const JSString *p)
 {
-    int i, c, sep;
+    int i, sep;
 
     if (p == NULL) {
         printf("<null>");
@@ -2490,21 +2488,7 @@ static __maybe_unused void JS_DumpString(JSRuntime *rt,
     sep = (p->header.ref_count == 1) ? '\"' : '\'';
     putchar(sep);
     for(i = 0; i < p->len; i++) {
-        if (p->is_wide_char)
-            c = p->u.str16[i];
-        else
-            c = p->u.str8[i];
-        if (c == sep || c == '\\') {
-            putchar('\\');
-            putchar(c);
-        } else if (c >= ' ' && c <= 126) {
-            putchar(c);
-        } else if (c == '\n') {
-            putchar('\\');
-            putchar('n');
-        } else {
-            printf("\\u%04x", c);
-        }
+        JS_DumpChar(stdout, string_get(p, i), sep);
     }
     putchar(sep);
 }
@@ -2642,14 +2626,10 @@ static JSAtomKindEnum JS_AtomGetKind(JSContext *ctx, JSAtom v)
     case JS_ATOM_TYPE_GLOBAL_SYMBOL:
         return JS_ATOM_KIND_SYMBOL;
     case JS_ATOM_TYPE_SYMBOL:
-        switch(p->hash) {
-        case JS_ATOM_HASH_SYMBOL:
-            return JS_ATOM_KIND_SYMBOL;
-        case JS_ATOM_HASH_PRIVATE:
+        if (p->hash == JS_ATOM_HASH_PRIVATE)
             return JS_ATOM_KIND_PRIVATE;
-        default:
-            abort();
-        }
+        else
+            return JS_ATOM_KIND_SYMBOL;
     default:
         abort();
     }
@@ -2709,7 +2689,7 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
             if (p->hash == h &&
                 p->atom_type == atom_type &&
                 p->len == len &&
-                js_string_memcmp(p, str, len) == 0) {
+                js_string_memcmp(p, 0, str, 0, len) == 0) {
                 if (!__JS_AtomIsConst(i))
                     p->header.ref_count++;
                 goto done;
@@ -2719,7 +2699,7 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
     } else {
         h1 = 0; /* avoid warning */
         if (atom_type == JS_ATOM_TYPE_SYMBOL) {
-            h = JS_ATOM_HASH_SYMBOL;
+            h = 0;
         } else {
             h = JS_ATOM_HASH_PRIVATE;
             atom_type = JS_ATOM_TYPE_SYMBOL;
@@ -2847,6 +2827,7 @@ static JSAtom __JS_NewAtomInit(JSRuntime *rt, const char *str, int len,
     return __JS_NewAtom(rt, p, atom_type);
 }
 
+/* Warning: str must be ASCII only */
 static JSAtom __JS_FindAtom(JSRuntime *rt, const char *str, size_t len,
                             int atom_type)
 {
@@ -2911,7 +2892,13 @@ static void JS_FreeAtomStruct(JSRuntime *rt, JSAtomStruct *p)
 #ifdef DUMP_LEAKS
     list_del(&p->link);
 #endif
-    js_free_rt(rt, p);
+    if (p->atom_type == JS_ATOM_TYPE_SYMBOL &&
+        p->hash != JS_ATOM_HASH_PRIVATE && p->hash != 0) {
+        /* live weak references are still present on this object: keep
+           it */
+    } else {
+        js_free_rt(rt, p);
+    }
     rt->atom_count--;
     assert(rt->atom_count >= 0);
 }
@@ -2941,11 +2928,25 @@ static JSAtom JS_NewAtomStr(JSContext *ctx, JSString *p)
     return __JS_NewAtom(rt, p, JS_ATOM_TYPE_STRING);
 }
 
+/* XXX: optimize */
+static size_t count_ascii(const uint8_t *buf, size_t len)
+{
+    const uint8_t *p, *p_end;
+    p = buf;
+    p_end = buf + len;
+    while (p < p_end && *p < 128)
+        p++;
+    return p - buf;
+}
+
+/* str is UTF-8 encoded */
 JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len)
 {
     JSValue val;
 
-    if (len == 0 || !is_digit(*str)) {
+    if (len == 0 ||
+        (!is_digit(*str) &&
+         count_ascii((const uint8_t *)str, len) == len)) {
         JSAtom atom = __JS_FindAtom(ctx->rt, str, len, JS_ATOM_TYPE_STRING);
         if (atom)
             return atom;
@@ -2968,8 +2969,9 @@ JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n)
     } else {
         char buf[11];
         JSValue val;
-        snprintf(buf, sizeof(buf), "%u", n);
-        val = JS_NewString(ctx, buf);
+        size_t len;
+        len = u32toa(buf, n);
+        val = js_new_string8_len(ctx, buf, len);
         if (JS_IsException(val))
             return JS_ATOM_NULL;
         return __JS_NewAtom(ctx->rt, JS_VALUE_GET_STRING(val),
@@ -2984,8 +2986,9 @@ static JSAtom JS_NewAtomInt64(JSContext *ctx, int64_t n)
     } else {
         char buf[24];
         JSValue val;
-        snprintf(buf, sizeof(buf), "%" PRId64 , n);
-        val = JS_NewString(ctx, buf);
+        size_t len;
+        len = i64toa(buf, n);
+        val = js_new_string8_len(ctx, buf, len);
         if (JS_IsException(val))
             return JS_ATOM_NULL;
         return __JS_NewAtom(ctx->rt, JS_VALUE_GET_STRING(val),
@@ -3051,10 +3054,7 @@ static const char *JS_AtomGetStrRT(JSRuntime *rt, char *buf, int buf_size,
                         return (const char *)str->u.str8;
                 }
                 for(i = 0; i < str->len; i++) {
-                    if (str->is_wide_char)
-                        c = str->u.str16[i];
-                    else
-                        c = str->u.str8[i];
+                    c = string_get(str, i);
                     if ((q - buf) >= buf_size - UTF8_CHAR_LEN_MAX)
                         break;
                     if (c < 128) {
@@ -3080,8 +3080,8 @@ static JSValue __JS_AtomToValue(JSContext *ctx, JSAtom atom, BOOL force_string)
     char buf[ATOM_GET_STR_BUF_SIZE];
 
     if (__JS_AtomIsTaggedInt(atom)) {
-        snprintf(buf, sizeof(buf), "%u", __JS_AtomToUInt32(atom));
-        return JS_NewString(ctx, buf);
+        size_t len = u32toa(buf, __JS_AtomToUInt32(atom));
+        return js_new_string8_len(ctx, buf, len);
     } else {
         JSRuntime *rt = ctx->rt;
         JSAtomStruct *p;
@@ -3145,7 +3145,7 @@ static JSValue JS_AtomIsNumericIndex1(JSContext *ctx, JSAtom atom)
     JSRuntime *rt = ctx->rt;
     JSAtomStruct *p1;
     JSString *p;
-    int c, len, ret;
+    int c, ret;
     JSValue num, str;
 
     if (__JS_AtomIsTaggedInt(atom))
@@ -3154,54 +3154,24 @@ static JSValue JS_AtomIsNumericIndex1(JSContext *ctx, JSAtom atom)
     p1 = rt->atom_array[atom];
     if (p1->atom_type != JS_ATOM_TYPE_STRING)
         return JS_UNDEFINED;
+    switch(atom) {
+    case JS_ATOM_minus_zero:
+        return __JS_NewFloat64(ctx, -0.0);
+    case JS_ATOM_Infinity:
+        return __JS_NewFloat64(ctx, INFINITY);
+    case JS_ATOM_minus_Infinity:
+        return __JS_NewFloat64(ctx, -INFINITY);
+    case JS_ATOM_NaN:
+        return __JS_NewFloat64(ctx, NAN);
+    default:
+        break;
+    }
     p = p1;
-    len = p->len;
-    if (p->is_wide_char) {
-        const uint16_t *r = p->u.str16, *r_end = p->u.str16 + len;
-        if (r >= r_end)
-            return JS_UNDEFINED;
-        c = *r;
-        if (c == '-') {
-            if (r >= r_end)
-                return JS_UNDEFINED;
-            r++;
-            c = *r;
-            /* -0 case is specific */
-            if (c == '0' && len == 2)
-                goto minus_zero;
-        }
-        /* XXX: should test NaN, but the tests do not check it */
-        if (!is_num(c)) {
-            /* XXX: String should be normalized, therefore 8-bit only */
-            const uint16_t nfinity16[7] = { 'n', 'f', 'i', 'n', 'i', 't', 'y' };
-            if (!(c =='I' && (r_end - r) == 8 &&
-                  !memcmp(r + 1, nfinity16, sizeof(nfinity16))))
-                return JS_UNDEFINED;
-        }
-    } else {
-        const uint8_t *r = p->u.str8, *r_end = p->u.str8 + len;
-        if (r >= r_end)
-            return JS_UNDEFINED;
-        c = *r;
-        if (c == '-') {
-            if (r >= r_end)
-                return JS_UNDEFINED;
-            r++;
-            c = *r;
-            /* -0 case is specific */
-            if (c == '0' && len == 2) {
-            minus_zero:
-                return __JS_NewFloat64(ctx, -0.0);
-            }
-        }
-        if (!is_num(c)) {
-            if (!(c =='I' && (r_end - r) == 8 &&
-                  !memcmp(r + 1, "nfinity", 7)))
-                return JS_UNDEFINED;
-        }
-    }
-    /* XXX: bignum: would be better to only accept integer to avoid
-       relying on current floating point precision */
+    if (p->len == 0)
+        return JS_UNDEFINED;
+    c = string_get(p, 0);
+    if (!is_num(c) && c != '-')
+        return JS_UNDEFINED;
     /* this is ECMA CanonicalNumericIndexString primitive */
     num = JS_ToNumber(ctx, JS_MKPTR(JS_TAG_STRING, p));
     if (JS_IsException(num))
@@ -3257,59 +3227,24 @@ static BOOL JS_AtomSymbolHasDescription(JSContext *ctx, JSAtom v)
         return FALSE;
     p = rt->atom_array[v];
     return (((p->atom_type == JS_ATOM_TYPE_SYMBOL &&
-              p->hash == JS_ATOM_HASH_SYMBOL) ||
+              p->hash != JS_ATOM_HASH_PRIVATE) ||
              p->atom_type == JS_ATOM_TYPE_GLOBAL_SYMBOL) &&
             !(p->len == 0 && p->is_wide_char != 0));
 }
 
-static __maybe_unused void print_atom(JSContext *ctx, JSAtom atom)
-{
-    char buf[ATOM_GET_STR_BUF_SIZE];
-    const char *p;
-    int i;
-
-    /* XXX: should handle embedded null characters */
-    /* XXX: should move encoding code to JS_AtomGetStr */
-    p = JS_AtomGetStr(ctx, buf, sizeof(buf), atom);
-    for (i = 0; p[i]; i++) {
-        int c = (unsigned char)p[i];
-        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
-              (c == '_' || c == '$') || (c >= '0' && c <= '9' && i > 0)))
-            break;
-    }
-    if (i > 0 && p[i] == '\0') {
-        printf("%s", p);
-    } else {
-        putchar('"');
-        printf("%.*s", i, p);
-        for (; p[i]; i++) {
-            int c = (unsigned char)p[i];
-            if (c == '\"' || c == '\\') {
-                putchar('\\');
-                putchar(c);
-            } else if (c >= ' ' && c <= 126) {
-                putchar(c);
-            } else if (c == '\n') {
-                putchar('\\');
-                putchar('n');
-            } else {
-                printf("\\u%04x", c);
-            }
-        }
-        putchar('\"');
-    }
-}
-
 /* free with JS_FreeCString() */
-const char *JS_AtomToCString(JSContext *ctx, JSAtom atom)
+const char *JS_AtomToCStringLen(JSContext *ctx, size_t *plen, JSAtom atom)
 {
     JSValue str;
     const char *cstr;
 
     str = JS_AtomToString(ctx, atom);
-    if (JS_IsException(str))
+    if (JS_IsException(str)) {
+        if (plen)
+            *plen = 0;
         return NULL;
-    cstr = JS_ToCString(ctx, str);
+    }
+    cstr = JS_ToCStringLen(ctx, plen, str);
     JS_FreeValue(ctx, str);
     return cstr;
 }
@@ -3322,7 +3257,7 @@ static JSAtom js_atom_concat_str(JSContext *ctx, JSAtom name, const char *str1)
     const char *cstr;
     char *cstr2;
     size_t len, len1;
-    
+
     str = JS_AtomToString(ctx, name);
     if (JS_IsException(str))
         return JS_ATOM_NULL;
@@ -3350,7 +3285,9 @@ static JSAtom js_atom_concat_str(JSContext *ctx, JSAtom name, const char *str1)
 static JSAtom js_atom_concat_num(JSContext *ctx, JSAtom name, uint32_t n)
 {
     char buf[16];
-    snprintf(buf, sizeof(buf), "%u", n);
+    size_t len;
+    len = u32toa(buf, n);
+    buf[len] = '\0';
     return js_atom_concat_str(ctx, name, buf);
 }
 
@@ -3361,19 +3298,37 @@ static inline BOOL JS_IsEmptyString(JSValueConst v)
 
 /* JSClass support */
 
+#ifdef CONFIG_ATOMICS
+static pthread_mutex_t js_class_id_mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
 /* a new class ID is allocated if *pclass_id != 0 */
 JSClassID JS_NewClassID(JSClassID *pclass_id)
 {
     JSClassID class_id;
-    /* XXX: make it thread safe */
+#ifdef CONFIG_ATOMICS
+    pthread_mutex_lock(&js_class_id_mutex);
+#endif
     class_id = *pclass_id;
     if (class_id == 0) {
         class_id = js_class_id_alloc++;
         *pclass_id = class_id;
     }
+#ifdef CONFIG_ATOMICS
+    pthread_mutex_unlock(&js_class_id_mutex);
+#endif
     return class_id;
 }
 
+JSClassID JS_GetClassID(JSValueConst v)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
+        return JS_INVALID_CLASS_ID;
+    p = JS_VALUE_GET_OBJ(v);
+    return p->class_id;
+}
+
 BOOL JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id)
 {
     return (class_id < rt->class_count &&
@@ -3448,7 +3403,7 @@ int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def)
     return ret;
 }
 
-static JSValue js_new_string8(JSContext *ctx, const uint8_t *buf, int len)
+static JSValue js_new_string8_len(JSContext *ctx, const char *buf, int len)
 {
     JSString *str;
 
@@ -3463,7 +3418,12 @@ static JSValue js_new_string8(JSContext *ctx, const uint8_t *buf, int len)
     return JS_MKPTR(JS_TAG_STRING, str);
 }
 
-static JSValue js_new_string16(JSContext *ctx, const uint16_t *buf, int len)
+static JSValue js_new_string8(JSContext *ctx, const char *buf)
+{
+    return js_new_string8_len(ctx, buf, strlen(buf));
+}
+
+static JSValue js_new_string16_len(JSContext *ctx, const uint16_t *buf, int len)
 {
     JSString *str;
     str = js_alloc_string(ctx, len, 1);
@@ -3477,10 +3437,10 @@ static JSValue js_new_string_char(JSContext *ctx, uint16_t c)
 {
     if (c < 0x100) {
         uint8_t ch8 = c;
-        return js_new_string8(ctx, &ch8, 1);
+        return js_new_string8_len(ctx, (const char *)&ch8, 1);
     } else {
         uint16_t ch16 = c;
-        return js_new_string16(ctx, &ch16, 1);
+        return js_new_string16_len(ctx, &ch16, 1);
     }
 }
 
@@ -3498,7 +3458,7 @@ static JSValue js_sub_string(JSContext *ctx, JSString *p, int start, int end)
             c |= p->u.str16[i];
         }
         if (c > 0xFF)
-            return js_new_string16(ctx, p->u.str16 + start, len);
+            return js_new_string16_len(ctx, p->u.str16 + start, len);
 
         str = js_alloc_string(ctx, len, 0);
         if (!str)
@@ -3509,7 +3469,7 @@ static JSValue js_sub_string(JSContext *ctx, JSString *p, int start, int end)
         str->u.str8[len] = '\0';
         return JS_MKPTR(JS_TAG_STRING, str);
     } else {
-        return js_new_string8(ctx, p->u.str8 + start, len);
+        return js_new_string8_len(ctx, (const char *)(p->u.str8 + start), len);
     }
 }
 
@@ -3668,28 +3628,23 @@ static int string_buffer_putc(StringBuffer *s, uint32_t c)
 {
     if (unlikely(c >= 0x10000)) {
         /* surrogate pair */
-        c -= 0x10000;
-        if (string_buffer_putc16(s, (c >> 10) + 0xd800))
+        if (string_buffer_putc16(s, get_hi_surrogate(c)))
             return -1;
-        c = (c & 0x3ff) + 0xdc00;
+        c = get_lo_surrogate(c);
     }
     return string_buffer_putc16(s, c);
 }
 
-static int string_get(const JSString *p, int idx) {
-    return p->is_wide_char ? p->u.str16[idx] : p->u.str8[idx];
-}
-
 static int string_getc(const JSString *p, int *pidx)
 {
     int idx, c, c1;
     idx = *pidx;
     if (p->is_wide_char) {
         c = p->u.str16[idx++];
-        if (c >= 0xd800 && c < 0xdc00 && idx < p->len) {
+        if (is_hi_surrogate(c) && idx < p->len) {
             c1 = p->u.str16[idx];
-            if (c1 >= 0xdc00 && c1 < 0xe000) {
-                c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+            if (is_lo_surrogate(c1)) {
+                c = from_surrogate(c, c1);
                 idx++;
             }
         }
@@ -3774,13 +3729,21 @@ static int string_buffer_concat_value(StringBuffer *s, JSValueConst v)
         return -1;
     }
     if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
-        v1 = JS_ToString(s->ctx, v);
-        if (JS_IsException(v1))
-            return string_buffer_set_error(s);
-        p = JS_VALUE_GET_STRING(v1);
-        res = string_buffer_concat(s, p, 0, p->len);
-        JS_FreeValue(s->ctx, v1);
-        return res;
+        if (JS_VALUE_GET_TAG(v) == JS_TAG_STRING_ROPE) {
+            JSStringRope *r = JS_VALUE_GET_STRING_ROPE(v);
+            /* recursion is acceptable because the rope depth is bounded */
+            if (string_buffer_concat_value(s, r->left))
+                return -1;
+            return string_buffer_concat_value(s, r->right);
+        } else {
+            v1 = JS_ToString(s->ctx, v);
+            if (JS_IsException(v1))
+                return string_buffer_set_error(s);
+            p = JS_VALUE_GET_STRING(v1);
+            res = string_buffer_concat(s, p, 0, p->len);
+            JS_FreeValue(s->ctx, v1);
+            return res;
+        }
     }
     p = JS_VALUE_GET_STRING(v);
     return string_buffer_concat(s, p, 0, p->len);
@@ -3860,18 +3823,16 @@ JSValue JS_NewStringLen(JSContext *ctx, const char *buf, size_t buf_len)
     uint32_t c;
     StringBuffer b_s, *b = &b_s;
     size_t len1;
-    
+
     p_start = (const uint8_t *)buf;
     p_end = p_start + buf_len;
-    p = p_start;
-    while (p < p_end && *p < 128)
-        p++;
-    len1 = p - p_start;
+    len1 = count_ascii(p_start, buf_len);
+    p = p_start + len1;
     if (len1 > JS_STRING_LEN_MAX)
         return JS_ThrowInternalError(ctx, "string too long");
     if (p == p_end) {
         /* ASCII string */
-        return js_new_string8(ctx, (const uint8_t *)buf, buf_len);
+        return js_new_string8_len(ctx, buf, buf_len);
     } else {
         if (string_buffer_init(ctx, b, buf_len))
             goto fail;
@@ -3887,9 +3848,8 @@ JSValue JS_NewStringLen(JSContext *ctx, const char *buf, size_t buf_len)
                 } else if (c <= 0x10FFFF) {
                     p = p_next;
                     /* surrogate pair */
-                    c -= 0x10000;
-                    string_buffer_putc16(b, (c >> 10) + 0xd800);
-                    c = (c & 0x3ff) + 0xdc00;
+                    string_buffer_putc16(b, get_hi_surrogate(c));
+                    c = get_lo_surrogate(c);
                 } else {
                     /* invalid char */
                     c = 0xfffd;
@@ -3945,11 +3905,6 @@ static JSValue JS_ConcatString3(JSContext *ctx, const char *str1,
     return JS_EXCEPTION;
 }
 
-JSValue JS_NewString(JSContext *ctx, const char *str)
-{
-    return JS_NewStringLen(ctx, str, strlen(str));
-}
-
 JSValue JS_NewAtomString(JSContext *ctx, const char *str)
 {
     JSAtom atom = JS_NewAtom(ctx, str);
@@ -4027,13 +3982,12 @@ const char *JS_ToCStringLen2(JSContext *ctx, size_t *plen, JSValueConst val1, BO
             if (c < 0x80) {
                 *q++ = c;
             } else {
-                if (c >= 0xd800 && c < 0xdc00) {
+                if (is_hi_surrogate(c)) {
                     if (pos < len && !cesu8) {
                         c1 = src[pos];
-                        if (c1 >= 0xdc00 && c1 < 0xe000) {
+                        if (is_lo_surrogate(c1)) {
                             pos++;
-                            /* surrogate pair */
-                            c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+                            c = from_surrogate(c, c1);
                         } else {
                             /* Keep unmatched surrogate code points */
                             /* c = 0xfffd; */ /* error */
@@ -4066,7 +4020,7 @@ void JS_FreeCString(JSContext *ctx, const char *ptr)
     if (!ptr)
         return;
     /* purposely removing constness */
-    p = (JSString *)(void *)(ptr - offsetof(JSString, u));
+    p = container_of(ptr, JSString, u);
     JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, p));
 }
 
@@ -4092,20 +4046,21 @@ static int memcmp16(const uint16_t *src1, const uint16_t *src2, int len)
     return 0;
 }
 
-static int js_string_memcmp(const JSString *p1, const JSString *p2, int len)
+static int js_string_memcmp(const JSString *p1, int pos1, const JSString *p2,
+                            int pos2, int len)
 {
     int res;
 
     if (likely(!p1->is_wide_char)) {
         if (likely(!p2->is_wide_char))
-            res = memcmp(p1->u.str8, p2->u.str8, len);
+            res = memcmp(p1->u.str8 + pos1, p2->u.str8 + pos2, len);
         else
-            res = -memcmp16_8(p2->u.str16, p1->u.str8, len);
+            res = -memcmp16_8(p2->u.str16 + pos2, p1->u.str8 + pos1, len);
     } else {
         if (!p2->is_wide_char)
-            res = memcmp16_8(p1->u.str16, p2->u.str8, len);
+            res = memcmp16_8(p1->u.str16 + pos1, p2->u.str8 + pos2, len);
         else
-            res = memcmp16(p1->u.str16, p2->u.str16, len);
+            res = memcmp16(p1->u.str16 + pos1, p2->u.str16 + pos2, len);
     }
     return res;
 }
@@ -4116,7 +4071,7 @@ static int js_string_compare(JSContext *ctx,
 {
     int res, len;
     len = min_int(p1->len, p2->len);
-    res = js_string_memcmp(p1, p2, len);
+    res = js_string_memcmp(p1, 0, p2, 0, len);
     if (res == 0) {
         if (p1->len == p2->len)
             res = 0;
@@ -4166,53 +4121,452 @@ static JSValue JS_ConcatString1(JSContext *ctx,
     return JS_MKPTR(JS_TAG_STRING, p);
 }
 
-/* op1 and op2 are converted to strings. For convience, op1 or op2 =
+static BOOL JS_ConcatStringInPlace(JSContext *ctx, JSString *p1, JSValueConst op2) {
+    if (JS_VALUE_GET_TAG(op2) == JS_TAG_STRING) {
+        JSString *p2 = JS_VALUE_GET_STRING(op2);
+        size_t size1;
+
+        if (p2->len == 0)
+            return TRUE;
+        if (p1->header.ref_count != 1)
+            return FALSE;
+        size1 = js_malloc_usable_size(ctx, p1);
+        if (p1->is_wide_char) {
+            if (size1 >= sizeof(*p1) + ((p1->len + p2->len) << 1)) {
+                if (p2->is_wide_char) {
+                    memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
+                    p1->len += p2->len;
+                    return TRUE;
+                } else {
+                    size_t i;
+                    for (i = 0; i < p2->len; i++) {
+                        p1->u.str16[p1->len++] = p2->u.str8[i];
+                    }
+                    return TRUE;
+                }
+            }
+        } else if (!p2->is_wide_char) {
+            if (size1 >= sizeof(*p1) + p1->len + p2->len + 1) {
+                memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
+                p1->len += p2->len;
+                p1->u.str8[p1->len] = '\0';
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+static JSValue JS_ConcatString2(JSContext *ctx, JSValue op1, JSValue op2)
+{
+    JSValue ret;
+    JSString *p1, *p2;
+    p1 = JS_VALUE_GET_STRING(op1);
+    if (JS_ConcatStringInPlace(ctx, p1, op2)) {
+        JS_FreeValue(ctx, op2);
+        return op1;
+    }
+    p2 = JS_VALUE_GET_STRING(op2);
+    ret = JS_ConcatString1(ctx, p1, p2);
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return ret;
+}
+
+/* Return the character at position 'idx'. 'val' must be a string or rope */
+static int string_rope_get(JSValueConst val, uint32_t idx)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        return string_get(JS_VALUE_GET_STRING(val), idx);
+    } else {
+        JSStringRope *r = JS_VALUE_GET_STRING_ROPE(val);
+        uint32_t len;
+        if (JS_VALUE_GET_TAG(r->left) == JS_TAG_STRING)
+            len = JS_VALUE_GET_STRING(r->left)->len;
+        else
+            len = JS_VALUE_GET_STRING_ROPE(r->left)->len;
+        if (idx < len)
+            return string_rope_get(r->left, idx);
+        else
+            return string_rope_get(r->right, idx - len);
+    }
+}
+
+typedef struct {
+    JSValueConst stack[JS_STRING_ROPE_MAX_DEPTH];
+    int stack_len;
+} JSStringRopeIter;
+
+static void string_rope_iter_init(JSStringRopeIter *s, JSValueConst val)
+{
+    s->stack_len = 0;
+    s->stack[s->stack_len++] = val;
+}
+
+/* iterate thru a rope and return the strings in order */
+static JSString *string_rope_iter_next(JSStringRopeIter *s)
+{
+    JSValueConst val;
+    JSStringRope *r;
+
+    if (s->stack_len == 0)
+        return NULL;
+    val = s->stack[--s->stack_len];
+    for(;;) {
+        if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING)
+            return JS_VALUE_GET_STRING(val);
+        r = JS_VALUE_GET_STRING_ROPE(val);
+        assert(s->stack_len < JS_STRING_ROPE_MAX_DEPTH);
+        s->stack[s->stack_len++] = r->right;
+        val = r->left;
+    }
+}
+
+static uint32_t string_rope_get_len(JSValueConst val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING)
+        return JS_VALUE_GET_STRING(val)->len;
+    else
+        return JS_VALUE_GET_STRING_ROPE(val)->len;
+}
+
+static int js_string_rope_compare(JSContext *ctx, JSValueConst op1,
+                                  JSValueConst op2, BOOL eq_only)
+{
+    uint32_t len1, len2, len, pos1, pos2, l;
+    int res;
+    JSStringRopeIter it1, it2;
+    JSString *p1, *p2;
+    
+    len1 = string_rope_get_len(op1);
+    len2 = string_rope_get_len(op2);
+    /* no need to go further for equality test if
+       different length */
+    if (eq_only && len1 != len2)
+        return 1; 
+    len = min_uint32(len1, len2);
+    string_rope_iter_init(&it1, op1);
+    string_rope_iter_init(&it2, op2);
+    p1 = string_rope_iter_next(&it1);
+    p2 = string_rope_iter_next(&it2);
+    pos1 = 0;
+    pos2 = 0;
+    while (len != 0) {
+        l = min_uint32(p1->len - pos1, p2->len - pos2);
+        l = min_uint32(l, len);
+        res = js_string_memcmp(p1, pos1, p2, pos2, l);
+        if (res != 0)
+            return res;
+        len -= l;
+        pos1 += l;
+        if (pos1 >= p1->len) {
+            p1 = string_rope_iter_next(&it1);
+            pos1 = 0;
+        }
+        pos2 += l;
+        if (pos2 >= p2->len) {
+            p2 = string_rope_iter_next(&it2);
+            pos2 = 0;
+        }
+    }
+
+    if (len1 == len2)
+        res = 0;
+    else if (len1 < len2)
+        res = -1;
+    else
+        res = 1;
+    return res;
+}
+
+/* 'rope' must be a rope. return a string and modify the rope so that
+   it won't need to be linearized again. */
+static JSValue js_linearize_string_rope(JSContext *ctx, JSValue rope)
+{
+    StringBuffer b_s, *b = &b_s;
+    JSStringRope *r;
+    JSValue ret;
+    
+    r = JS_VALUE_GET_STRING_ROPE(rope);
+
+    /* check whether it is already linearized */
+    if (JS_VALUE_GET_TAG(r->right) == JS_TAG_STRING &&
+        JS_VALUE_GET_STRING(r->right)->len == 0) {
+        ret = JS_DupValue(ctx, r->left);
+        JS_FreeValue(ctx, rope);
+        return ret;
+    }
+    if (string_buffer_init2(ctx, b, r->len, r->is_wide_char))
+        goto fail;
+    if (string_buffer_concat_value(b, rope))
+        goto fail;
+    ret = string_buffer_end(b);
+    if (r->header.ref_count > 1) {
+        /* update the rope so that it won't need to be linearized again */
+        JS_FreeValue(ctx, r->left);
+        JS_FreeValue(ctx, r->right);
+        r->left = JS_DupValue(ctx, ret);
+        r->right = JS_AtomToString(ctx, JS_ATOM_empty_string);
+    }
+    JS_FreeValue(ctx, rope);
+    return ret;
+ fail:
+    JS_FreeValue(ctx, rope);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_rebalancee_string_rope(JSContext *ctx, JSValueConst rope);
+
+/* op1 and op2 must be strings or string ropes */
+static JSValue js_new_string_rope(JSContext *ctx, JSValue op1, JSValue op2)
+{
+    uint32_t len;
+    int is_wide_char, depth;
+    JSStringRope *r;
+    JSValue res;
+    
+    if (JS_VALUE_GET_TAG(op1) == JS_TAG_STRING) {
+        JSString *p1 = JS_VALUE_GET_STRING(op1);
+        len = p1->len;
+        is_wide_char = p1->is_wide_char;
+        depth = 0;
+    } else {
+        JSStringRope *r1 = JS_VALUE_GET_STRING_ROPE(op1);
+        len = r1->len;
+        is_wide_char = r1->is_wide_char;
+        depth = r1->depth;
+    }
+
+    if (JS_VALUE_GET_TAG(op2) == JS_TAG_STRING) {
+        JSString *p2 = JS_VALUE_GET_STRING(op2);
+        len += p2->len;
+        is_wide_char |= p2->is_wide_char;
+    } else {
+        JSStringRope *r2 = JS_VALUE_GET_STRING_ROPE(op2);
+        len += r2->len;
+        is_wide_char |= r2->is_wide_char;
+        depth = max_int(depth, r2->depth);
+    }
+    if (len > JS_STRING_LEN_MAX) {
+        JS_ThrowInternalError(ctx, "string too long");
+        goto fail;
+    }
+    r = js_malloc(ctx, sizeof(*r));
+    if (!r)
+        goto fail;
+    r->header.ref_count = 1;
+    r->len = len;
+    r->is_wide_char = is_wide_char;
+    r->depth = depth + 1;
+    r->left = op1;
+    r->right = op2;
+    res = JS_MKPTR(JS_TAG_STRING_ROPE, r);
+    if (r->depth > JS_STRING_ROPE_MAX_DEPTH) {
+        JSValue res2;
+#ifdef DUMP_ROPE_REBALANCE
+        printf("rebalance: initial depth=%d\n", r->depth);
+#endif
+        res2 = js_rebalancee_string_rope(ctx, res);
+#ifdef DUMP_ROPE_REBALANCE
+        if (JS_VALUE_GET_TAG(res2) == JS_TAG_STRING_ROPE) 
+            printf("rebalance: final depth=%d\n", JS_VALUE_GET_STRING_ROPE(res2)->depth);
+#endif
+        JS_FreeValue(ctx, res);
+        return res2;
+    } else {
+        return res;
+    }
+ fail:
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    return JS_EXCEPTION;
+}
+
+#define ROPE_N_BUCKETS 44
+
+/* Fibonacii numbers starting from F_2 */
+static const uint32_t rope_bucket_len[ROPE_N_BUCKETS] = {
+          1,          2,          3,          5,
+          8,         13,         21,         34,
+         55,         89,        144,        233,
+        377,        610,        987,       1597,
+       2584,       4181,       6765,      10946,
+      17711,      28657,      46368,      75025,
+     121393,     196418,     317811,     514229,
+     832040,    1346269,    2178309,    3524578,
+    5702887,    9227465,   14930352,   24157817,
+   39088169,   63245986,  102334155,  165580141,
+  267914296,  433494437,  701408733, 1134903170, /* > JS_STRING_LEN_MAX */
+};
+
+static int js_rebalancee_string_rope_rec(JSContext *ctx, JSValue *buckets,
+                                          JSValueConst val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        uint32_t len, i;
+        JSValue a, b;
+        
+        len = p->len;
+        if (len == 0)
+            return 0; /* nothing to do */
+        /* find the bucket i so that rope_bucket_len[i] <= len <
+           rope_bucket_len[i + 1] and concatenate the ropes in the
+           buckets before */
+        a = JS_NULL;
+        i = 0;
+        while (len >= rope_bucket_len[i + 1]) {
+            b = buckets[i];
+            if (!JS_IsNull(b)) {
+                buckets[i] = JS_NULL;
+                if (JS_IsNull(a)) {
+                    a = b;
+                } else {
+                    a = js_new_string_rope(ctx, b, a);
+                    if (JS_IsException(a))
+                        return -1;
+                }
+            }
+            i++;
+        }
+        if (!JS_IsNull(a)) {
+            a = js_new_string_rope(ctx, a, JS_DupValue(ctx, val));
+            if (JS_IsException(a))
+                return -1;
+        } else {
+            a = JS_DupValue(ctx, val);
+        }
+        while (!JS_IsNull(buckets[i])) {
+            a = js_new_string_rope(ctx, buckets[i], a);
+            buckets[i] = JS_NULL;
+            if (JS_IsException(a))
+                return -1;
+            i++;
+        }
+        buckets[i] = a;
+    } else {
+        JSStringRope *r = JS_VALUE_GET_STRING_ROPE(val);
+        js_rebalancee_string_rope_rec(ctx, buckets, r->left);
+        js_rebalancee_string_rope_rec(ctx, buckets, r->right);
+    }
+    return 0;
+}
+
+/* Return a new rope which is balanced. Algorithm from "Ropes: an
+   Alternative to Strings", Hans-J. Boehm, Russ Atkinson and Michael
+   Plass. */
+static JSValue js_rebalancee_string_rope(JSContext *ctx, JSValueConst rope)
+{
+    JSValue buckets[ROPE_N_BUCKETS], a, b;
+    int i;
+    
+    for(i = 0; i < ROPE_N_BUCKETS; i++)
+        buckets[i] = JS_NULL;
+    if (js_rebalancee_string_rope_rec(ctx, buckets, rope))
+        goto fail;
+    a = JS_NULL;
+    for(i = 0; i < ROPE_N_BUCKETS; i++) {
+        b = buckets[i];
+        if (!JS_IsNull(b)) {
+            buckets[i] = JS_NULL;
+            if (JS_IsNull(a)) {
+                a = b;
+            } else {
+                a = js_new_string_rope(ctx, b, a);
+                if (JS_IsException(a))
+                    goto fail;
+            }
+        }
+    }
+    /* fail safe */
+    if (JS_IsNull(a))
+        return JS_AtomToString(ctx, JS_ATOM_empty_string);
+    else
+        return a;
+ fail:
+    for(i = 0; i < ROPE_N_BUCKETS; i++) {
+        JS_FreeValue(ctx, buckets[i]);
+    }
+    return JS_EXCEPTION;
+}
+
+/* op1 and op2 are converted to strings. For convenience, op1 or op2 =
    JS_EXCEPTION are accepted and return JS_EXCEPTION.  */
 static JSValue JS_ConcatString(JSContext *ctx, JSValue op1, JSValue op2)
 {
-    JSValue ret;
     JSString *p1, *p2;
 
-    if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING)) {
+    if (unlikely(JS_VALUE_GET_TAG(op1) != JS_TAG_STRING &&
+                 JS_VALUE_GET_TAG(op1) != JS_TAG_STRING_ROPE)) {
         op1 = JS_ToStringFree(ctx, op1);
         if (JS_IsException(op1)) {
             JS_FreeValue(ctx, op2);
             return JS_EXCEPTION;
         }
     }
-    if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING)) {
+    if (unlikely(JS_VALUE_GET_TAG(op2) != JS_TAG_STRING &&
+                 JS_VALUE_GET_TAG(op2) != JS_TAG_STRING_ROPE)) {
         op2 = JS_ToStringFree(ctx, op2);
         if (JS_IsException(op2)) {
             JS_FreeValue(ctx, op1);
             return JS_EXCEPTION;
         }
     }
-    p1 = JS_VALUE_GET_STRING(op1);
-    p2 = JS_VALUE_GET_STRING(op2);
 
-    /* XXX: could also check if p1 is empty */
-    if (p2->len == 0) {
-        goto ret_op1;
-    }
-    if (p1->header.ref_count == 1 && p1->is_wide_char == p2->is_wide_char
-    &&  js_malloc_usable_size(ctx, p1) >= sizeof(*p1) + ((p1->len + p2->len) << p2->is_wide_char) + 1 - p1->is_wide_char) {
-        /* Concatenate in place in available space at the end of p1 */
-        if (p1->is_wide_char) {
-            memcpy(p1->u.str16 + p1->len, p2->u.str16, p2->len << 1);
-            p1->len += p2->len;
-        } else {
-            memcpy(p1->u.str8 + p1->len, p2->u.str8, p2->len);
-            p1->len += p2->len;
-            p1->u.str8[p1->len] = '\0';
+    /* normal concatenation for short strings */
+    if (JS_VALUE_GET_TAG(op2) == JS_TAG_STRING) {
+        p2 = JS_VALUE_GET_STRING(op2);
+        if (p2->len == 0) {
+            JS_FreeValue(ctx, op2);
+            return op1;
+        }
+        if (p2->len <= JS_STRING_ROPE_SHORT_LEN) {
+            if (JS_VALUE_GET_TAG(op1) == JS_TAG_STRING) {
+                p1 = JS_VALUE_GET_STRING(op1);
+                if (p1->len <= JS_STRING_ROPE_SHORT2_LEN) {
+                    return JS_ConcatString2(ctx, op1, op2);
+                } else {
+                    return js_new_string_rope(ctx, op1, op2);
+                }
+            } else {
+                JSStringRope *r1;
+                r1 = JS_VALUE_GET_STRING_ROPE(op1);
+                if (JS_VALUE_GET_TAG(r1->right) == JS_TAG_STRING &&
+                    JS_VALUE_GET_STRING(r1->right)->len <= JS_STRING_ROPE_SHORT_LEN) {
+                    JSValue val, ret;
+                    val = JS_ConcatString2(ctx, JS_DupValue(ctx, r1->right), op2);
+                    if (JS_IsException(val)) {
+                        JS_FreeValue(ctx, op1);
+                        return JS_EXCEPTION;
+                    }
+                    ret = js_new_string_rope(ctx, JS_DupValue(ctx, r1->left), val);
+                    JS_FreeValue(ctx, op1);
+                    return ret;
+                }
+            }
+        }
+    } else if (JS_VALUE_GET_TAG(op1) == JS_TAG_STRING) {
+        JSStringRope *r2;
+        p1 = JS_VALUE_GET_STRING(op1);
+        if (p1->len == 0) {
+            JS_FreeValue(ctx, op1);
+            return op2;
+        }
+        r2 = JS_VALUE_GET_STRING_ROPE(op2);
+        if (JS_VALUE_GET_TAG(r2->left) == JS_TAG_STRING &&
+            JS_VALUE_GET_STRING(r2->left)->len <= JS_STRING_ROPE_SHORT_LEN) {
+            JSValue val, ret;
+            val = JS_ConcatString2(ctx, op1, JS_DupValue(ctx, r2->left));
+            if (JS_IsException(val)) {
+                JS_FreeValue(ctx, op2);
+                return JS_EXCEPTION;
+            }
+            ret = js_new_string_rope(ctx, val, JS_DupValue(ctx, r2->right));
+            JS_FreeValue(ctx, op2);
+            return ret;
         }
-    ret_op1:
-        JS_FreeValue(ctx, op2);
-        return op1;
     }
-    ret = JS_ConcatString1(ctx, p1, p2);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return ret;
+    return js_new_string_rope(ctx, op1, op2);
 }
 
 /* Shape support */
@@ -4352,7 +4706,7 @@ static no_inline JSShape *js_new_shape2(JSContext *ctx, JSObject *proto,
     sh->prop_size = prop_size;
     sh->prop_count = 0;
     sh->deleted_prop_count = 0;
-    
+
     /* insert in the hash table */
     sh->hash = shape_initial_hash(proto);
     sh->is_hashed = TRUE;
@@ -4445,6 +4799,7 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
     JSShapeProperty *pr;
     void *sh_alloc;
     intptr_t h;
+    JSShape *old_sh;
 
     sh = *psh;
     new_size = max_int(count, sh->prop_size * 3 / 2);
@@ -4460,19 +4815,21 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
     new_hash_size = sh->prop_hash_mask + 1;
     while (new_hash_size < new_size)
         new_hash_size = 2 * new_hash_size;
+    /* resize the property shapes. Using js_realloc() is not possible in
+       case the GC runs during the allocation */
+    old_sh = sh;
+    sh_alloc = js_malloc(ctx, get_shape_size(new_hash_size, new_size));
+    if (!sh_alloc)
+        return -1;
+    sh = get_shape_from_alloc(sh_alloc, new_hash_size);
+    list_del(&old_sh->header.link);
+    /* copy all the shape properties */
+    memcpy(sh, old_sh,
+           sizeof(JSShape) + sizeof(sh->prop[0]) * old_sh->prop_count);
+    list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
+
     if (new_hash_size != (sh->prop_hash_mask + 1)) {
-        JSShape *old_sh;
         /* resize the hash table and the properties */
-        old_sh = sh;
-        sh_alloc = js_malloc(ctx, get_shape_size(new_hash_size, new_size));
-        if (!sh_alloc)
-            return -1;
-        sh = get_shape_from_alloc(sh_alloc, new_hash_size);
-        list_del(&old_sh->header.link);
-        /* copy all the fields and the properties */
-        memcpy(sh, old_sh,
-               sizeof(JSShape) + sizeof(sh->prop[0]) * old_sh->prop_count);
-        list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
         new_hash_mask = new_hash_size - 1;
         sh->prop_hash_mask = new_hash_mask;
         memset(prop_hash_end(sh) - new_hash_size, 0,
@@ -4484,20 +4841,12 @@ static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
                 prop_hash_end(sh)[-h - 1] = i + 1;
             }
         }
-        js_free(ctx, get_alloc_from_shape(old_sh));
     } else {
-        /* only resize the properties */
-        list_del(&sh->header.link);
-        sh_alloc = js_realloc(ctx, get_alloc_from_shape(sh),
-                              get_shape_size(new_hash_size, new_size));
-        if (unlikely(!sh_alloc)) {
-            /* insert again in the GC list */
-            list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
-            return -1;
-        }
-        sh = get_shape_from_alloc(sh_alloc, new_hash_size);
-        list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
+        /* just copy the previous hash table */
+        memcpy(prop_hash_end(sh) - new_hash_size, prop_hash_end(old_sh) - new_hash_size,
+               sizeof(prop_hash_end(sh)[0]) * new_hash_size);
     }
+    js_free(ctx, get_alloc_from_shape(old_sh));
     *psh = sh;
     sh->prop_size = new_size;
     return 0;
@@ -4512,7 +4861,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
     uint32_t new_hash_size, i, j, new_hash_mask, new_size;
     JSShapeProperty *old_pr, *pr;
     JSProperty *prop, *new_prop;
-    
+
     sh = p->shape;
     assert(!sh->is_hashed);
 
@@ -4534,7 +4883,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
     list_del(&old_sh->header.link);
     memcpy(sh, old_sh, sizeof(JSShape));
     list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
-    
+
     memset(prop_hash_end(sh) - new_hash_size, 0,
            sizeof(prop_hash_end(sh)[0]) * new_hash_size);
 
@@ -4563,7 +4912,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
 
     p->shape = sh;
     js_free(ctx, get_alloc_from_shape(old_sh));
-    
+
     /* reduce the size of the object properties */
     new_prop = js_realloc(ctx, p->prop, sizeof(new_prop[0]) * new_size);
     if (new_prop)
@@ -4690,7 +5039,7 @@ static __maybe_unused void JS_DumpShapes(JSRuntime *rt)
     struct list_head *el;
     JSObject *p;
     JSGCObjectHeader *gp;
-    
+
     printf("JSShapes: {\n");
     printf("%5s %4s %14s %5s %5s %s\n", "SLOT", "REFS", "PROTO", "SIZE", "COUNT", "PROPS");
     for(i = 0; i < rt->shape_hash_size; i++) {
@@ -4726,10 +5075,10 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     p->is_exotic = 0;
     p->fast_array = 0;
     p->is_constructor = 0;
-    p->is_uncatchable_error = 0;
+    p->has_immutable_prototype = 0;
     p->tmp_mark = 0;
     p->is_HTMLDDA = 0;
-    p->first_weak_ref = NULL;
+    p->weakref_count = 0;
     p->u.opaque = NULL;
     p->shape = sh;
     p->prop = js_malloc(ctx, sizeof(JSProperty) * sh->prop_size);
@@ -4776,6 +5125,7 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     case JS_CLASS_UINT32_ARRAY:
     case JS_CLASS_BIG_INT64_ARRAY:
     case JS_CLASS_BIG_UINT64_ARRAY:
+    case JS_CLASS_FLOAT16_ARRAY:
     case JS_CLASS_FLOAT32_ARRAY:
     case JS_CLASS_FLOAT64_ARRAY:
         p->is_exotic = 1;
@@ -4793,10 +5143,6 @@ static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID clas
     case JS_CLASS_SYMBOL:
     case JS_CLASS_DATE:
     case JS_CLASS_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_CLASS_BIG_FLOAT:
-    case JS_CLASS_BIG_DECIMAL:
-#endif
         p->u.object_data = JS_UNDEFINED;
         goto set_exotic;
     case JS_CLASS_REGEXP:
@@ -4856,10 +5202,6 @@ static JSValue JS_GetObjectData(JSContext *ctx, JSValueConst obj)
         case JS_CLASS_SYMBOL:
         case JS_CLASS_DATE:
         case JS_CLASS_BIG_INT:
-#ifdef CONFIG_BIGNUM
-        case JS_CLASS_BIG_FLOAT:
-        case JS_CLASS_BIG_DECIMAL:
-#endif
             return JS_DupValue(ctx, p->u.object_data);
         }
     }
@@ -4880,12 +5222,10 @@ static int JS_SetObjectData(JSContext *ctx, JSValueConst obj, JSValue val)
         case JS_CLASS_SYMBOL:
         case JS_CLASS_DATE:
         case JS_CLASS_BIG_INT:
-#ifdef CONFIG_BIGNUM
-        case JS_CLASS_BIG_FLOAT:
-        case JS_CLASS_BIG_DECIMAL:
-#endif
             JS_FreeValue(ctx, p->u.object_data);
-            p->u.object_data = val;
+            p->u.object_data = val; /* for JS_CLASS_STRING, 'val' must
+                                       be JS_TAG_STRING (and not a
+                                       rope) */
             return 0;
         }
     }
@@ -5016,7 +5356,7 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
     JSValue func_obj;
     JSObject *p;
     JSAtom name_atom;
-    
+
     func_obj = JS_NewObjectProtoClass(ctx, proto_val, JS_CLASS_C_FUNCTION);
     if (JS_IsException(func_obj))
         return func_obj;
@@ -5033,6 +5373,10 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
     if (!name)
         name = "";
     name_atom = JS_NewAtom(ctx, name);
+    if (name_atom == JS_ATOM_NULL) {
+        JS_FreeValue(ctx, func_obj);
+        return JS_EXCEPTION;
+    }
     js_function_set_properties(ctx, func_obj, name_atom, length);
     JS_FreeAtom(ctx, name_atom);
     return func_obj;
@@ -5227,10 +5571,12 @@ static void free_var_ref(JSRuntime *rt, JSVarRef *var_ref)
         if (--var_ref->header.ref_count == 0) {
             if (var_ref->is_detached) {
                 JS_FreeValueRT(rt, var_ref->value);
-                remove_gc_object(&var_ref->header);
             } else {
-                list_del(&var_ref->header.link); /* still on the stack */
+                list_del(&var_ref->var_ref_link); /* still on the stack */
+                if (var_ref->async_func)
+                    async_func_free(rt, var_ref->async_func);
             }
+            remove_gc_object(&var_ref->header);
             js_free_rt(rt, var_ref);
         }
     }
@@ -5328,7 +5674,7 @@ static void js_bytecode_function_mark(JSRuntime *rt, JSValueConst val,
         if (var_refs) {
             for(i = 0; i < b->closure_var_count; i++) {
                 JSVarRef *var_ref = var_refs[i];
-                if (var_ref && var_ref->is_detached) {
+                if (var_ref) {
                     mark_func(rt, &var_ref->header);
                 }
             }
@@ -5370,7 +5716,15 @@ static void js_for_in_iterator_finalizer(JSRuntime *rt, JSValue val)
 {
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSForInIterator *it = p->u.for_in_iterator;
+    int i;
+
     JS_FreeValueRT(rt, it->obj);
+    if (!it->is_array) {
+        for(i = 0; i < it->atom_count; i++) {
+            JS_FreeAtomRT(rt, it->tab_atom[i].atom);
+        }
+        js_free_rt(rt, it->tab_atom);
+    }
     js_free_rt(rt, it);
 }
 
@@ -5407,10 +5761,6 @@ static void free_object(JSRuntime *rt, JSObject *p)
     p->shape = NULL;
     p->prop = NULL;
 
-    if (unlikely(p->first_weak_ref)) {
-        reset_weak_ref(rt, p);
-    }
-
     finalizer = rt->class_array[p->class_id].finalizer;
     if (finalizer)
         (*finalizer)(rt, JS_MKPTR(JS_TAG_OBJECT, p));
@@ -5422,10 +5772,21 @@ static void free_object(JSRuntime *rt, JSObject *p)
     p->u.func.home_object = NULL;
 
     remove_gc_object(&p->header);
-    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES && p->header.ref_count != 0) {
-        list_add_tail(&p->header.link, &rt->gc_zero_ref_count_list);
+    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES) {
+        if (p->header.ref_count == 0 && p->weakref_count == 0) {
+            js_free_rt(rt, p);
+        } else {
+            /* keep the object structure because there are may be
+               references to it */
+            list_add_tail(&p->header.link, &rt->gc_zero_ref_count_list);
+        }
     } else {
-        js_free_rt(rt, p);
+        /* keep the object structure in case there are weak references to it */
+        if (p->weakref_count == 0) {
+            js_free_rt(rt, p);
+        } else {
+            p->header.mark = 0; /* reset the mark so that the weakref can be freed */
+        }
     }
 }
 
@@ -5438,6 +5799,12 @@ static void free_gc_object(JSRuntime *rt, JSGCObjectHeader *gp)
     case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
         free_function_bytecode(rt, (JSFunctionBytecode *)gp);
         break;
+    case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
+        __async_func_free(rt, (JSAsyncFunctionState *)gp);
+        break;
+    case JS_GC_OBJ_TYPE_MODULE:
+        js_free_module_def(rt, (JSModuleDef *)gp);
+        break;
     default:
         abort();
     }
@@ -5447,7 +5814,7 @@ static void free_zero_refcount(JSRuntime *rt)
 {
     struct list_head *el;
     JSGCObjectHeader *p;
-    
+
     rt->gc_phase = JS_GC_PHASE_DECREF;
     for(;;) {
         el = rt->gc_zero_ref_count_list.next;
@@ -5491,41 +5858,36 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v)
             }
         }
         break;
+    case JS_TAG_STRING_ROPE:
+        /* Note: recursion is acceptable because the rope depth is bounded */
+        {
+            JSStringRope *p = JS_VALUE_GET_STRING_ROPE(v);
+            JS_FreeValueRT(rt, p->left);
+            JS_FreeValueRT(rt, p->right);
+            js_free_rt(rt, p);
+        }
+        break;
     case JS_TAG_OBJECT:
     case JS_TAG_FUNCTION_BYTECODE:
+    case JS_TAG_MODULE:
         {
             JSGCObjectHeader *p = JS_VALUE_GET_PTR(v);
             if (rt->gc_phase != JS_GC_PHASE_REMOVE_CYCLES) {
                 list_del(&p->link);
                 list_add(&p->link, &rt->gc_zero_ref_count_list);
+                p->mark = 1; /* indicate that the object is about to be freed */
                 if (rt->gc_phase == JS_GC_PHASE_NONE) {
                     free_zero_refcount(rt);
                 }
             }
         }
         break;
-    case JS_TAG_MODULE:
-        abort(); /* never freed here */
-        break;
     case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif        
         {
-            JSBigFloat *bf = JS_VALUE_GET_PTR(v);
-            bf_delete(&bf->num);
-            js_free_rt(rt, bf);
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_DECIMAL:
-        {
-            JSBigDecimal *bf = JS_VALUE_GET_PTR(v);
-            bfdec_delete(&bf->num);
-            js_free_rt(rt, bf);
+            JSBigInt *p = JS_VALUE_GET_PTR(v);
+            js_free_rt(rt, p);
         }
         break;
-#endif
     case JS_TAG_SYMBOL:
         {
             JSAtomStruct *p = JS_VALUE_GET_PTR(v);
@@ -5533,7 +5895,6 @@ void __JS_FreeValueRT(JSRuntime *rt, JSValue v)
         }
         break;
     default:
-        printf("__JS_FreeValue: unknown tag=%d\n", tag);
         abort();
     }
 }
@@ -5545,6 +5906,36 @@ void __JS_FreeValue(JSContext *ctx, JSValue v)
 
 /* garbage collection */
 
+static void gc_remove_weak_objects(JSRuntime *rt)
+{
+    struct list_head *el;
+
+    /* add the freed objects to rt->gc_zero_ref_count_list so that
+       rt->weakref_list is not modified while we traverse it */
+    rt->gc_phase = JS_GC_PHASE_DECREF; 
+        
+    list_for_each(el, &rt->weakref_list) {
+        JSWeakRefHeader *wh = list_entry(el, JSWeakRefHeader, link);
+        switch(wh->weakref_type) {
+        case JS_WEAKREF_TYPE_MAP:
+            map_delete_weakrefs(rt, wh);
+            break;
+        case JS_WEAKREF_TYPE_WEAKREF:
+            weakref_delete_weakref(rt, wh);
+            break;
+        case JS_WEAKREF_TYPE_FINREC:
+            finrec_delete_weakref(rt, wh);
+            break;
+        default:
+            abort();
+        }
+    }
+
+    rt->gc_phase = JS_GC_PHASE_NONE;
+    /* free the freed objects here. */
+    free_zero_refcount(rt);
+}
+
 static void add_gc_object(JSRuntime *rt, JSGCObjectHeader *h,
                           JSGCObjectTypeEnum type)
 {
@@ -5564,6 +5955,7 @@ void JS_MarkValue(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func)
         switch(JS_VALUE_GET_TAG(val)) {
         case JS_TAG_OBJECT:
         case JS_TAG_FUNCTION_BYTECODE:
+        case JS_TAG_MODULE:
             mark_func(rt, JS_VALUE_GET_PTR(val));
             break;
         default:
@@ -5596,11 +5988,9 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
                             if (pr->u.getset.setter)
                                 mark_func(rt, &pr->u.getset.setter->header);
                         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
-                            if (pr->u.var_ref->is_detached) {
-                                /* Note: the tag does not matter
-                                   provided it is a GC object */
-                                mark_func(rt, &pr->u.var_ref->header);
-                            }
+                            /* Note: the tag does not matter
+                               provided it is a GC object */
+                            mark_func(rt, &pr->u.var_ref->header);
                         } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
                             js_autoinit_mark(rt, pr, mark_func);
                         }
@@ -5634,16 +6024,32 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
     case JS_GC_OBJ_TYPE_VAR_REF:
         {
             JSVarRef *var_ref = (JSVarRef *)gp;
-            /* only detached variable referenced are taken into account */
-            assert(var_ref->is_detached);
-            JS_MarkValue(rt, *var_ref->pvalue, mark_func);
+            if (var_ref->is_detached) {
+                JS_MarkValue(rt, *var_ref->pvalue, mark_func);
+            } else if (var_ref->async_func) {
+                mark_func(rt, &var_ref->async_func->header);
+            }
         }
         break;
     case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
         {
-            JSAsyncFunctionData *s = (JSAsyncFunctionData *)gp;
-            if (s->is_active)
-                async_func_mark(rt, &s->func_state, mark_func);
+            JSAsyncFunctionState *s = (JSAsyncFunctionState *)gp;
+            JSStackFrame *sf = &s->frame;
+            JSValue *sp;
+
+            if (!s->is_completed) {
+                JS_MarkValue(rt, sf->cur_func, mark_func);
+                JS_MarkValue(rt, s->this_val, mark_func);
+                /* sf->cur_sp = NULL if the function is running */
+                if (sf->cur_sp) {
+                    /* if the function is running, cur_sp is not known so we
+                       cannot mark the stack. Marking the variables is not needed
+                       because a running function cannot be part of a removable
+                       cycle */
+                    for(sp = sf->arg_buf; sp < sf->cur_sp; sp++)
+                        JS_MarkValue(rt, *sp, mark_func);
+                }
+            }
             JS_MarkValue(rt, s->resolving_funcs[0], mark_func);
             JS_MarkValue(rt, s->resolving_funcs[1], mark_func);
         }
@@ -5662,6 +6068,12 @@ static void mark_children(JSRuntime *rt, JSGCObjectHeader *gp,
             JS_MarkContext(rt, ctx, mark_func);
         }
         break;
+    case JS_GC_OBJ_TYPE_MODULE:
+        {
+            JSModuleDef *m = (JSModuleDef *)gp;
+            js_mark_module_def(rt, m, mark_func);
+        }
+        break;
     default:
         abort();
     }
@@ -5681,7 +6093,7 @@ static void gc_decref(JSRuntime *rt)
 {
     struct list_head *el, *el1;
     JSGCObjectHeader *p;
-    
+
     init_list_head(&rt->tmp_obj_list);
 
     /* decrement the refcount of all the children of all the GC
@@ -5728,7 +6140,7 @@ static void gc_scan(JSRuntime *rt)
         p->mark = 0; /* reset the mark for the next GC call */
         mark_children(rt, p, gc_scan_incref_child);
     }
-    
+
     /* restore the refcount of the objects to be deleted. */
     list_for_each(el, &rt->tmp_obj_list) {
         p = list_entry(el, JSGCObjectHeader, link);
@@ -5751,12 +6163,14 @@ static void gc_free_cycles(JSRuntime *rt)
         if (el == &rt->tmp_obj_list)
             break;
         p = list_entry(el, JSGCObjectHeader, link);
-        /* Only need to free the GC object associated with JS
-           values. The rest will be automatically removed because they
-           must be referenced by them. */
+        /* Only need to free the GC object associated with JS values
+           or async functions. The rest will be automatically removed
+           because they must be referenced by them. */
         switch(p->gc_obj_type) {
         case JS_GC_OBJ_TYPE_JS_OBJECT:
         case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
+        case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
+        case JS_GC_OBJ_TYPE_MODULE:
 #ifdef DUMP_GC_FREE
             if (!header_done) {
                 printf("Freeing cycles:\n");
@@ -5774,19 +6188,34 @@ static void gc_free_cycles(JSRuntime *rt)
         }
     }
     rt->gc_phase = JS_GC_PHASE_NONE;
-           
+
     list_for_each_safe(el, el1, &rt->gc_zero_ref_count_list) {
         p = list_entry(el, JSGCObjectHeader, link);
         assert(p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT ||
-               p->gc_obj_type == JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-        js_free_rt(rt, p);
+               p->gc_obj_type == JS_GC_OBJ_TYPE_FUNCTION_BYTECODE ||
+               p->gc_obj_type == JS_GC_OBJ_TYPE_ASYNC_FUNCTION ||
+               p->gc_obj_type == JS_GC_OBJ_TYPE_MODULE);
+        if (p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT &&
+            ((JSObject *)p)->weakref_count != 0) {
+            /* keep the object because there are weak references to it */
+            p->mark = 0;
+        } else {
+            js_free_rt(rt, p);
+        }
     }
 
     init_list_head(&rt->gc_zero_ref_count_list);
 }
 
-void JS_RunGC(JSRuntime *rt)
+static void JS_RunGCInternal(JSRuntime *rt, BOOL remove_weak_objects)
 {
+    if (remove_weak_objects) {
+        /* free the weakly referenced object or symbol structures, delete
+           the associated Map/Set entries and queue the finalization
+           registry callbacks. */
+        gc_remove_weak_objects(rt);
+    }
+    
     /* decrement the reference of the children of each object. mark =
        1 after this pass. */
     gc_decref(rt);
@@ -5798,6 +6227,11 @@ void JS_RunGC(JSRuntime *rt)
     gc_free_cycles(rt);
 }
 
+void JS_RunGC(JSRuntime *rt)
+{
+    JS_RunGCInternal(rt, TRUE);
+}
+
 /* Return false if not an object or if the object has already been
    freed (zombie objects are visible in finalizers when freeing
    cycles). */
@@ -5881,11 +6315,7 @@ static void compute_value_size(JSValueConst val, JSMemoryUsage_helper *hp)
         compute_jsstring_size(JS_VALUE_GET_STRING(val), hp);
         break;
     case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-    case JS_TAG_BIG_DECIMAL:
-#endif
-        /* should track JSBigFloat usage */
+        /* should track JSBigInt usage */
         break;
     }
 }
@@ -6011,10 +6441,6 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         case JS_CLASS_SYMBOL:            /* u.object_data */
         case JS_CLASS_DATE:              /* u.object_data */
         case JS_CLASS_BIG_INT:           /* u.object_data */
-#ifdef CONFIG_BIGNUM
-        case JS_CLASS_BIG_FLOAT:         /* u.object_data */
-        case JS_CLASS_BIG_DECIMAL:         /* u.object_data */
-#endif
             compute_value_size(p->u.object_data, hp);
             break;
         case JS_CLASS_C_FUNCTION:        /* u.cfunc */
@@ -6105,12 +6531,10 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         case JS_CLASS_UINT32_ARRAY:      /* u.typed_array / u.array */
         case JS_CLASS_BIG_INT64_ARRAY:   /* u.typed_array / u.array */
         case JS_CLASS_BIG_UINT64_ARRAY:  /* u.typed_array / u.array */
+        case JS_CLASS_FLOAT16_ARRAY:     /* u.typed_array / u.array */
         case JS_CLASS_FLOAT32_ARRAY:     /* u.typed_array / u.array */
         case JS_CLASS_FLOAT64_ARRAY:     /* u.typed_array / u.array */
         case JS_CLASS_DATAVIEW:          /* u.typed_array */
-#ifdef CONFIG_BIGNUM
-        case JS_CLASS_FLOAT_ENV:         /* u.float_env */
-#endif
         case JS_CLASS_MAP:               /* u.map_state */
         case JS_CLASS_SET:               /* u.map_state */
         case JS_CLASS_WEAKMAP:           /* u.map_state */
@@ -6180,12 +6604,8 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
 
 void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt)
 {
-    fprintf(fp, "QuickJS memory usage -- "
-#ifdef CONFIG_BIGNUM
-            "BigNum "
-#endif
-            CONFIG_VERSION " version, %d-bit, malloc limit: %"PRId64"\n\n",
-            (int)sizeof(void *) * 8, (int64_t)(ssize_t)s->malloc_limit);
+    fprintf(fp, "QuickJS memory usage -- " CONFIG_VERSION " version, %d-bit, malloc limit: %"PRId64"\n\n",
+            (int)sizeof(void *) * 8, s->malloc_limit);
 #if 1
     if (rt) {
         static const struct {
@@ -6231,10 +6651,10 @@ void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt)
             if (obj_classes[0])
                 fprintf(fp, "  %5d  %2.0d %s\n", obj_classes[0], 0, "none");
             for (class_id = 1; class_id < JS_CLASS_INIT_COUNT; class_id++) {
-                if (obj_classes[class_id]) {
+                if (obj_classes[class_id] && class_id < rt->class_count) {
                     char buf[ATOM_GET_STR_BUF_SIZE];
                     fprintf(fp, "  %5d  %2.0d %s\n", obj_classes[class_id], class_id,
-                            JS_AtomGetStrRT(rt, buf, sizeof(buf), js_std_class_def[class_id - 1].class_name));
+                            JS_AtomGetStrRT(rt, buf, sizeof(buf), rt->class_array[class_id].class_name));
                 }
             }
             if (obj_classes[JS_CLASS_INIT_COUNT])
@@ -6318,6 +6738,7 @@ JSValue JS_Throw(JSContext *ctx, JSValue obj)
     JSRuntime *rt = ctx->rt;
     JS_FreeValue(ctx, rt->current_exception);
     rt->current_exception = obj;
+    rt->current_exception_is_uncatchable = FALSE;
     return JS_EXCEPTION;
 }
 
@@ -6327,10 +6748,15 @@ JSValue JS_GetException(JSContext *ctx)
     JSValue val;
     JSRuntime *rt = ctx->rt;
     val = rt->current_exception;
-    rt->current_exception = JS_NULL;
+    rt->current_exception = JS_UNINITIALIZED;
     return val;
 }
 
+JS_BOOL JS_HasException(JSContext *ctx)
+{
+    return !JS_IsUninitialized(ctx->rt->current_exception);
+}
+
 static void dbuf_put_leb128(DynBuf *s, uint32_t v)
 {
     uint32_t a;
@@ -6386,49 +6812,72 @@ static int get_sleb128(int32_t *pval, const uint8_t *buf,
     return ret;
 }
 
+/* use pc_value = -1 to get the position of the function definition */
 static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
-                         uint32_t pc_value)
+                         uint32_t pc_value, int *pcol_num)
 {
     const uint8_t *p_end, *p;
-    int new_line_num, line_num, pc, v, ret;
+    int new_line_num, line_num, pc, v, ret, new_col_num, col_num;
+    uint32_t val;
     unsigned int op;
 
-    if (!b->has_debug || !b->debug.pc2line_buf) {
-        /* function was stripped */
-        return -1;
-    }
+    if (!b->has_debug || !b->debug.pc2line_buf)
+        goto fail; /* function was stripped */
 
     p = b->debug.pc2line_buf;
     p_end = p + b->debug.pc2line_len;
-    pc = 0;
-    line_num = b->debug.line_num;
-    while (p < p_end) {
-        op = *p++;
-        if (op == 0) {
-            uint32_t val;
-            ret = get_leb128(&val, p, p_end);
+
+    /* get the function line and column numbers */
+    ret = get_leb128(&val, p, p_end);
+    if (ret < 0)
+        goto fail;
+    p += ret;
+    line_num = val + 1;
+
+    ret = get_leb128(&val, p, p_end);
+    if (ret < 0)
+        goto fail;
+    p += ret;
+    col_num = val + 1;
+
+    if (pc_value != -1) {
+        pc = 0;
+        while (p < p_end) {
+            op = *p++;
+            if (op == 0) {
+                ret = get_leb128(&val, p, p_end);
+                if (ret < 0)
+                    goto fail;
+                pc += val;
+                p += ret;
+                ret = get_sleb128(&v, p, p_end);
+                if (ret < 0)
+                    goto fail;
+                p += ret;
+                new_line_num = line_num + v;
+            } else {
+                op -= PC2LINE_OP_FIRST;
+                pc += (op / PC2LINE_RANGE);
+                new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
+            }
+            ret = get_sleb128(&v, p, p_end);
             if (ret < 0)
                 goto fail;
-            pc += val;
-            p += ret;
-            ret = get_sleb128(&v, p, p_end);
-            if (ret < 0) {
-            fail:
-                /* should never happen */
-                return b->debug.line_num;
-            }
             p += ret;
-            new_line_num = line_num + v;
-        } else {
-            op -= PC2LINE_OP_FIRST;
-            pc += (op / PC2LINE_RANGE);
-            new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
+            new_col_num = col_num + v;
+            
+            if (pc_value < pc)
+                goto done;
+            line_num = new_line_num;
+            col_num = new_col_num;
         }
-        if (pc_value < pc)
-            return line_num;
-        line_num = new_line_num;
     }
+ done:
+    *pcol_num = col_num;
     return line_num;
+ fail:
+    *pcol_num = 0;
+    return 0;
 }
 
 /* in order to avoid executing arbitrary code during the stack trace
@@ -6439,7 +6888,7 @@ static const char *get_func_name(JSContext *ctx, JSValueConst func)
     JSProperty *pr;
     JSShapeProperty *prs;
     JSValueConst val;
-    
+
     if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
         return NULL;
     prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
@@ -6454,13 +6903,11 @@ static const char *get_func_name(JSContext *ctx, JSValueConst func)
 }
 
 #define JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL (1 << 0)
-/* only taken into account if filename is provided */
-#define JS_BACKTRACE_FLAG_SINGLE_LEVEL     (1 << 1)
 
 /* if filename != NULL, an additional level is added with the filename
    and line number information (used for parse error). */
 static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
-                            const char *filename, int line_num,
+                            const char *filename, int line_num, int col_num,
                             int backtrace_flags)
 {
     JSStackFrame *sf;
@@ -6469,23 +6916,32 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
     const char *func_name_str;
     const char *str1;
     JSObject *p;
-    BOOL backtrace_barrier;
+
+    if (!JS_IsObject(error_obj))
+        return; /* protection in the out of memory case */
     
     js_dbuf_init(ctx, &dbuf);
     if (filename) {
         dbuf_printf(&dbuf, "    at %s", filename);
         if (line_num != -1)
-            dbuf_printf(&dbuf, ":%d", line_num);
+            dbuf_printf(&dbuf, ":%d:%d", line_num, col_num);
         dbuf_putc(&dbuf, '\n');
         str = JS_NewString(ctx, filename);
-        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_fileName, str,
-                               JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-        JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_lineNumber, JS_NewInt32(ctx, line_num),
-                               JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-        if (backtrace_flags & JS_BACKTRACE_FLAG_SINGLE_LEVEL)
-            goto done;
+        if (JS_IsException(str))
+            return;
+        /* Note: SpiderMonkey does that, could update once there is a standard */
+        if (JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_fileName, str,
+                                   JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE) < 0 ||
+            JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_lineNumber, JS_NewInt32(ctx, line_num),
+                                   JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE) < 0 ||
+            JS_DefinePropertyValue(ctx, error_obj, JS_ATOM_columnNumber, JS_NewInt32(ctx, col_num),
+                                   JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE) < 0) {
+            return;
+        }
     }
     for(sf = ctx->rt->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
+        if (sf->js_mode & JS_MODE_BACKTRACE_BARRIER)
+            break;
         if (backtrace_flags & JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL) {
             backtrace_flags &= ~JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL;
             continue;
@@ -6499,34 +6955,28 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
         JS_FreeCString(ctx, func_name_str);
 
         p = JS_VALUE_GET_OBJ(sf->cur_func);
-        backtrace_barrier = FALSE;
         if (js_class_has_bytecode(p->class_id)) {
             JSFunctionBytecode *b;
             const char *atom_str;
-            int line_num1;
+            int line_num1, col_num1;
 
             b = p->u.func.function_bytecode;
-            backtrace_barrier = b->backtrace_barrier;
             if (b->has_debug) {
                 line_num1 = find_line_num(ctx, b,
-                                          sf->cur_pc - b->byte_code_buf - 1);
+                                          sf->cur_pc - b->byte_code_buf - 1, &col_num1);
                 atom_str = JS_AtomToCString(ctx, b->debug.filename);
                 dbuf_printf(&dbuf, " (%s",
                             atom_str ? atom_str : "<null>");
                 JS_FreeCString(ctx, atom_str);
-                if (line_num1 != -1)
-                    dbuf_printf(&dbuf, ":%d", line_num1);
+                if (line_num1 != 0)
+                    dbuf_printf(&dbuf, ":%d:%d", line_num1, col_num1);
                 dbuf_putc(&dbuf, ')');
             }
         } else {
             dbuf_printf(&dbuf, " (native)");
         }
         dbuf_putc(&dbuf, '\n');
-        /* stop backtrace if JS_EVAL_FLAG_BACKTRACE_BARRIER was used */
-        if (backtrace_barrier)
-            break;
     }
- done:
     dbuf_putc(&dbuf, '\0');
     if (dbuf_error(&dbuf))
         str = JS_NULL;
@@ -6572,9 +7022,9 @@ static JSValue JS_ThrowError2(JSContext *ctx, JSErrorEnum error_num,
         JS_DefinePropertyValue(ctx, obj, JS_ATOM_message,
                                JS_NewString(ctx, buf),
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    }
-    if (add_backtrace) {
-        build_backtrace(ctx, obj, NULL, 0, 0);
+        if (add_backtrace) {
+            build_backtrace(ctx, obj, NULL, 0, 0, 0);
+        }
     }
     ret = JS_Throw(ctx, obj);
     return ret;
@@ -6760,15 +7210,19 @@ static JSValue JS_ThrowTypeErrorInvalidClass(JSContext *ctx, int class_id)
     return JS_ThrowTypeErrorAtom(ctx, "%s object expected", name);
 }
 
+static void JS_ThrowInterrupted(JSContext *ctx)
+{
+    JS_ThrowInternalError(ctx, "interrupted");
+    JS_SetUncatchableException(ctx, TRUE);
+}
+
 static no_inline __exception int __js_poll_interrupts(JSContext *ctx)
 {
     JSRuntime *rt = ctx->rt;
     ctx->interrupt_counter = JS_INTERRUPT_COUNTER_INIT;
     if (rt->interrupt_handler) {
         if (rt->interrupt_handler(rt, rt->interrupt_opaque)) {
-            /* XXX: should set a specific flag to avoid catching */
-            JS_ThrowInternalError(ctx, "interrupted");
-            JS_SetUncatchableError(ctx, ctx->rt->current_exception, TRUE);
+            JS_ThrowInterrupted(ctx);
             return -1;
         }
     }
@@ -6784,7 +7238,17 @@ static inline __exception int js_poll_interrupts(JSContext *ctx)
     }
 }
 
-/* return -1 (exception) or TRUE/FALSE */
+static void JS_SetImmutablePrototype(JSContext *ctx, JSValueConst obj)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
+        return;
+    p = JS_VALUE_GET_OBJ(obj);
+    p->has_immutable_prototype = TRUE;
+}
+
+/* Return -1 (exception) or TRUE/FALSE. 'throw_flag' = FALSE indicates
+   that it is called from Reflect.setPrototypeOf(). */
 static int JS_SetPrototypeInternal(JSContext *ctx, JSValueConst obj,
                                    JSValueConst proto_val,
                                    BOOL throw_flag)
@@ -6815,12 +7279,32 @@ static int JS_SetPrototypeInternal(JSContext *ctx, JSValueConst obj,
     if (throw_flag && JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
         return TRUE;
 
-    if (unlikely(p->class_id == JS_CLASS_PROXY))
-        return js_proxy_setPrototypeOf(ctx, obj, proto_val, throw_flag);
+    if (unlikely(p->is_exotic)) {
+        const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
+        int ret;
+        if (em && em->set_prototype) {
+            ret = em->set_prototype(ctx, obj, proto_val);
+            if (ret == 0 && throw_flag) {
+                JS_ThrowTypeError(ctx, "proxy: bad prototype");
+                return -1;
+            } else {
+                return ret;
+            }
+        }
+    }
+
     sh = p->shape;
     if (sh->proto == proto)
         return TRUE;
-    if (!p->extensible) {
+    if (unlikely(p->has_immutable_prototype)) {
+        if (throw_flag) {
+            JS_ThrowTypeError(ctx, "prototype is immutable");
+            return -1;
+        } else {
+            return FALSE;
+        }
+    }
+    if (unlikely(!p->extensible)) {
         if (throw_flag) {
             JS_ThrowTypeError(ctx, "object is not extensible");
             return -1;
@@ -6865,17 +7349,10 @@ int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val)
 static JSValueConst JS_GetPrototypePrimitive(JSContext *ctx, JSValueConst val)
 {
     switch(JS_VALUE_GET_NORM_TAG(val)) {
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
         val = ctx->class_proto[JS_CLASS_BIG_INT];
         break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        val = ctx->class_proto[JS_CLASS_BIG_FLOAT];
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        val = ctx->class_proto[JS_CLASS_BIG_DECIMAL];
-        break;
-#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         val = ctx->class_proto[JS_CLASS_NUMBER];
@@ -6884,6 +7361,7 @@ static JSValueConst JS_GetPrototypePrimitive(JSContext *ctx, JSValueConst val)
         val = ctx->class_proto[JS_CLASS_BOOLEAN];
         break;
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         val = ctx->class_proto[JS_CLASS_STRING];
         break;
     case JS_TAG_SYMBOL:
@@ -6899,22 +7377,24 @@ static JSValueConst JS_GetPrototypePrimitive(JSContext *ctx, JSValueConst val)
     return val;
 }
 
-/* Return an Object, JS_NULL or JS_EXCEPTION in case of Proxy object. */
+/* Return an Object, JS_NULL or JS_EXCEPTION in case of exotic object. */
 JSValue JS_GetPrototype(JSContext *ctx, JSValueConst obj)
 {
     JSValue val;
     if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
         JSObject *p;
         p = JS_VALUE_GET_OBJ(obj);
-        if (unlikely(p->class_id == JS_CLASS_PROXY)) {
-            val = js_proxy_getPrototypeOf(ctx, obj);
-        } else {
-            p = p->shape->proto;
-            if (!p)
-                val = JS_NULL;
-            else
-                val = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+        if (unlikely(p->is_exotic)) {
+            const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
+            if (em && em->get_prototype) {
+                return em->get_prototype(ctx, obj);
+            }
         }
+        p = p->shape->proto;
+        if (!p)
+            val = JS_NULL;
+        else
+            val = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
     } else {
         val = JS_DupValue(ctx, JS_GetPrototypePrimitive(ctx, obj));
     }
@@ -6961,8 +7441,8 @@ static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValueConst val,
     for(;;) {
         proto1 = p->shape->proto;
         if (!proto1) {
-            /* slow case if proxy in the prototype chain */
-            if (unlikely(p->class_id == JS_CLASS_PROXY)) {
+            /* slow case if exotic object in the prototype chain */
+            if (unlikely(p->is_exotic && !p->fast_array)) {
                 JSValue obj1;
                 obj1 = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
                 for(;;) {
@@ -7044,12 +7524,14 @@ static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
     JSValue val;
     JSContext *realm;
     JSAutoInitFunc *func;
-
+    JSAutoInitIDEnum id;
+    
     if (js_shape_prepare_update(ctx, p, &prs))
         return -1;
 
     realm = js_autoinit_get_realm(pr);
-    func = js_autoinit_func_table[js_autoinit_get_id(pr)];
+    id = js_autoinit_get_id(pr);
+    func = js_autoinit_func_table[id];
     /* 'func' shall not modify the object properties 'pr' */
     val = func(realm, p, prop, pr->u.init.opaque);
     js_autoinit_free(ctx->rt, pr);
@@ -7057,7 +7539,15 @@ static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
     pr->u.value = JS_UNDEFINED;
     if (JS_IsException(val))
         return -1;
-    pr->u.value = val;
+    if (id == JS_AUTOINIT_ID_MODULE_NS &&
+        JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        /* WARNING: a varref is returned as a string  ! */
+        prs->flags |= JS_PROP_VARREF;
+        pr->u.var_ref = JS_VALUE_GET_PTR(val);
+        pr->u.var_ref->header.ref_count++;
+    } else {
+        pr->u.value = val;
+    }
     return 0;
 }
 
@@ -7083,14 +7573,24 @@ JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
             {
                 JSString *p1 = JS_VALUE_GET_STRING(obj);
                 if (__JS_AtomIsTaggedInt(prop)) {
-                    uint32_t idx, ch;
+                    uint32_t idx;
                     idx = __JS_AtomToUInt32(prop);
                     if (idx < p1->len) {
-                        if (p1->is_wide_char)
-                            ch = p1->u.str16[idx];
-                        else
-                            ch = p1->u.str8[idx];
-                        return js_new_string_char(ctx, ch);
+                        return js_new_string_char(ctx, string_get(p1, idx));
+                    }
+                } else if (prop == JS_ATOM_length) {
+                    return JS_NewInt32(ctx, p1->len);
+                }
+            }
+            break;
+        case JS_TAG_STRING_ROPE:
+            {
+                JSStringRope *p1 = JS_VALUE_GET_STRING_ROPE(obj);
+                if (__JS_AtomIsTaggedInt(prop)) {
+                    uint32_t idx;
+                    idx = __JS_AtomToUInt32(prop);
+                    if (idx < p1->len) {
+                        return js_new_string_char(ctx, string_rope_get(obj, idx));
                     }
                 } else if (prop == JS_ATOM_length) {
                     return JS_NewInt32(ctx, p1->len);
@@ -7303,6 +7803,8 @@ static int JS_SetPrivateField(JSContext *ctx, JSValueConst obj,
     return 0;
 }
 
+/* add a private brand field to 'home_obj' if not already present and
+   if obj is != null add a private brand to it */
 static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
 {
     JSObject *p, *p1;
@@ -7310,7 +7812,7 @@ static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
     JSProperty *pr;
     JSValue brand;
     JSAtom brand_atom;
-    
+
     if (unlikely(JS_VALUE_GET_TAG(home_obj) != JS_TAG_OBJECT)) {
         JS_ThrowTypeErrorNotAnObject(ctx);
         return -1;
@@ -7318,10 +7820,10 @@ static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
     p = JS_VALUE_GET_OBJ(home_obj);
     prs = find_own_property(&pr, p, JS_ATOM_Private_brand);
     if (!prs) {
+        /* if the brand is not present, add it */
         brand = JS_NewSymbolFromAtom(ctx, JS_ATOM_brand, JS_ATOM_TYPE_PRIVATE);
         if (JS_IsException(brand))
             return -1;
-        /* if the brand is not present, add it */
         pr = add_property(ctx, p, JS_ATOM_Private_brand, JS_PROP_C_W_E);
         if (!pr) {
             JS_FreeValue(ctx, brand);
@@ -7332,34 +7834,38 @@ static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
         brand = JS_DupValue(ctx, pr->u.value);
     }
     brand_atom = js_symbol_to_atom(ctx, brand);
-    
-    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
-        JS_ThrowTypeErrorNotAnObject(ctx);
+
+    if (JS_IsObject(obj)) {
+        p1 = JS_VALUE_GET_OBJ(obj);
+        prs = find_own_property(&pr, p1, brand_atom);
+        if (unlikely(prs)) {
+            JS_FreeAtom(ctx, brand_atom);
+            JS_ThrowTypeError(ctx, "private method is already present");
+            return -1;
+        }
+        pr = add_property(ctx, p1, brand_atom, JS_PROP_C_W_E);
+        JS_FreeAtom(ctx, brand_atom);
+        if (!pr)
+            return -1;
+        pr->u.value = JS_UNDEFINED;
+    } else {
         JS_FreeAtom(ctx, brand_atom);
-        return -1;
     }
-    p1 = JS_VALUE_GET_OBJ(obj);
-    pr = add_property(ctx, p1, brand_atom, JS_PROP_C_W_E);
-    JS_FreeAtom(ctx, brand_atom);
-    if (!pr)
-        return -1;
-    pr->u.value = JS_UNDEFINED;
     return 0;
 }
 
+/* return a boolean telling if the brand of the home object of 'func'
+   is present on 'obj' or -1 in case of exception */
 static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
 {
     JSObject *p, *p1, *home_obj;
     JSShapeProperty *prs;
     JSProperty *pr;
     JSValueConst brand;
-    
+
     /* get the home object of 'func' */
-    if (unlikely(JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)) {
-    not_obj:
-        JS_ThrowTypeErrorNotAnObject(ctx);
-        return -1;
-    }
+    if (unlikely(JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT))
+        goto not_obj;
     p1 = JS_VALUE_GET_OBJ(func);
     if (!js_class_has_bytecode(p1->class_id))
         goto not_obj;
@@ -7375,30 +7881,28 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     /* safety check */
     if (unlikely(JS_VALUE_GET_TAG(brand) != JS_TAG_SYMBOL))
         goto not_obj;
-    
+
     /* get the brand array of 'obj' */
-    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
-        goto not_obj;
-    p = JS_VALUE_GET_OBJ(obj);
-    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
-    if (!prs) {
-        JS_ThrowTypeError(ctx, "invalid brand on object");
+    if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
+    not_obj:
+        JS_ThrowTypeErrorNotAnObject(ctx);
         return -1;
     }
-    return 0;
+    p = JS_VALUE_GET_OBJ(obj);
+    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
+    return (prs != NULL);
 }
 
 static uint32_t js_string_obj_get_length(JSContext *ctx,
                                          JSValueConst obj)
 {
     JSObject *p;
-    JSString *p1;
     uint32_t len = 0;
 
     /* This is a class exotic method: obj class_id is JS_CLASS_STRING */
     p = JS_VALUE_GET_OBJ(obj);
     if (JS_VALUE_GET_TAG(p->u.object_data) == JS_TAG_STRING) {
-        p1 = JS_VALUE_GET_STRING(p->u.object_data);
+        JSString *p1 = JS_VALUE_GET_STRING(p->u.object_data);
         len = p1->len;
     }
     return len;
@@ -7423,7 +7927,7 @@ static int num_keys_cmp(const void *p1, const void *p2, void *opaque)
         return 1;
 }
 
-static void js_free_prop_enum(JSContext *ctx, JSPropertyEnum *tab, uint32_t len)
+void JS_FreePropertyEnum(JSContext *ctx, JSPropertyEnum *tab, uint32_t len)
 {
     uint32_t i;
     if (tab) {
@@ -7450,7 +7954,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
     BOOL is_enumerable, num_sorted;
     uint32_t num_key;
     JSAtomKindEnum kind;
-    
+
     /* clear pointer for consistency in case of failure */
     *ptab = NULL;
     *plen = 0;
@@ -7517,7 +8021,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
                             /* set the "is_enumerable" field if necessary */
                             res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
                             if (res < 0) {
-                                js_free_prop_enum(ctx, tab_exotic, exotic_count);
+                                JS_FreePropertyEnum(ctx, tab_exotic, exotic_count);
                                 return -1;
                             }
                             if (res) {
@@ -7538,11 +8042,25 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
 
     /* fill them */
 
-    atom_count = num_keys_count + str_keys_count + sym_keys_count + exotic_keys_count;
+    atom_count = num_keys_count + str_keys_count;
+    if (atom_count < str_keys_count)
+        goto add_overflow;
+    atom_count += sym_keys_count;
+    if (atom_count < sym_keys_count)
+        goto add_overflow;
+    atom_count += exotic_keys_count;
+    if (atom_count < exotic_keys_count || atom_count > INT32_MAX) {
+    add_overflow:
+        JS_ThrowOutOfMemory(ctx);
+        JS_FreePropertyEnum(ctx, tab_exotic, exotic_count);
+        return -1;
+    }
+    /* XXX: need generic way to test for js_malloc(ctx, a * b) overflow */
+    
     /* avoid allocating 0 bytes */
     tab_atom = js_malloc(ctx, sizeof(tab_atom[0]) * max_int(atom_count, 1));
     if (!tab_atom) {
-        js_free_prop_enum(ctx, tab_exotic, exotic_count);
+        JS_FreePropertyEnum(ctx, tab_exotic, exotic_count);
         return -1;
     }
 
@@ -7587,7 +8105,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
                 for(i = 0; i < len; i++) {
                     tab_atom[num_index].atom = __JS_AtomFromUInt32(i);
                     if (tab_atom[num_index].atom == JS_ATOM_NULL) {
-                        js_free_prop_enum(ctx, tab_atom, num_index);
+                        JS_FreePropertyEnum(ctx, tab_atom, num_index);
                         return -1;
                     }
                     tab_atom[num_index].is_enumerable = TRUE;
@@ -7728,7 +8246,7 @@ int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
     return JS_GetOwnPropertyInternal(ctx, desc, JS_VALUE_GET_OBJ(obj), prop);
 }
 
-/* return -1 if exception (Proxy object only) or TRUE/FALSE */
+/* return -1 if exception (exotic object only) or TRUE/FALSE */
 int JS_IsExtensible(JSContext *ctx, JSValueConst obj)
 {
     JSObject *p;
@@ -7736,13 +8254,16 @@ int JS_IsExtensible(JSContext *ctx, JSValueConst obj)
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         return FALSE;
     p = JS_VALUE_GET_OBJ(obj);
-    if (unlikely(p->class_id == JS_CLASS_PROXY))
-        return js_proxy_isExtensible(ctx, obj);
-    else
-        return p->extensible;
+    if (unlikely(p->is_exotic)) {
+        const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
+        if (em && em->is_extensible) {
+            return em->is_extensible(ctx, obj);
+        }
+    }
+    return p->extensible;
 }
 
-/* return -1 if exception (Proxy object only) or TRUE/FALSE */
+/* return -1 if exception (exotic object only) or TRUE/FALSE */
 int JS_PreventExtensions(JSContext *ctx, JSValueConst obj)
 {
     JSObject *p;
@@ -7750,8 +8271,12 @@ int JS_PreventExtensions(JSContext *ctx, JSValueConst obj)
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         return FALSE;
     p = JS_VALUE_GET_OBJ(obj);
-    if (unlikely(p->class_id == JS_CLASS_PROXY))
-        return js_proxy_preventExtensions(ctx, obj);
+    if (unlikely(p->is_exotic)) {
+        const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
+        if (em && em->prevent_extensions) {
+            return em->prevent_extensions(ctx, obj);
+        }
+    }
     p->extensible = FALSE;
     return TRUE;
 }
@@ -7842,45 +8367,61 @@ static JSValue JS_GetPropertyValue(JSContext *ctx, JSValueConst this_obj,
     if (likely(JS_VALUE_GET_TAG(this_obj) == JS_TAG_OBJECT &&
                JS_VALUE_GET_TAG(prop) == JS_TAG_INT)) {
         JSObject *p;
-        uint32_t idx, len;
+        uint32_t idx;
         /* fast path for array access */
         p = JS_VALUE_GET_OBJ(this_obj);
         if (unlikely(!p->fast_array))
             goto slow_path;
         idx = JS_VALUE_GET_INT(prop);
-        len = (uint32_t)p->u.array.count;
-        if (unlikely(idx >= len))
-            goto slow_path;
         switch(p->class_id) {
         case JS_CLASS_ARRAY:
         case JS_CLASS_ARGUMENTS:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_DupValue(ctx, p->u.array.u.values[idx]);
         case JS_CLASS_INT8_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewInt32(ctx, p->u.array.u.int8_ptr[idx]);
         case JS_CLASS_UINT8C_ARRAY:
         case JS_CLASS_UINT8_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewInt32(ctx, p->u.array.u.uint8_ptr[idx]);
         case JS_CLASS_INT16_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewInt32(ctx, p->u.array.u.int16_ptr[idx]);
         case JS_CLASS_UINT16_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewInt32(ctx, p->u.array.u.uint16_ptr[idx]);
         case JS_CLASS_INT32_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewInt32(ctx, p->u.array.u.int32_ptr[idx]);
         case JS_CLASS_UINT32_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewUint32(ctx, p->u.array.u.uint32_ptr[idx]);
         case JS_CLASS_BIG_INT64_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewBigInt64(ctx, p->u.array.u.int64_ptr[idx]);
         case JS_CLASS_BIG_UINT64_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return JS_NewBigUint64(ctx, p->u.array.u.uint64_ptr[idx]);
+        case JS_CLASS_FLOAT16_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
+            return __JS_NewFloat64(ctx, fromfp16(p->u.array.u.fp16_ptr[idx]));
         case JS_CLASS_FLOAT32_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return __JS_NewFloat64(ctx, p->u.array.u.float_ptr[idx]);
         case JS_CLASS_FLOAT64_ARRAY:
+            if (unlikely(idx >= p->u.array.count)) goto slow_path;
             return __JS_NewFloat64(ctx, p->u.array.u.double_ptr[idx]);
         default:
             goto slow_path;
         }
     } else {
     slow_path:
+        /* ToObject() must be done before ToPropertyKey() */
+        if (JS_IsNull(this_obj) || JS_IsUndefined(this_obj)) {
+            JS_FreeValue(ctx, prop);
+            return JS_ThrowTypeError(ctx, "cannot read property of %s", JS_IsNull(this_obj) ? "null" : "undefined");
+        }
         atom = JS_ValueToAtom(ctx, prop);
         JS_FreeValue(ctx, prop);
         if (unlikely(atom == JS_ATOM_NULL))
@@ -7957,6 +8498,8 @@ JSValue JS_GetPropertyStr(JSContext *ctx, JSValueConst this_obj,
     JSAtom atom;
     JSValue ret;
     atom = JS_NewAtom(ctx, prop);
+    if (atom == JS_ATOM_NULL)
+        return JS_EXCEPTION;
     ret = JS_GetProperty(ctx, this_obj, atom);
     JS_FreeAtom(ctx, atom);
     return ret;
@@ -8292,6 +8835,30 @@ static int add_fast_array_element(JSContext *ctx, JSObject *p,
     return TRUE;
 }
 
+/* Allocate a new fast array. Its 'length' property is set to zero. It
+   maximum size is 2^31-1 elements. For convenience, 'len' is a 64 bit
+   integer. WARNING: the content of the array is not initialized. */
+static JSValue js_allocate_fast_array(JSContext *ctx, int64_t len)
+{
+    JSValue arr;
+    JSObject *p;
+
+    if (len > INT32_MAX)
+        return JS_ThrowRangeError(ctx, "invalid array length");
+    arr = JS_NewArray(ctx);
+    if (JS_IsException(arr))
+        return arr;
+    if (len > 0) {
+        p = JS_VALUE_GET_OBJ(arr);
+        if (expand_fast_array(ctx, p, len) < 0) {
+            JS_FreeValue(ctx, arr);
+            return JS_EXCEPTION;
+        }
+        p->u.array.count = len;
+    }
+    return arr;
+}
+
 static void js_free_desc(JSContext *ctx, JSPropertyDescriptor *desc)
 {
     JS_FreeValue(ctx, desc->getter);
@@ -8381,7 +8948,7 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst obj,
             goto read_only_prop;
         }
     }
-    
+
     for(;;) {
         if (p1->is_exotic) {
             if (p1->fast_array) {
@@ -8405,17 +8972,21 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst obj,
                             return -1;
                         }
                     typed_array_oob:
-                        /* must convert the argument even if out of bound access */
-                        if (p1->class_id == JS_CLASS_BIG_INT64_ARRAY ||
-                            p1->class_id == JS_CLASS_BIG_UINT64_ARRAY) {
-                            int64_t v;
-                            if (JS_ToBigInt64Free(ctx, &v, val))
-                                return -1;
+                        if (p == p1) {
+                            /* must convert the argument even if out of bound access */
+                            if (p1->class_id == JS_CLASS_BIG_INT64_ARRAY ||
+                                p1->class_id == JS_CLASS_BIG_UINT64_ARRAY) {
+                                int64_t v;
+                                if (JS_ToBigInt64Free(ctx, &v, val))
+                                    return -1;
+                            } else {
+                                val = JS_ToNumberFree(ctx, val);
+                                JS_FreeValue(ctx, val);
+                                if (JS_IsException(val))
+                                    return -1;
+                            }
                         } else {
-                            val = JS_ToNumberFree(ctx, val);
                             JS_FreeValue(ctx, val);
-                            if (JS_IsException(val))
-                                return -1;
                         }
                         return TRUE;
                     }
@@ -8490,6 +9061,8 @@ int JS_SetPropertyInternal(JSContext *ctx, JSValueConst obj,
                 goto retry2;
             } else if (!(prs->flags & JS_PROP_WRITABLE)) {
                 goto read_only_prop;
+            } else {
+                break;
             }
         }
     }
@@ -8669,6 +9242,13 @@ static int JS_SetPropertyValue(JSContext *ctx, JSValueConst this_obj,
                 p->u.array.u.uint64_ptr[idx] = v;
             }
             break;
+        case JS_CLASS_FLOAT16_ARRAY:
+            if (JS_ToFloat64Free(ctx, &d, val))
+                return -1;
+            if (unlikely(idx >= (uint32_t)p->u.array.count))
+                goto ta_out_of_bound;
+            p->u.array.u.fp16_ptr[idx] = tofp16(d);
+            break;
         case JS_CLASS_FLOAT32_ARRAY:
             if (JS_ToFloat64Free(ctx, &d, val))
                 return -1;
@@ -8739,6 +9319,10 @@ int JS_SetPropertyStr(JSContext *ctx, JSValueConst this_obj,
     JSAtom atom;
     int ret;
     atom = JS_NewAtom(ctx, prop);
+    if (atom == JS_ATOM_NULL) {
+        JS_FreeValue(ctx, val);
+        return -1;
+    }
     ret = JS_SetPropertyInternal(ctx, this_obj, atom, val, this_obj, JS_PROP_THROW);
     JS_FreeAtom(ctx, atom);
     return ret;
@@ -8880,15 +9464,13 @@ static BOOL check_define_prop_flags(int prop_flags, int flags)
         if ((flags & JS_PROP_HAS_ENUMERABLE) &&
             (flags & JS_PROP_ENUMERABLE) != (prop_flags & JS_PROP_ENUMERABLE))
             return FALSE;
-    }
-    if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
-                 JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
-        if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
+        if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
+                     JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
             has_accessor = ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) != 0);
             is_getset = ((prop_flags & JS_PROP_TMASK) == JS_PROP_GETSET);
             if (has_accessor != is_getset)
                 return FALSE;
-            if (!has_accessor && !is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
+            if (!is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
                 /* not writable: cannot set the writable bit */
                 if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
                     (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE))
@@ -9079,15 +9661,19 @@ int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
                                spaces. */
                             if (!js_same_value(ctx, val, *pr->u.var_ref->pvalue))
                                 goto not_configurable;
+                        } else {
+                            /* update the reference */
+                            set_value(ctx, pr->u.var_ref->pvalue,
+                                      JS_DupValue(ctx, val));
                         }
-                        /* update the reference */
-                        set_value(ctx, pr->u.var_ref->pvalue,
-                                  JS_DupValue(ctx, val));
                     }
                     /* if writable is set to false, no longer a
                        reference (for mapped arguments) */
                     if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) == JS_PROP_HAS_WRITABLE) {
                         JSValue val1;
+                        if (p->class_id == JS_CLASS_MODULE_NS) {
+                            return JS_ThrowTypeErrorOrFalse(ctx, flags, "module namespace properties have writable = false");
+                        }
                         if (js_shape_prepare_update(ctx, p, &prs))
                             return -1;
                         val1 = JS_DupValue(ctx, *pr->u.var_ref->pvalue);
@@ -9293,6 +9879,10 @@ int JS_DefinePropertyValueStr(JSContext *ctx, JSValueConst this_obj,
     JSAtom atom;
     int ret;
     atom = JS_NewAtom(ctx, prop);
+    if (atom == JS_ATOM_NULL) {
+        JS_FreeValue(ctx, val);
+        return -1;
+    }
     ret = JS_DefinePropertyValue(ctx, this_obj, atom, val, flags);
     JS_FreeAtom(ctx, atom);
     return ret;
@@ -9328,7 +9918,7 @@ static BOOL js_object_has_name(JSContext *ctx, JSValueConst obj)
     JSShapeProperty *prs;
     JSValueConst val;
     JSString *p;
-    
+
     prs = find_own_property(&pr, JS_VALUE_GET_OBJ(obj), JS_ATOM_name);
     if (!prs)
         return FALSE;
@@ -9587,12 +10177,38 @@ static int JS_SetGlobalVar(JSContext *ctx, JSAtom prop, JSValue val,
         set_value(ctx, &pr->u.value, val);
         return 0;
     }
+    /* XXX: add a fast path where the property exists and the object
+       is not exotic. Otherwise do as in OP_put_ref_value and remove
+       JS_PROP_NO_ADD which is no longer necessary */
     flags = JS_PROP_THROW_STRICT;
-    if (is_strict_mode(ctx)) 
+    if (is_strict_mode(ctx))
         flags |= JS_PROP_NO_ADD;
     return JS_SetPropertyInternal(ctx, ctx->global_obj, prop, val, ctx->global_obj, flags);
 }
 
+/* return -1, FALSE or TRUE */
+static int JS_DeleteGlobalVar(JSContext *ctx, JSAtom prop)
+{
+    JSObject *p;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    int ret;
+
+    /* 9.1.1.4.7 DeleteBinding ( N ) */
+    p = JS_VALUE_GET_OBJ(ctx->global_var_obj);
+    prs = find_own_property(&pr, p, prop);
+    if (prs)
+        return FALSE; /* lexical variables cannot be deleted */
+    ret = JS_HasProperty(ctx, ctx->global_obj, prop);
+    if (ret < 0)
+        return -1;
+    if (ret) {
+        return JS_DeleteProperty(ctx, ctx->global_obj, prop, 0);
+    } else {
+        return TRUE;
+    }
+}
+
 /* return -1, FALSE or TRUE. return FALSE if not configurable or
    invalid object. return -1 in case of exception.
    flags can be 0, JS_PROP_THROW or JS_PROP_THROW_STRICT */
@@ -9601,7 +10217,7 @@ int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags)
     JSValue obj1;
     JSObject *p;
     int res;
-    
+
     obj1 = JS_ToObject(ctx, obj);
     if (JS_IsException(obj1))
         return -1;
@@ -9691,29 +10307,10 @@ BOOL JS_IsError(JSContext *ctx, JSValueConst val)
     return (p->class_id == JS_CLASS_ERROR);
 }
 
-/* used to avoid catching interrupt exceptions */
-BOOL JS_IsUncatchableError(JSContext *ctx, JSValueConst val)
+/* must be called after JS_Throw() */
+void JS_SetUncatchableException(JSContext *ctx, BOOL flag)
 {
-    JSObject *p;
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
-        return FALSE;
-    p = JS_VALUE_GET_OBJ(val);
-    return p->class_id == JS_CLASS_ERROR && p->is_uncatchable_error;
-}
-
-void JS_SetUncatchableError(JSContext *ctx, JSValueConst val, BOOL flag)
-{
-    JSObject *p;
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
-        return;
-    p = JS_VALUE_GET_OBJ(val);
-    if (p->class_id == JS_CLASS_ERROR)
-        p->is_uncatchable_error = flag;
-}
-
-void JS_ResetUncatchableError(JSContext *ctx)
-{
-    JS_SetUncatchableError(ctx, ctx->rt->current_exception, FALSE);
+    ctx->rt->current_exception_is_uncatchable = flag;
 }
 
 void JS_SetOpaque(JSValue obj, void *opaque)
@@ -9746,11 +10343,17 @@ void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id)
     return p;
 }
 
-#define HINT_STRING  0
-#define HINT_NUMBER  1
-#define HINT_NONE    2
-/* don't try Symbol.toPrimitive */
-#define HINT_FORCE_ORDINARY (1 << 4)
+void *JS_GetAnyOpaque(JSValueConst obj, JSClassID *class_id)
+{
+    JSObject *p;
+    if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT) {
+        *class_id = 0;
+        return NULL;
+    }
+    p = JS_VALUE_GET_OBJ(obj);
+    *class_id = p->class_id;
+    return p->u.opaque;
+}
 
 static JSValue JS_ToPrimitiveFree(JSContext *ctx, JSValue val, int hint)
 {
@@ -9848,7 +10451,7 @@ static inline BOOL JS_IsHTMLDDA(JSContext *ctx, JSValueConst obj)
     p = JS_VALUE_GET_OBJ(obj);
     return p->is_HTMLDDA;
 }
-                         
+
 static int JS_ToBoolFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag = JS_VALUE_GET_TAG(val);
@@ -9867,27 +10470,33 @@ static int JS_ToBoolFree(JSContext *ctx, JSValue val)
             JS_FreeValue(ctx, val);
             return ret;
         }
-    case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif        
+    case JS_TAG_STRING_ROPE:
         {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            BOOL ret;
-            ret = p->num.expn != BF_EXP_ZERO && p->num.expn != BF_EXP_NAN;
+            BOOL ret = JS_VALUE_GET_STRING_ROPE(val)->len != 0;
             JS_FreeValue(ctx, val);
             return ret;
         }
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_DECIMAL:
+    case JS_TAG_SHORT_BIG_INT:
+        return JS_VALUE_GET_SHORT_BIG_INT(val) != 0;
+    case JS_TAG_BIG_INT:
         {
-            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
+            JSBigInt *p = JS_VALUE_GET_PTR(val);
             BOOL ret;
-            ret = p->num.expn != BF_EXP_ZERO && p->num.expn != BF_EXP_NAN;
+            int i;
+            
+            /* fail safe: we assume it is not necessarily
+               normalized. Beginning from the MSB ensures that the
+               test is fast. */
+            ret = FALSE;
+            for(i = p->len - 1; i >= 0; i--) {
+                if (p->tab[i] != 0) {
+                    ret = TRUE;
+                    break;
+                }
+            }
             JS_FreeValue(ctx, val);
             return ret;
         }
-#endif
     case JS_TAG_OBJECT:
         {
             JSObject *p = JS_VALUE_GET_OBJ(val);
@@ -9947,2862 +10556,3405 @@ static inline int to_digit(int c)
         return 36;
 }
 
-/* XXX: remove */
-static double js_strtod(const char *p, int radix, BOOL is_float)
-{
-    double d;
-    int c;
-    
-    if (!is_float || radix != 10) {
-        uint64_t n_max, n;
-        int int_exp, is_neg;
-        
-        is_neg = 0;
-        if (*p == '-') {
-            is_neg = 1;
-            p++;
-        }
+/* bigint support */
 
-        /* skip leading zeros */
-        while (*p == '0')
-            p++;
-        n = 0;
-        if (radix == 10)
-            n_max = ((uint64_t)-1 - 9) / 10; /* most common case */
-        else
-            n_max = ((uint64_t)-1 - (radix - 1)) / radix;
-        /* XXX: could be more precise */
-        int_exp = 0;
-        while (*p != '\0') {
-            c = to_digit((uint8_t)*p);
-            if (c >= radix)
-                break;
-            if (n <= n_max) {
-                n = n * radix + c;
-            } else {
-                int_exp++;
-            }
-            p++;
-        }
-        d = n;
-        if (int_exp != 0) {
-            d *= pow(radix, int_exp);
-        }
-        if (is_neg)
-            d = -d;
-    } else {
-        d = strtod(p, NULL);
-    }
-    return d;
-}
+#define JS_BIGINT_MAX_SIZE ((1024 * 1024) / JS_LIMB_BITS) /* in limbs */
 
-#define ATOD_INT_ONLY        (1 << 0)
-/* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
-#define ATOD_ACCEPT_BIN_OCT  (1 << 2)
-/* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
-#define ATOD_ACCEPT_LEGACY_OCTAL  (1 << 4)
-/* accept _ between digits as a digit separator */
-#define ATOD_ACCEPT_UNDERSCORES  (1 << 5)
-/* allow a suffix to override the type */
-#define ATOD_ACCEPT_SUFFIX    (1 << 6) 
-/* default type */
-#define ATOD_TYPE_MASK        (3 << 7)
-#define ATOD_TYPE_FLOAT64     (0 << 7)
-#define ATOD_TYPE_BIG_INT     (1 << 7)
-#ifdef CONFIG_BIGNUM
-#define ATOD_TYPE_BIG_FLOAT   (2 << 7)
-#define ATOD_TYPE_BIG_DECIMAL (3 << 7)
-/* assume bigint mode: floats are parsed as integers if no decimal
-   point nor exponent */
-#define ATOD_MODE_BIGINT      (1 << 9) 
+/* it is currently assumed that JS_SHORT_BIG_INT_BITS = JS_LIMB_BITS */
+#if JS_SHORT_BIG_INT_BITS == 32
+#define JS_SHORT_BIG_INT_MIN INT32_MIN
+#define JS_SHORT_BIG_INT_MAX INT32_MAX
+#elif JS_SHORT_BIG_INT_BITS == 64
+#define JS_SHORT_BIG_INT_MIN INT64_MIN
+#define JS_SHORT_BIG_INT_MAX INT64_MAX
+#else
+#error unsupported
 #endif
-/* accept -0x1 */
-#define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
-static JSValue js_string_to_bigint(JSContext *ctx, const char *buf,
-                                   int radix, int flags, slimb_t *pexponent)
+#define ADDC(res, carry_out, op1, op2, carry_in)        \
+do {                                                    \
+    js_limb_t __v, __a, __k, __k1;                      \
+    __v = (op1);                                        \
+    __a = __v + (op2);                                  \
+    __k1 = __a < __v;                                   \
+    __k = (carry_in);                                   \
+    __a = __a + __k;                                    \
+    carry_out = (__a < __k) | __k1;                     \
+    res = __a;                                          \
+} while (0)
+
+#if JS_LIMB_BITS == 32
+/* a != 0 */
+static inline js_limb_t js_limb_clz(js_limb_t a)
 {
-    bf_t a_s, *a = &a_s;
-    int ret;
-    JSValue val;
-    val = JS_NewBigInt(ctx);
-    if (JS_IsException(val))
-        return val;
-    a = JS_GetBigInt(val);
-    ret = bf_atof(a, buf, NULL, radix, BF_PREC_INF, BF_RNDZ);
-    if (ret & BF_ST_MEM_ERROR) {
-        JS_FreeValue(ctx, val);
-        return JS_ThrowOutOfMemory(ctx);
-    }
-#ifdef CONFIG_BIGNUM
-    val = JS_CompactBigInt1(ctx, val, (flags & ATOD_MODE_BIGINT) != 0);
+    return clz32(a);
+}
 #else
-    val = JS_CompactBigInt1(ctx, val, FALSE);
+static inline js_limb_t js_limb_clz(js_limb_t a)
+{
+    return clz64(a);
+}
 #endif
-    return val;
+
+/* handle a = 0 too */
+static inline js_limb_t js_limb_safe_clz(js_limb_t a)
+{
+    if (a == 0)
+        return JS_LIMB_BITS;
+    else
+        return js_limb_clz(a);
 }
 
-#ifdef CONFIG_BIGNUM
-static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
-                                     int radix, int flags, slimb_t *pexponent)
+static js_limb_t mp_add(js_limb_t *res, const js_limb_t *op1, const js_limb_t *op2,
+                     js_limb_t n, js_limb_t carry)
 {
-    bf_t *a;
-    int ret;
-    JSValue val;
-    
-    val = JS_NewBigFloat(ctx);
-    if (JS_IsException(val))
-        return val;
-    a = JS_GetBigFloat(val);
-    if (flags & ATOD_ACCEPT_SUFFIX) {
-        /* return the exponent to get infinite precision */
-        ret = bf_atof2(a, pexponent, buf, NULL, radix, BF_PREC_INF,
-                       BF_RNDZ | BF_ATOF_EXPONENT);
-    } else {
-        ret = bf_atof(a, buf, NULL, radix, ctx->fp_env.prec,
-                      ctx->fp_env.flags);
-    }
-    if (ret & BF_ST_MEM_ERROR) {
-        JS_FreeValue(ctx, val);
-        return JS_ThrowOutOfMemory(ctx);
+    int i;
+    for(i = 0;i < n; i++) {
+        ADDC(res[i], carry, op1[i], op2[i], carry);
     }
-    return val;
+    return carry;
 }
 
-static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
-                                       int radix, int flags, slimb_t *pexponent)
+static js_limb_t mp_sub(js_limb_t *res, const js_limb_t *op1, const js_limb_t *op2,
+                        int n, js_limb_t carry)
 {
-    bfdec_t *a;
-    int ret;
-    JSValue val;
-    
-    val = JS_NewBigDecimal(ctx);
-    if (JS_IsException(val))
-        return val;
-    a = JS_GetBigDecimal(val);
-    ret = bfdec_atof(a, buf, NULL, BF_PREC_INF,
-                     BF_RNDZ | BF_ATOF_NO_NAN_INF);
-    if (ret & BF_ST_MEM_ERROR) {
-        JS_FreeValue(ctx, val);
-        return JS_ThrowOutOfMemory(ctx);
+    int i;
+    js_limb_t k, a, v, k1;
+
+    k = carry;
+    for(i=0;i<n;i++) {
+        v = op1[i];
+        a = v - op2[i];
+        k1 = a > v;
+        v = a - k;
+        k = (v > a) | k1;
+        res[i] = v;
     }
-    return val;
+    return k;
 }
-#endif
 
-/* return an exception in case of memory error. Return JS_NAN if
-   invalid syntax */
-#ifdef CONFIG_BIGNUM
-static JSValue js_atof2(JSContext *ctx, const char *str, const char **pp,
-                        int radix, int flags, slimb_t *pexponent)
-#else
-static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
-                       int radix, int flags)
-#endif
+/* compute 0 - op2. carry = 0 or 1. */
+static js_limb_t mp_neg(js_limb_t *res, const js_limb_t *op2, int n)
 {
-    const char *p, *p_start;
-    int sep, is_neg;
-    BOOL is_float, has_legacy_octal;
-    int atod_type = flags & ATOD_TYPE_MASK;
-    char buf1[64], *buf;
-    int i, j, len;
-    BOOL buf_allocated = FALSE;
-    JSValue val;
-    
-    /* optional separator between digits */
-    sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
-    has_legacy_octal = FALSE;
-    
-    p = str;
-    p_start = p;
-    is_neg = 0;
-    if (p[0] == '+') {
-        p++;
-        p_start++;
-        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
-            goto no_radix_prefix;
-    } else if (p[0] == '-') {
-        p++;
-        p_start++;
-        is_neg = 1;
-        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
-            goto no_radix_prefix;
-    }
-    if (p[0] == '0') {
-        if ((p[1] == 'x' || p[1] == 'X') &&
-            (radix == 0 || radix == 16)) {
-            p += 2;
-            radix = 16;
-        } else if ((p[1] == 'o' || p[1] == 'O') &&
-                   radix == 0 && (flags & ATOD_ACCEPT_BIN_OCT)) {
-            p += 2;
-            radix = 8;
-        } else if ((p[1] == 'b' || p[1] == 'B') &&
-                   radix == 0 && (flags & ATOD_ACCEPT_BIN_OCT)) {
-            p += 2;
-            radix = 2;
-        } else if ((p[1] >= '0' && p[1] <= '9') &&
-                   radix == 0 && (flags & ATOD_ACCEPT_LEGACY_OCTAL)) {
-            int i;
-            has_legacy_octal = TRUE;
-            sep = 256;
-            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
-                continue;
-            if (p[i] == '8' || p[i] == '9')
-                goto no_prefix;
-            p += 1;
-            radix = 8;
-        } else {
-            goto no_prefix;
-        }
-        /* there must be a digit after the prefix */
-        if (to_digit((uint8_t)*p) >= radix)
-            goto fail;
-    no_prefix: ;
-    } else {
- no_radix_prefix:
-        if (!(flags & ATOD_INT_ONLY) &&
-            (atod_type == ATOD_TYPE_FLOAT64
-#ifdef CONFIG_BIGNUM
-             || atod_type == ATOD_TYPE_BIG_FLOAT
-#endif             
-             ) &&
-            strstart(p, "Infinity", &p)) {
-#ifdef CONFIG_BIGNUM
-            if (atod_type == ATOD_TYPE_BIG_FLOAT) {
-                bf_t *a;
-                val = JS_NewBigFloat(ctx);
-                if (JS_IsException(val))
-                    goto done;
-                a = JS_GetBigFloat(val);
-                bf_set_inf(a, is_neg);
-            } else
-#endif
-            {
-                double d = 1.0 / 0.0;
-                if (is_neg)
-                    d = -d;
-                val = JS_NewFloat64(ctx, d);
-            }
-            goto done;
-        }
-    }
-    if (radix == 0)
-        radix = 10;
-    is_float = FALSE;
-    p_start = p;
-    while (to_digit((uint8_t)*p) < radix
-           ||  (*p == sep && (radix != 10 ||
-                              p != p_start + 1 || p[-1] != '0') &&
-                to_digit((uint8_t)p[1]) < radix)) {
-        p++;
-    }
-    if (!(flags & ATOD_INT_ONLY)) {
-        if (*p == '.' && (p > p_start || to_digit((uint8_t)p[1]) < radix)) {
-            is_float = TRUE;
-            p++;
-            if (*p == sep)
-                goto fail;
-            while (to_digit((uint8_t)*p) < radix ||
-                   (*p == sep && to_digit((uint8_t)p[1]) < radix))
-                p++;
-        }
-        if (p > p_start &&
-            (((*p == 'e' || *p == 'E') && radix == 10) ||
-             ((*p == 'p' || *p == 'P') && (radix == 2 || radix == 8 || radix == 16)))) {
-            const char *p1 = p + 1;
-            is_float = TRUE;
-            if (*p1 == '+') {
-                p1++;
-            } else if (*p1 == '-') {
-                p1++;
-            }
-            if (is_digit((uint8_t)*p1)) {
-                p = p1 + 1;
-                while (is_digit((uint8_t)*p) || (*p == sep && is_digit((uint8_t)p[1])))
-                    p++;
-            }
-        }
-    }
-    if (p == p_start)
-        goto fail;
+    int i;
+    js_limb_t v, carry;
 
-    buf = buf1;
-    buf_allocated = FALSE;
-    len = p - p_start;
-    if (unlikely((len + 2) > sizeof(buf1))) {
-        buf = js_malloc_rt(ctx->rt, len + 2); /* no exception raised */
-        if (!buf)
-            goto mem_error;
-        buf_allocated = TRUE;
+    carry = 1;
+    for(i=0;i<n;i++) {
+        v = ~op2[i] + carry;
+        carry = v < carry;
+        res[i] = v;
     }
-    /* remove the separators and the radix prefixes */
-    j = 0;
-    if (is_neg)
-        buf[j++] = '-';
-    for (i = 0; i < len; i++) {
-        if (p_start[i] != '_')
-            buf[j++] = p_start[i];
+    return carry;
+}
+
+/* tabr[] = taba[] * b + l. Return the high carry */
+static js_limb_t mp_mul1(js_limb_t *tabr, const js_limb_t *taba, js_limb_t n,
+                      js_limb_t b, js_limb_t l)
+{
+    js_limb_t i;
+    js_dlimb_t t;
+
+    for(i = 0; i < n; i++) {
+        t = (js_dlimb_t)taba[i] * (js_dlimb_t)b + l;
+        tabr[i] = t;
+        l = t >> JS_LIMB_BITS;
     }
-    buf[j] = '\0';
+    return l;
+}
 
-    if (flags & ATOD_ACCEPT_SUFFIX) {
-        if (*p == 'n') {
-            p++;
-            atod_type = ATOD_TYPE_BIG_INT;
-        } else
-#ifdef CONFIG_BIGNUM
-        if (*p == 'l') {
-            p++;
-            atod_type = ATOD_TYPE_BIG_FLOAT;
-        } else if (*p == 'm') {
-            p++;
-            atod_type = ATOD_TYPE_BIG_DECIMAL;
-        } else if (flags & ATOD_MODE_BIGINT) {
-            if (!is_float)
-                atod_type = ATOD_TYPE_BIG_INT;
-            if (has_legacy_octal)
-                goto fail;
-        } else
-#endif
-        {
-            if (is_float && radix != 10)
-                goto fail;
-        }
-    } else {
-        if (atod_type == ATOD_TYPE_FLOAT64) {
-#ifdef CONFIG_BIGNUM
-            if (flags & ATOD_MODE_BIGINT) {
-                if (!is_float)
-                    atod_type = ATOD_TYPE_BIG_INT;
-                if (has_legacy_octal)
-                    goto fail;
-            } else
-#endif                
-            {
-                if (is_float && radix != 10)
-                    goto fail;
-            }
-        }
+static js_limb_t mp_div1(js_limb_t *tabr, const js_limb_t *taba, js_limb_t n,
+                      js_limb_t b, js_limb_t r)
+{
+    js_slimb_t i;
+    js_dlimb_t a1;
+    for(i = n - 1; i >= 0; i--) {
+        a1 = ((js_dlimb_t)r << JS_LIMB_BITS) | taba[i];
+        tabr[i] = a1 / b;
+        r = a1 % b;
     }
+    return r;
+}
 
-    switch(atod_type) {
-    case ATOD_TYPE_FLOAT64:
-        {
-            double d;
-            d = js_strtod(buf, radix, is_float);
-            /* return int or float64 */
-            val = JS_NewFloat64(ctx, d);
-        }
-        break;
-    case ATOD_TYPE_BIG_INT:
-        if (has_legacy_octal || is_float)
-            goto fail;
-        val = ctx->rt->bigint_ops.from_string(ctx, buf, radix, flags, NULL);
-        break;
-#ifdef CONFIG_BIGNUM
-    case ATOD_TYPE_BIG_FLOAT:
-        if (has_legacy_octal)
-            goto fail;
-        val = ctx->rt->bigfloat_ops.from_string(ctx, buf, radix, flags,
-                                                pexponent);
-        break;
-    case ATOD_TYPE_BIG_DECIMAL:
-        if (radix != 10)
-            goto fail;
-        val = ctx->rt->bigdecimal_ops.from_string(ctx, buf, radix, flags, NULL);
-        break;
-#endif        
-    default:
-        abort();
+/* tabr[] += taba[] * b, return the high word. */
+static js_limb_t mp_add_mul1(js_limb_t *tabr, const js_limb_t *taba, js_limb_t n,
+                          js_limb_t b)
+{
+    js_limb_t i, l;
+    js_dlimb_t t;
+
+    l = 0;
+    for(i = 0; i < n; i++) {
+        t = (js_dlimb_t)taba[i] * (js_dlimb_t)b + l + tabr[i];
+        tabr[i] = t;
+        l = t >> JS_LIMB_BITS;
     }
+    return l;
+}
+
+/* size of the result : op1_size + op2_size. */
+static void mp_mul_basecase(js_limb_t *result,
+                            const js_limb_t *op1, js_limb_t op1_size,
+                            const js_limb_t *op2, js_limb_t op2_size)
+{
+    int i;
+    js_limb_t r;
     
-done:
-    if (buf_allocated)
-        js_free_rt(ctx->rt, buf);
-    if (pp)
-        *pp = p;
-    return val;
- fail:
-    val = JS_NAN;
-    goto done;
- mem_error:
-    val = JS_ThrowOutOfMemory(ctx);
-    goto done;
+    result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
+    for(i=1;i<op2_size;i++) {
+        r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
+        result[i + op1_size] = r;
+    }
 }
 
-#ifdef CONFIG_BIGNUM
-static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
-                       int radix, int flags)
+/* tabr[] -= taba[] * b. Return the value to substract to the high
+   word. */
+static js_limb_t mp_sub_mul1(js_limb_t *tabr, const js_limb_t *taba, js_limb_t n,
+                          js_limb_t b)
 {
-    return js_atof2(ctx, str, pp, radix, flags, NULL);
+    js_limb_t i, l;
+    js_dlimb_t t;
+
+    l = 0;
+    for(i = 0; i < n; i++) {
+        t = tabr[i] - (js_dlimb_t)taba[i] * (js_dlimb_t)b - l;
+        tabr[i] = t;
+        l = -(t >> JS_LIMB_BITS);
+    }
+    return l;
+}
+
+/* WARNING: d must be >= 2^(JS_LIMB_BITS-1) */
+static inline js_limb_t udiv1norm_init(js_limb_t d)
+{
+    js_limb_t a0, a1;
+    a1 = -d - 1;
+    a0 = -1;
+    return (((js_dlimb_t)a1 << JS_LIMB_BITS) | a0) / d;
+}
+
+/* return the quotient and the remainder in '*pr'of 'a1*2^JS_LIMB_BITS+a0
+   / d' with 0 <= a1 < d. */
+static inline js_limb_t udiv1norm(js_limb_t *pr, js_limb_t a1, js_limb_t a0,
+                                js_limb_t d, js_limb_t d_inv)
+{
+    js_limb_t n1m, n_adj, q, r, ah;
+    js_dlimb_t a;
+    n1m = ((js_slimb_t)a0 >> (JS_LIMB_BITS - 1));
+    n_adj = a0 + (n1m & d);
+    a = (js_dlimb_t)d_inv * (a1 - n1m) + n_adj;
+    q = (a >> JS_LIMB_BITS) + a1;
+    /* compute a - q * r and update q so that the remainder is\
+       between 0 and d - 1 */
+    a = ((js_dlimb_t)a1 << JS_LIMB_BITS) | a0;
+    a = a - (js_dlimb_t)q * d - d;
+    ah = a >> JS_LIMB_BITS;
+    q += 1 + ah;
+    r = (js_limb_t)a + (ah & d);
+    *pr = r;
+    return q;
 }
-#endif
 
-typedef enum JSToNumberHintEnum {
-    TON_FLAG_NUMBER,
-    TON_FLAG_NUMERIC,
-} JSToNumberHintEnum;
+#define UDIV1NORM_THRESHOLD 3
 
-static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
-                                   JSToNumberHintEnum flag)
+/* b must be >= 1 << (JS_LIMB_BITS - 1) */
+static js_limb_t mp_div1norm(js_limb_t *tabr, const js_limb_t *taba, js_limb_t n,
+                          js_limb_t b, js_limb_t r)
 {
-    uint32_t tag;
-    JSValue ret;
+    js_slimb_t i;
 
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_BIG_INT:
-        if (flag != TON_FLAG_NUMERIC) {
-            JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
+    if (n >= UDIV1NORM_THRESHOLD) {
+        js_limb_t b_inv;
+        b_inv = udiv1norm_init(b);
+        for(i = n - 1; i >= 0; i--) {
+            tabr[i] = udiv1norm(&r, r, taba[i], b, b_inv);
         }
-        ret = val;
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_DECIMAL:
-        if (flag != TON_FLAG_NUMERIC) {
-            JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert bigdecimal to number");
+    } else {
+        js_dlimb_t a1;
+        for(i = n - 1; i >= 0; i--) {
+            a1 = ((js_dlimb_t)r << JS_LIMB_BITS) | taba[i];
+            tabr[i] = a1 / b;
+            r = a1 % b;
         }
-        ret = val;
-        break;
-    case JS_TAG_BIG_FLOAT:
-        if (flag != TON_FLAG_NUMERIC) {
-            JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert bigfloat to number");
+    }
+    return r;
+}
+
+/* base case division: divides taba[0..na-1] by tabb[0..nb-1]. tabb[nb
+   - 1] must be >= 1 << (JS_LIMB_BITS - 1). na - nb must be >= 0. 'taba'
+   is modified and contains the remainder (nb limbs). tabq[0..na-nb]
+   contains the quotient with tabq[na - nb] <= 1. */
+static void mp_divnorm(js_limb_t *tabq, js_limb_t *taba, js_limb_t na,
+                       const js_limb_t *tabb, js_limb_t nb)
+{
+    js_limb_t r, a, c, q, v, b1, b1_inv, n, dummy_r;
+    int i, j;
+
+    b1 = tabb[nb - 1];
+    if (nb == 1) {
+        taba[0] = mp_div1norm(tabq, taba, na, b1, 0);
+        return;
+    }
+    n = na - nb;
+
+    if (n >= UDIV1NORM_THRESHOLD)
+        b1_inv = udiv1norm_init(b1);
+    else
+        b1_inv = 0;
+
+    /* first iteration: the quotient is only 0 or 1 */
+    q = 1;
+    for(j = nb - 1; j >= 0; j--) {
+        if (taba[n + j] != tabb[j]) {
+            if (taba[n + j] < tabb[j])
+                q = 0;
+            break;
         }
-        ret = val;
-        break;
-#endif
-    case JS_TAG_FLOAT64:
-    case JS_TAG_INT:
-    case JS_TAG_EXCEPTION:
-        ret = val;
-        break;
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-        ret = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
-        break;
-    case JS_TAG_UNDEFINED:
-        ret = JS_NAN;
-        break;
-    case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
-        if (JS_IsException(val))
-            return JS_EXCEPTION;
-        goto redo;
-    case JS_TAG_STRING:
-        {
-            const char *str;
-            const char *p;
-            size_t len;
-            
-            str = JS_ToCStringLen(ctx, &len, val);
-            JS_FreeValue(ctx, val);
-            if (!str)
-                return JS_EXCEPTION;
-            p = str;
-            p += skip_spaces(p);
-            if ((p - str) == len) {
-                ret = JS_NewInt32(ctx, 0);
-            } else {
-                int flags = ATOD_ACCEPT_BIN_OCT;
-                ret = js_atof(ctx, p, &p, 0, flags);
-                if (!JS_IsException(ret)) {
-                    p += skip_spaces(p);
-                    if ((p - str) != len) {
-                        JS_FreeValue(ctx, ret);
-                        ret = JS_NAN;
+    }
+    tabq[n] = q;
+    if (q) {
+        mp_sub(taba + n, taba + n, tabb, nb, 0);
+    }
+
+    for(i = n - 1; i >= 0; i--) {
+        if (unlikely(taba[i + nb] >= b1)) {
+            q = -1;
+        } else if (b1_inv) {
+            q = udiv1norm(&dummy_r, taba[i + nb], taba[i + nb - 1], b1, b1_inv);
+        } else {
+            js_dlimb_t al;
+            al = ((js_dlimb_t)taba[i + nb] << JS_LIMB_BITS) | taba[i + nb - 1];
+            q = al / b1;
+            r = al % b1;
+        }
+        r = mp_sub_mul1(taba + i, tabb, nb, q);
+
+        v = taba[i + nb];
+        a = v - r;
+        c = (a > v);
+        taba[i + nb] = a;
+
+        if (c != 0) {
+            /* negative result */
+            for(;;) {
+                q--;
+                c = mp_add(taba + i, taba + i, tabb, nb, 0);
+                /* propagate carry and test if positive result */
+                if (c != 0) {
+                    if (++taba[i + nb] == 0) {
+                        break;
                     }
                 }
             }
-            JS_FreeCString(ctx, str);
         }
-        break;
-    case JS_TAG_SYMBOL:
-        JS_FreeValue(ctx, val);
-        return JS_ThrowTypeError(ctx, "cannot convert symbol to number");
-    default:
-        JS_FreeValue(ctx, val);
-        ret = JS_NAN;
-        break;
+        tabq[i] = q;
     }
-    return ret;
 }
 
-static JSValue JS_ToNumberFree(JSContext *ctx, JSValue val)
+/* 1 <= shift <= JS_LIMB_BITS - 1 */
+static js_limb_t mp_shl(js_limb_t *tabr, const js_limb_t *taba, int n,
+                        int shift)
 {
-    return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMBER);
+    int i;
+    js_limb_t l, v;
+    l = 0;
+    for(i = 0; i < n; i++) {
+        v = taba[i];
+        tabr[i] = (v << shift) | l;
+        l = v >> (JS_LIMB_BITS - shift);
+    }
+    return l;
 }
 
-static JSValue JS_ToNumericFree(JSContext *ctx, JSValue val)
+/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift). 
+   1 <= shift <= LIMB_BITS - 1 */
+static js_limb_t mp_shr(js_limb_t *tab_r, const js_limb_t *tab, int n,
+                        int shift, js_limb_t high)
 {
-    return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMERIC);
+    int i;
+    js_limb_t l, a;
+
+    l = high;
+    for(i = n - 1; i >= 0; i--) {
+        a = tab[i];
+        tab_r[i] = (a >> shift) | (l << (JS_LIMB_BITS - shift));
+        l = a;
+    }
+    return l & (((js_limb_t)1 << shift) - 1);
 }
 
-static JSValue JS_ToNumeric(JSContext *ctx, JSValueConst val)
+static JSBigInt *js_bigint_new(JSContext *ctx, int len)
 {
-    return JS_ToNumericFree(ctx, JS_DupValue(ctx, val));
+    JSBigInt *r;
+    if (len > JS_BIGINT_MAX_SIZE) {
+        JS_ThrowRangeError(ctx, "BigInt is too large to allocate");
+        return NULL;
+    }
+    r = js_malloc(ctx, sizeof(JSBigInt) + len * sizeof(js_limb_t));
+    if (!r)
+        return NULL;
+    r->header.ref_count = 1;
+    r->len = len;
+    return r;
 }
 
-static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
-                                          JSValue val)
+static JSBigInt *js_bigint_set_si(JSBigIntBuf *buf, js_slimb_t a)
 {
-    double d;
-    uint32_t tag;
+    JSBigInt *r = (JSBigInt *)buf->big_int_buf;
+    r->header.ref_count = 0; /* fail safe */
+    r->len = 1;
+    r->tab[0] = a;
+    return r;
+}
 
-    val = JS_ToNumberFree(ctx, val);
-    if (JS_IsException(val)) {
-        *pres = JS_FLOAT64_NAN;
-        return -1;
+static JSBigInt *js_bigint_set_si64(JSBigIntBuf *buf, int64_t a)
+{
+#if JS_LIMB_BITS == 64
+    return js_bigint_set_si(buf, a);
+#else
+    JSBigInt *r = (JSBigInt *)buf->big_int_buf;
+    r->header.ref_count = 0; /* fail safe */
+    if (a >= INT32_MIN && a <= INT32_MAX) {
+        r->len = 1;
+        r->tab[0] = a;
+    } else {
+        r->len = 2;
+        r->tab[0] = a;
+        r->tab[1] = a >> JS_LIMB_BITS;
     }
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-        d = JS_VALUE_GET_INT(val);
-        break;
-    case JS_TAG_FLOAT64:
-        d = JS_VALUE_GET_FLOAT64(val);
-        break;
-    case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
+    return r;
+#endif
+}
+
+/* val must be a short big int */
+static JSBigInt *js_bigint_set_short(JSBigIntBuf *buf, JSValueConst val)
+{
+    return js_bigint_set_si(buf, JS_VALUE_GET_SHORT_BIG_INT(val));
+}
+
+static __maybe_unused void js_bigint_dump1(JSContext *ctx, const char *str,
+                                           const js_limb_t *tab, int len)
+{
+    int i;
+    printf("%s: ", str);
+    for(i = len - 1; i >= 0; i--) {
+#if JS_LIMB_BITS == 32
+        printf(" %08x", tab[i]);
+#else
+        printf(" %016" PRIx64, tab[i]);
 #endif
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            /* XXX: there can be a double rounding issue with some
-               primitives (such as JS_ToUint8ClampFree()), but it is
-               not critical to fix it. */
-            bf_get_float64(&p->num, &d, BF_RNDN);
-            JS_FreeValue(ctx, val);
-        }
-        break;
-    default:
-        abort();
     }
-    *pres = d;
-    return 0;
+    printf("\n");
 }
 
-static inline int JS_ToFloat64Free(JSContext *ctx, double *pres, JSValue val)
+static __maybe_unused void js_bigint_dump(JSContext *ctx, const char *str,
+                                          const JSBigInt *p)
 {
-    uint32_t tag;
+    js_bigint_dump1(ctx, str, p->tab, p->len);
+}
 
-    tag = JS_VALUE_GET_TAG(val);
-    if (tag <= JS_TAG_NULL) {
-        *pres = JS_VALUE_GET_INT(val);
-        return 0;
-    } else if (JS_TAG_IS_FLOAT64(tag)) {
-        *pres = JS_VALUE_GET_FLOAT64(val);
-        return 0;
+static JSBigInt *js_bigint_new_si(JSContext *ctx, js_slimb_t a)
+{
+    JSBigInt *r;
+    r = js_bigint_new(ctx, 1);
+    if (!r)
+        return NULL;
+    r->tab[0] = a;
+    return r;
+}
+
+static JSBigInt *js_bigint_new_si64(JSContext *ctx, int64_t a)
+{
+#if JS_LIMB_BITS == 64
+    return js_bigint_new_si(ctx, a);
+#else
+    if (a >= INT32_MIN && a <= INT32_MAX) {
+        return js_bigint_new_si(ctx, a);
     } else {
-        return __JS_ToFloat64Free(ctx, pres, val);
+        JSBigInt *r;
+        r = js_bigint_new(ctx, 2);
+        if (!r)
+            return NULL;
+        r->tab[0] = a;
+        r->tab[1] = a >> 32;
+        return r;
     }
+#endif
 }
 
-int JS_ToFloat64(JSContext *ctx, double *pres, JSValueConst val)
+static JSBigInt *js_bigint_new_ui64(JSContext *ctx, uint64_t a)
 {
-    return JS_ToFloat64Free(ctx, pres, JS_DupValue(ctx, val));
+    if (a <= INT64_MAX) {
+        return js_bigint_new_si64(ctx, a);
+    } else {
+        JSBigInt *r;
+        r = js_bigint_new(ctx, (65 + JS_LIMB_BITS - 1) / JS_LIMB_BITS);
+        if (!r)
+            return NULL;
+#if JS_LIMB_BITS == 64
+        r->tab[0] = a;
+        r->tab[1] = 0;
+#else
+        r->tab[0] = a;
+        r->tab[1] = a >> 32;
+        r->tab[2] = 0;
+#endif
+        return r;
+    }
 }
 
-static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val)
+static JSBigInt *js_bigint_new_di(JSContext *ctx, js_sdlimb_t a)
 {
-    return JS_ToNumberFree(ctx, JS_DupValue(ctx, val));
+    JSBigInt *r;
+    if (a == (js_slimb_t)a) {
+        r = js_bigint_new(ctx, 1);
+        if (!r)
+            return NULL;
+        r->tab[0] = a;
+    } else {
+        r = js_bigint_new(ctx, 2);
+        if (!r)
+            return NULL;
+        r->tab[0] = a;
+        r->tab[1] = a >> JS_LIMB_BITS;
+    }
+    return r;
 }
 
-/* same as JS_ToNumber() but return 0 in case of NaN/Undefined */
-static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
+/* Remove redundant high order limbs. Warning: 'a' may be
+   reallocated. Can never fail.
+*/
+static JSBigInt *js_bigint_normalize1(JSContext *ctx, JSBigInt *a, int l)
 {
-    uint32_t tag;
-    JSValue ret;
-
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        ret = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
-        break;
-    case JS_TAG_FLOAT64:
-        {
-            double d = JS_VALUE_GET_FLOAT64(val);
-            if (isnan(d)) {
-                ret = JS_NewInt32(ctx, 0);
-            } else {
-                /* convert -0 to +0 */
-                d = trunc(d) + 0.0;
-                ret = JS_NewFloat64(ctx, d);
-            }
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            bf_t a_s, *a, r_s, *r = &r_s;
-            BOOL is_nan;
+    js_limb_t v;
 
-            a = JS_ToBigFloat(ctx, &a_s, val);
-            if (!a) {
-                JS_FreeValue(ctx, val);
-                return JS_EXCEPTION;
-            }
-            if (!bf_is_finite(a)) {
-                is_nan = bf_is_nan(a);
-                if (is_nan)
-                    ret = JS_NewInt32(ctx, 0);
-                else
-                    ret = JS_DupValue(ctx, val);
-            } else {
-                ret = JS_NewBigInt(ctx);
-                if (!JS_IsException(ret)) {
-                    r = JS_GetBigInt(ret);
-                    bf_set(r, a);
-                    bf_rint(r, BF_RNDZ);
-                    ret = JS_CompactBigInt(ctx, ret);
-                }
-            }
-            if (a == &a_s)
-                bf_delete(a);
-            JS_FreeValue(ctx, val);
+    assert(a->header.ref_count == 1);
+    while (l > 1) {
+        v = a->tab[l - 1];
+        if ((v != 0 && v != -1) ||
+            (v & 1) != (a->tab[l - 2] >> (JS_LIMB_BITS - 1))) {
+            break;
         }
-        break;
-#endif
-    default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val))
-            return val;
-        goto redo;
+        l--;
     }
-    return ret;
+    if (l != a->len) {
+        JSBigInt *a1;
+        /* realloc to reduce the size */
+        a->len = l;
+        a1 = js_realloc(ctx, a, sizeof(JSBigInt) + l * sizeof(js_limb_t));
+        if (a1)
+            a = a1;
+    }
+    return a;
 }
 
-/* Note: the integer value is satured to 32 bits */
-static int JS_ToInt32SatFree(JSContext *ctx, int *pres, JSValue val)
+static JSBigInt *js_bigint_normalize(JSContext *ctx, JSBigInt *a)
 {
-    uint32_t tag;
-    int ret;
+    return js_bigint_normalize1(ctx, a, a->len);
+}
 
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        ret = JS_VALUE_GET_INT(val);
-        break;
-    case JS_TAG_EXCEPTION:
-        *pres = 0;
-        return -1;
-    case JS_TAG_FLOAT64:
-        {
-            double d = JS_VALUE_GET_FLOAT64(val);
-            if (isnan(d)) {
-                ret = 0;
-            } else {
-                if (d < INT32_MIN)
-                    ret = INT32_MIN;
-                else if (d > INT32_MAX)
-                    ret = INT32_MAX;
-                else
-                    ret = (int)d;
-            }
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_get_int32(&ret, &p->num, 0);
-            JS_FreeValue(ctx, val);
-        }
-        break;
-#endif
-    default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val)) {
-            *pres = 0;
-            return -1;
-        }
-        goto redo;
-    }
-    *pres = ret;
-    return 0;
+/* return 0 or 1 depending on the sign */
+static inline int js_bigint_sign(const JSBigInt *a)
+{
+    return a->tab[a->len - 1] >> (JS_LIMB_BITS - 1);
 }
 
-int JS_ToInt32Sat(JSContext *ctx, int *pres, JSValueConst val)
+static js_slimb_t js_bigint_get_si_sat(const JSBigInt *a)
 {
-    return JS_ToInt32SatFree(ctx, pres, JS_DupValue(ctx, val));
+    if (a->len == 1) {
+        return a->tab[0];
+    } else {
+#if JS_LIMB_BITS == 32
+        if (js_bigint_sign(a))
+            return INT32_MIN;
+        else
+            return INT32_MAX;
+#else
+        if (js_bigint_sign(a))
+            return INT64_MIN;
+        else
+            return INT64_MAX;
+#endif
+    }
 }
 
-int JS_ToInt32Clamp(JSContext *ctx, int *pres, JSValueConst val,
-                    int min, int max, int min_offset)
+/* add the op1 limb */
+static JSBigInt *js_bigint_extend(JSContext *ctx, JSBigInt *r,
+                                  js_limb_t op1)
 {
-    int res = JS_ToInt32SatFree(ctx, pres, JS_DupValue(ctx, val));
-    if (res == 0) {
-        if (*pres < min) {
-            *pres += min_offset;
-            if (*pres < min)
-                *pres = min;
-        } else {
-            if (*pres > max)
-                *pres = max;
+    int n2 = r->len;
+    if ((op1 != 0 && op1 != -1) ||
+        (op1 & 1) != r->tab[n2 - 1] >> (JS_LIMB_BITS - 1)) {
+        JSBigInt *r1;
+        r1 = js_realloc(ctx, r,
+                        sizeof(JSBigInt) + (n2 + 1) * sizeof(js_limb_t));
+        if (!r1) {
+            js_free(ctx, r);
+            return NULL;
         }
+        r = r1;
+        r->len = n2 + 1;
+        r->tab[n2] = op1;
+    } else {
+        /* otherwise still need to normalize the result */
+        r = js_bigint_normalize(ctx, r);
     }
-    return res;
+    return r;
 }
 
-static int JS_ToInt64SatFree(JSContext *ctx, int64_t *pres, JSValue val)
+/* return NULL in case of error. Compute a + b (b_neg = 0) or a - b
+   (b_neg = 1) */
+/* XXX: optimize */
+static JSBigInt *js_bigint_add(JSContext *ctx, const JSBigInt *a,
+                               const JSBigInt *b, int b_neg)
 {
-    uint32_t tag;
-
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        *pres = JS_VALUE_GET_INT(val);
-        return 0;
-    case JS_TAG_EXCEPTION:
-        *pres = 0;
-        return -1;
-    case JS_TAG_FLOAT64:
-        {
-            double d = JS_VALUE_GET_FLOAT64(val);
-            if (isnan(d)) {
-                *pres = 0;
-            } else {
-                if (d < INT64_MIN)
-                    *pres = INT64_MIN;
-                else if (d > INT64_MAX)
-                    *pres = INT64_MAX;
-                else
-                    *pres = (int64_t)d;
-            }
-        }
-        return 0;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_get_int64(pres, &p->num, 0);
-            JS_FreeValue(ctx, val);
+    JSBigInt *r;
+    int n1, n2, i;
+    js_limb_t carry, op1, op2, a_sign, b_sign;
+    
+    n2 = max_int(a->len, b->len);
+    n1 = min_int(a->len, b->len);
+    r = js_bigint_new(ctx, n2);
+    if (!r)
+        return NULL;
+    /* XXX: optimize */
+    /* common part */
+    carry = b_neg;
+    for(i = 0; i < n1; i++) {
+        op1 = a->tab[i];
+        op2 = b->tab[i] ^ (-b_neg);
+        ADDC(r->tab[i], carry, op1, op2, carry);
+    }
+    a_sign = -js_bigint_sign(a);
+    b_sign = (-js_bigint_sign(b)) ^ (-b_neg);
+    /* part with sign extension of one operand  */
+    if (a->len > b->len) {
+        for(i = n1; i < n2; i++) {
+            op1 = a->tab[i];
+            ADDC(r->tab[i], carry, op1, b_sign, carry);
         }
-        return 0;
-#endif
-    default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val)) {
-            *pres = 0;
-            return -1;
+    } else if (a->len < b->len) {
+        for(i = n1; i < n2; i++) {
+            op2 = b->tab[i] ^ (-b_neg);
+            ADDC(r->tab[i], carry, a_sign, op2, carry);
         }
-        goto redo;
     }
+
+    /* part with sign extension for both operands. Extend the result
+       if necessary */
+    return js_bigint_extend(ctx, r, a_sign + b_sign + carry);
 }
 
-int JS_ToInt64Sat(JSContext *ctx, int64_t *pres, JSValueConst val)
+/* XXX: optimize */
+static JSBigInt *js_bigint_neg(JSContext *ctx, const JSBigInt *a)
 {
-    return JS_ToInt64SatFree(ctx, pres, JS_DupValue(ctx, val));
+    JSBigIntBuf buf;
+    JSBigInt *b;
+    b = js_bigint_set_si(&buf, 0);
+    return js_bigint_add(ctx, b, a, 1);
 }
 
-int JS_ToInt64Clamp(JSContext *ctx, int64_t *pres, JSValueConst val,
-                    int64_t min, int64_t max, int64_t neg_offset)
+static JSBigInt *js_bigint_mul(JSContext *ctx, const JSBigInt *a,
+                               const JSBigInt *b)
 {
-    int res = JS_ToInt64SatFree(ctx, pres, JS_DupValue(ctx, val));
-    if (res == 0) {
-        if (*pres < 0)
-            *pres += neg_offset;
-        if (*pres < min)
-            *pres = min;
-        else if (*pres > max)
-            *pres = max;
+    JSBigInt *r;
+    
+    r = js_bigint_new(ctx, a->len + b->len);
+    if (!r)
+        return NULL;
+    mp_mul_basecase(r->tab, a->tab, a->len, b->tab, b->len);
+    /* correct the result if negative operands (no overflow is
+       possible) */
+    if (js_bigint_sign(a))
+        mp_sub(r->tab + a->len, r->tab + a->len, b->tab, b->len, 0);
+    if (js_bigint_sign(b))
+        mp_sub(r->tab + b->len, r->tab + b->len, a->tab, a->len, 0);
+    return js_bigint_normalize(ctx, r);
+}
+
+/* return the division or the remainder. 'b' must be != 0. return NULL
+   in case of exception (division by zero or memory error) */
+static JSBigInt *js_bigint_divrem(JSContext *ctx, const JSBigInt *a,
+                                  const JSBigInt *b, BOOL is_rem)
+{
+    JSBigInt *r, *q;
+    js_limb_t *tabb, h;
+    int na, nb, a_sign, b_sign, shift;
+    
+    if (b->len == 1 && b->tab[0] == 0) {
+        JS_ThrowRangeError(ctx, "BigInt division by zero");
+        return NULL;
     }
-    return res;
-}
+    
+    a_sign = js_bigint_sign(a);
+    b_sign = js_bigint_sign(b);
+    na = a->len;
+    nb = b->len;
 
-/* Same as JS_ToInt32Free() but with a 64 bit result. Return (<0, 0)
-   in case of exception */
-static int JS_ToInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
-{
-    uint32_t tag;
-    int64_t ret;
+    r = js_bigint_new(ctx, na + 2); 
+    if (!r)
+        return NULL;
+    if (a_sign) {
+        mp_neg(r->tab, a->tab, na);
+    } else {
+        memcpy(r->tab, a->tab, na * sizeof(a->tab[0]));
+    }
+    /* normalize */
+    while (na > 1 && r->tab[na - 1] == 0)
+        na--;
 
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        ret = JS_VALUE_GET_INT(val);
-        break;
-    case JS_TAG_FLOAT64:
-        {
-            JSFloat64Union u;
-            double d;
-            int e;
-            d = JS_VALUE_GET_FLOAT64(val);
-            u.d = d;
-            /* we avoid doing fmod(x, 2^64) */
-            e = (u.u64 >> 52) & 0x7ff;
-            if (likely(e <= (1023 + 62))) {
-                /* fast case */
-                ret = (int64_t)d;
-            } else if (e <= (1023 + 62 + 53)) {
-                uint64_t v;
-                /* remainder modulo 2^64 */
-                v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
-                ret = v << ((e - 1023) - 52);
-                /* take the sign into account */
-                if (u.u64 >> 63)
-                    ret = -ret;
-            } else {
-                ret = 0; /* also handles NaN and +inf */
-            }
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_get_int64(&ret, &p->num, BF_GET_INT_MOD);
-            JS_FreeValue(ctx, val);
-        }
-        break;
-#endif
-    default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val)) {
-            *pres = 0;
-            return -1;
+    tabb = js_malloc(ctx, nb * sizeof(tabb[0]));
+    if (!tabb) {
+        js_free(ctx, r);
+        return NULL;
+    }
+    if (b_sign) {
+        mp_neg(tabb, b->tab, nb);
+    } else {
+        memcpy(tabb, b->tab, nb * sizeof(tabb[0]));
+    }
+    /* normalize */
+    while (nb > 1 && tabb[nb - 1] == 0)
+        nb--;
+
+    /* trivial case if 'a' is small */
+    if (na < nb) {
+        js_free(ctx, r);
+        js_free(ctx, tabb);
+        if (is_rem) {
+            /* r = a */
+            r = js_bigint_new(ctx, a->len);
+            if (!r)
+                return NULL;
+            memcpy(r->tab, a->tab, a->len * sizeof(a->tab[0])); 
+            return r;
+        } else {
+            /* q = 0 */
+            return js_bigint_new_si(ctx, 0);
         }
-        goto redo;
     }
-    *pres = ret;
-    return 0;
-}
 
-int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
-{
-    return JS_ToInt64Free(ctx, pres, JS_DupValue(ctx, val));
-}
+    /* normalize 'b' */
+    shift = js_limb_clz(tabb[nb - 1]);
+    if (shift != 0) {
+        mp_shl(tabb, tabb, nb, shift);
+        h = mp_shl(r->tab, r->tab, na, shift);
+        if (h != 0)
+            r->tab[na++] = h;
+    }
 
-int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val)
-{
-    if (JS_IsBigInt(ctx, val))
-        return JS_ToBigInt64(ctx, pres, val);
-    else
-        return JS_ToInt64(ctx, pres, val);
+    q = js_bigint_new(ctx, na - nb + 2); /* one more limb for the sign */
+    if (!q) {
+        js_free(ctx, r);
+        js_free(ctx, tabb);
+        return NULL;
+    }
+
+    //    js_bigint_dump1(ctx, "a", r->tab, na);
+    //    js_bigint_dump1(ctx, "b", tabb, nb);
+    mp_divnorm(q->tab, r->tab, na, tabb, nb);
+    js_free(ctx, tabb);
+
+    if (is_rem) {
+        js_free(ctx, q);
+        if (shift != 0)
+            mp_shr(r->tab, r->tab, nb, shift, 0);
+        r->tab[nb++] = 0;
+        if (a_sign)
+            mp_neg(r->tab, r->tab, nb);
+        r = js_bigint_normalize1(ctx, r, nb);
+        return r;
+    } else {
+        js_free(ctx, r);
+        q->tab[na - nb + 1] = 0;
+        if (a_sign ^ b_sign) {
+            mp_neg(q->tab, q->tab, q->len);
+        }
+        q = js_bigint_normalize(ctx, q);
+        return q;
+    }
 }
 
-/* return (<0, 0) in case of exception */
-static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
+/* and, or, xor */
+static JSBigInt *js_bigint_logic(JSContext *ctx, const JSBigInt *a,
+                                 const JSBigInt *b, OPCodeEnum op)
 {
-    uint32_t tag;
-    int32_t ret;
+    JSBigInt *r;
+    js_limb_t b_sign;
+    int a_len, b_len, i;
 
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        ret = JS_VALUE_GET_INT(val);
+    if (a->len < b->len) {
+        const JSBigInt *tmp;
+        tmp = a;
+        a = b;
+        b = tmp;
+    }
+    /* a_len >= b_len */
+    a_len = a->len;
+    b_len = b->len;
+    b_sign = -js_bigint_sign(b);
+
+    r = js_bigint_new(ctx, a_len);
+    if (!r)
+        return NULL;
+    switch(op) {
+    case OP_or:
+        for(i = 0; i < b_len; i++) {
+            r->tab[i] = a->tab[i] | b->tab[i];
+        }
+        for(i = b_len; i < a_len; i++) {
+            r->tab[i] = a->tab[i] | b_sign;
+        }
         break;
-    case JS_TAG_FLOAT64:
-        {
-            JSFloat64Union u;
-            double d;
-            int e;
-            d = JS_VALUE_GET_FLOAT64(val);
-            u.d = d;
-            /* we avoid doing fmod(x, 2^32) */
-            e = (u.u64 >> 52) & 0x7ff;
-            if (likely(e <= (1023 + 30))) {
-                /* fast case */
-                ret = (int32_t)d;
-            } else if (e <= (1023 + 30 + 53)) {
-                uint64_t v;
-                /* remainder modulo 2^32 */
-                v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
-                v = v << ((e - 1023) - 52 + 32);
-                ret = v >> 32;
-                /* take the sign into account */
-                if (u.u64 >> 63)
-                    ret = -ret;
-            } else {
-                ret = 0; /* also handles NaN and +inf */
-            }
+    case OP_and:
+        for(i = 0; i < b_len; i++) {
+            r->tab[i] = a->tab[i] & b->tab[i];
+        }
+        for(i = b_len; i < a_len; i++) {
+            r->tab[i] = a->tab[i] & b_sign;
         }
         break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_get_int32(&ret, &p->num, BF_GET_INT_MOD);
-            JS_FreeValue(ctx, val);
+    case OP_xor:
+        for(i = 0; i < b_len; i++) {
+            r->tab[i] = a->tab[i] ^ b->tab[i];
+        }
+        for(i = b_len; i < a_len; i++) {
+            r->tab[i] = a->tab[i] ^ b_sign;
         }
         break;
-#endif
     default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val)) {
-            *pres = 0;
-            return -1;
-        }
-        goto redo;
+        abort();
     }
-    *pres = ret;
-    return 0;
+    return js_bigint_normalize(ctx, r);
 }
 
-int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val)
+static JSBigInt *js_bigint_not(JSContext *ctx, const JSBigInt *a)
 {
-    return JS_ToInt32Free(ctx, pres, JS_DupValue(ctx, val));
+    JSBigInt *r;
+    int i;
+    
+    r = js_bigint_new(ctx, a->len);
+    if (!r)
+        return NULL;
+    for(i = 0; i < a->len; i++) {
+        r->tab[i] = ~a->tab[i];
+    }
+    /* no normalization is needed */
+    return r;
 }
 
-static inline int JS_ToUint32Free(JSContext *ctx, uint32_t *pres, JSValue val)
+static JSBigInt *js_bigint_shl(JSContext *ctx, const JSBigInt *a,
+                               unsigned int shift1)
 {
-    return JS_ToInt32Free(ctx, (int32_t *)pres, val);
+    int d, i, shift;
+    JSBigInt *r;
+    js_limb_t l;
+
+    if (a->len == 1 && a->tab[0] == 0)
+        return js_bigint_new_si(ctx, 0); /* zero case */
+    d = shift1 / JS_LIMB_BITS;
+    shift = shift1 % JS_LIMB_BITS;
+    r = js_bigint_new(ctx, a->len + d);
+    if (!r)
+        return NULL;
+    for(i = 0; i < d; i++)
+        r->tab[i] = 0;
+    if (shift == 0) {
+        for(i = 0; i < a->len; i++) {
+            r->tab[i + d] = a->tab[i];
+        }
+    } else {
+        l = mp_shl(r->tab + d, a->tab, a->len, shift);
+        if (js_bigint_sign(a))
+            l |= (js_limb_t)(-1) << shift;
+        r = js_bigint_extend(ctx, r, l);
+    }
+    return r;
 }
 
-static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
+static JSBigInt *js_bigint_shr(JSContext *ctx, const JSBigInt *a,
+                               unsigned int shift1)
 {
-    uint32_t tag;
-    int res;
+    int d, i, shift, a_sign, n1;
+    JSBigInt *r;
 
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-        res = JS_VALUE_GET_INT(val);
-#ifdef CONFIG_BIGNUM
-    int_clamp:
-#endif
-        res = max_int(0, min_int(255, res));
-        break;
-    case JS_TAG_FLOAT64:
-        {
-            double d = JS_VALUE_GET_FLOAT64(val);
-            if (isnan(d)) {
-                res = 0;
-            } else {
-                if (d < 0)
-                    res = 0;
-                else if (d > 255)
-                    res = 255;
-                else
-                    res = lrint(d);
-            }
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_t r_s, *r = &r_s;
-            bf_init(ctx->bf_ctx, r);
-            bf_set(r, &p->num);
-            bf_rint(r, BF_RNDN);
-            bf_get_int32(&res, r, 0);
-            bf_delete(r);
-            JS_FreeValue(ctx, val);
-        }
-        goto int_clamp;
-#endif
-    default:
-        val = JS_ToNumberFree(ctx, val);
-        if (JS_IsException(val)) {
-            *pres = 0;
-            return -1;
+    d = shift1 / JS_LIMB_BITS;
+    shift = shift1 % JS_LIMB_BITS;
+    a_sign = js_bigint_sign(a);
+    if (d >= a->len)
+        return js_bigint_new_si(ctx, -a_sign);
+    n1 = a->len - d;
+    r = js_bigint_new(ctx, n1);
+    if (!r)
+        return NULL;
+    if (shift == 0) {
+        for(i = 0; i < n1; i++) {
+            r->tab[i] = a->tab[i + d];
         }
-        goto redo;
+        /* no normalization is needed */
+    } else {
+        mp_shr(r->tab, a->tab + d, n1, shift, -a_sign);
+        r = js_bigint_normalize(ctx, r);
     }
-    *pres = res;
-    return 0;
+    return r;
 }
 
-static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
-                                            JSValue val, BOOL is_array_ctor)
+static JSBigInt *js_bigint_pow(JSContext *ctx, const JSBigInt *a, JSBigInt *b)
 {
-    uint32_t tag, len;
-
-    tag = JS_VALUE_GET_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-    case JS_TAG_NULL:
-        {
-            int v;
-            v = JS_VALUE_GET_INT(val);
-            if (v < 0)
-                goto fail;
-            len = v;
-        }
-        break;
-    case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif        
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            bf_t a;
-            BOOL res;
-            bf_get_int32((int32_t *)&len, &p->num, BF_GET_INT_MOD);
-            bf_init(ctx->bf_ctx, &a);
-            bf_set_ui(&a, len);
-            res = bf_cmp_eq(&a, &p->num);
-            bf_delete(&a);
-            JS_FreeValue(ctx, val);
-            if (!res)
-                goto fail;
+    uint32_t e;
+    int n_bits, i;
+    JSBigInt *r, *r1;
+    
+    /* b must be >= 0 */
+    if (js_bigint_sign(b)) {
+        JS_ThrowRangeError(ctx, "BigInt negative exponent");
+        return NULL;
+    }
+    if (b->len == 1 && b->tab[0] == 0) {
+        /* a^0 = 1 */
+        return js_bigint_new_si(ctx, 1);
+    } else if (a->len == 1) {
+        js_limb_t v;
+        BOOL is_neg;
+
+        v = a->tab[0];
+        if (v <= 1)
+            return js_bigint_new_si(ctx, v);
+        else if (v == -1)
+            return js_bigint_new_si(ctx, 1 - 2 * (b->tab[0] & 1));
+        is_neg = (js_slimb_t)v < 0;
+        if (is_neg)
+            v = -v;
+        if ((v & (v - 1)) == 0) {
+            uint64_t e1;
+            int n;
+            /* v = 2^n */
+            n = JS_LIMB_BITS - 1 - js_limb_clz(v);
+            if (b->len > 1)
+                goto overflow;
+            if (b->tab[0] > INT32_MAX)
+                goto overflow;
+            e = b->tab[0];
+            e1 = (uint64_t)e * n;
+            if (e1 > JS_BIGINT_MAX_SIZE * JS_LIMB_BITS)
+                goto overflow;
+            e = e1;
+            if (is_neg)
+                is_neg = b->tab[0] & 1;
+            r = js_bigint_new(ctx,
+                              (e + JS_LIMB_BITS + 1 - is_neg) / JS_LIMB_BITS);
+            if (!r)
+                return NULL;
+            memset(r->tab, 0, sizeof(r->tab[0]) * r->len);
+            r->tab[e / JS_LIMB_BITS] =
+                (js_limb_t)(1 - 2 * is_neg) << (e % JS_LIMB_BITS);
+            return r;
         }
-        break;
-    default:
-        if (JS_TAG_IS_FLOAT64(tag)) {
-            double d;
-            d = JS_VALUE_GET_FLOAT64(val);
-            len = (uint32_t)d;
-            if (len != d)
-                goto fail;
-        } else {
-            uint32_t len1;
+    }
+    if (b->len > 1)
+        goto overflow;
+    if (b->tab[0] > INT32_MAX)
+        goto overflow;
+    e = b->tab[0];
+    n_bits = 32 - clz32(e);
 
-            if (is_array_ctor) {
-                val = JS_ToNumberFree(ctx, val);
-                if (JS_IsException(val))
-                    return -1;
-                /* cannot recurse because val is a number */
-                if (JS_ToArrayLengthFree(ctx, &len, val, TRUE))
-                    return -1;
-            } else {
-                /* legacy behavior: must do the conversion twice and compare */
-                if (JS_ToUint32(ctx, &len, val)) {
-                    JS_FreeValue(ctx, val);
-                    return -1;
-                }
-                val = JS_ToNumberFree(ctx, val);
-                if (JS_IsException(val))
-                    return -1;
-                /* cannot recurse because val is a number */
-                if (JS_ToArrayLengthFree(ctx, &len1, val, FALSE))
-                    return -1;
-                if (len1 != len) {
-                fail:
-                    JS_ThrowRangeError(ctx, "invalid array length");
-                    return -1;
-                }
-            }
+    r = js_bigint_new(ctx, a->len);
+    if (!r)
+        return NULL;
+    memcpy(r->tab, a->tab, a->len * sizeof(a->tab[0]));
+    for(i = n_bits - 2; i >= 0; i--) {
+        r1 = js_bigint_mul(ctx, r, r);
+        if (!r1)
+            return NULL;
+        js_free(ctx, r);
+        r = r1;
+        if ((e >> i) & 1) {
+            r1 = js_bigint_mul(ctx, r, a);
+            if (!r1)
+                return NULL;
+            js_free(ctx, r);
+            r = r1;
         }
-        break;
     }
-    *plen = len;
-    return 0;
+    return r;
+ overflow:
+    JS_ThrowRangeError(ctx, "BigInt is too large");
+    return NULL;
 }
 
-#define MAX_SAFE_INTEGER (((int64_t)1 << 53) - 1)
+/* return (mant, exp) so that abs(a) ~ mant*2^(exp - (limb_bits -
+   1). a must be != 0. */
+static uint64_t js_bigint_get_mant_exp(JSContext *ctx,
+                                       int *pexp, const JSBigInt *a)
+{
+    js_limb_t t[4 - JS_LIMB_BITS / 32], carry, v, low_bits;
+    int n1, n2, sgn, shift, i, j, e;
+    uint64_t a1, a0;
+
+    n2 = 4 - JS_LIMB_BITS / 32;
+    n1 = a->len - n2;
+    sgn = js_bigint_sign(a);
+
+    /* low_bits != 0 if there are a non zero low bit in abs(a) */
+    low_bits = 0;
+    carry = sgn;
+    for(i = 0; i < n1; i++) {
+        v = (a->tab[i] ^ (-sgn)) + carry;
+        carry = v < carry;
+        low_bits |= v;
+    }
+    /* get the n2 high limbs of abs(a) */
+    for(j = 0; j < n2; j++) {
+        i = j + n1;
+        if (i < 0) {
+            v = 0;
+        } else {
+            v = (a->tab[i] ^ (-sgn)) + carry;
+            carry = v < carry;
+        }
+        t[j] = v;
+    }
+    
+#if JS_LIMB_BITS == 32
+    a1 = ((uint64_t)t[2] << 32) | t[1];
+    a0 = (uint64_t)t[0] << 32;
+#else
+    a1 = t[1];
+    a0 = t[0];
+#endif
+    a0 |= (low_bits != 0);
+    /* normalize */
+    if (a1 == 0) {
+        /* JS_LIMB_BITS = 64 bit only */
+        shift = 64;
+        a1 = a0;
+        a0 = 0;
+    } else {
+        shift = clz64(a1);
+        if (shift != 0) {
+            a1 = (a1 << shift) | (a0 >> (64 - shift));
+            a0 <<= shift;
+        }
+    }
+    a1 |= (a0 != 0); /* keep the bits for the final rounding */
+    /* compute the exponent */
+    e = a->len * JS_LIMB_BITS - shift - 1;
+    *pexp = e;
+    return a1;
+}
 
-static BOOL is_safe_integer(double d)
+/* shift left with round to nearest, ties to even. n >= 1 */
+static uint64_t shr_rndn(uint64_t a, int n)
 {
-    return isfinite(d) && floor(d) == d &&
-        fabs(d) <= (double)MAX_SAFE_INTEGER;
+    uint64_t addend = ((a >> n) & 1) + ((1 << (n - 1)) - 1);
+    return (a + addend) >> n;
 }
 
-int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val)
+/* convert to float64 with round to nearest, ties to even. Return
+   +/-infinity if too large. */
+static double js_bigint_to_float64(JSContext *ctx, const JSBigInt *a)
 {
-    int64_t v;
-    if (JS_ToInt64Sat(ctx, &v, val))
-        return -1;
-    if (v < 0 || v > MAX_SAFE_INTEGER) {
-        JS_ThrowRangeError(ctx, "invalid array index");
-        *plen = 0;
-        return -1;
+    int sgn, e;
+    uint64_t mant;
+
+    if (a->len == 1) {
+        /* fast case, including zero */
+        return (double)(js_slimb_t)a->tab[0];
     }
-    *plen = v;
-    return 0;
-}
 
-/* convert a value to a length between 0 and MAX_SAFE_INTEGER.
-   return -1 for exception */
-static __exception int JS_ToLengthFree(JSContext *ctx, int64_t *plen,
-                                       JSValue val)
-{
-    int res = JS_ToInt64Clamp(ctx, plen, val, 0, MAX_SAFE_INTEGER, 0);
-    JS_FreeValue(ctx, val);
-    return res;
+    sgn = js_bigint_sign(a);
+    mant = js_bigint_get_mant_exp(ctx, &e, a);
+    if (e > 1023) {
+        /* overflow: return infinity */
+        mant = 0;
+        e = 1024;
+    } else {
+        mant = (mant >> 1) | (mant & 1); /* avoid overflow in rounding */
+        mant = shr_rndn(mant, 10);
+        /* rounding can cause an overflow */
+        if (mant >= ((uint64_t)1 << 53)) {
+            mant >>= 1;
+            e++;
+        }
+        mant &= (((uint64_t)1 << 52) - 1);
+    }
+    return uint64_as_float64(((uint64_t)sgn << 63) |
+                             ((uint64_t)(e + 1023) << 52) |
+                             mant);
 }
 
-/* Note: can return an exception */
-static int JS_NumberIsInteger(JSContext *ctx, JSValueConst val)
+/* return (1, NULL) if not an integer, (2, NULL) if NaN or Infinity,
+   (0, n) if an integer, (0, NULL) in case of memory error */
+static JSBigInt *js_bigint_from_float64(JSContext *ctx, int *pres, double a1)
 {
-    double d;
-    if (!JS_IsNumber(val))
-        return FALSE;
-    if (unlikely(JS_ToFloat64(ctx, &d, val)))
-        return -1;
-    return isfinite(d) && floor(d) == d;
+    uint64_t a = float64_as_uint64(a1);
+    int sgn, e, shift;
+    uint64_t mant;
+    JSBigIntBuf buf;
+    JSBigInt *r;
+    
+    sgn = a >> 63;
+    e = (a >> 52) & ((1 << 11) - 1);
+    mant = a & (((uint64_t)1 << 52) - 1);
+    if (e == 2047) {
+        /* NaN, Infinity */
+        *pres = 2;
+        return NULL;
+    }
+    if (e == 0 && mant == 0) {
+        /* zero */
+        *pres = 0;
+        return js_bigint_new_si(ctx, 0);
+    }
+    e -= 1023;
+    /* 0 < a < 1 : not an integer */
+    if (e < 0)
+        goto not_an_integer;
+    mant |= (uint64_t)1 << 52;
+    if (e < 52) {
+        shift = 52 - e;
+        /* check that there is no fractional part */
+        if (mant & (((uint64_t)1 << shift) - 1)) {
+        not_an_integer:
+            *pres = 1;
+            return NULL;
+        }
+        mant >>= shift;
+        e = 0;
+    } else {
+        e -= 52;
+    }
+    if (sgn)
+        mant = -mant;
+    /* the integer is mant*2^e */
+    r = js_bigint_set_si64(&buf, (int64_t)mant);
+    *pres = 0;
+    return js_bigint_shl(ctx, r, e);
 }
 
-static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
+/* return -1, 0, 1 or (2) (unordered) */
+static int js_bigint_float64_cmp(JSContext *ctx, const JSBigInt *a,
+                                 double b)
 {
-    uint32_t tag;
-
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-        {
-            int v;
-            v = JS_VALUE_GET_INT(val);
-            return (v < 0);
-        }
-    case JS_TAG_FLOAT64:
-        {
-            JSFloat64Union u;
-            u.d = JS_VALUE_GET_FLOAT64(val);
-            return (u.u64 >> 63);
-        }
-    case JS_TAG_BIG_INT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            /* Note: integer zeros are not necessarily positive */
-            return p->num.sign && !bf_is_zero(&p->num);
-        }
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            return p->num.sign;
+    int b_sign, a_sign, e, f;
+    uint64_t mant, b1, a_mant;
+    
+    b1 = float64_as_uint64(b);
+    b_sign = b1 >> 63;
+    e = (b1 >> 52) & ((1 << 11) - 1);
+    mant = b1 & (((uint64_t)1 << 52) - 1);
+    a_sign = js_bigint_sign(a);
+    if (e == 2047) {
+        if (mant != 0) {
+            /* NaN */
+            return 2;
+        } else {
+            /* +/- infinity */
+            return 2 * b_sign - 1;
         }
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        {
-            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
-            return p->num.sign;
+    } else if (e == 0 && mant == 0) {
+        /* b = +/-0 */
+        if (a->len == 1 && a->tab[0] == 0)
+            return 0;
+        else
+            return 1 - 2 * a_sign;
+    } else if (a->len == 1 && a->tab[0] == 0) {
+        /* a = 0, b != 0 */
+        return 2 * b_sign - 1;
+    } else if (a_sign != b_sign) {
+        return 1 - 2 * a_sign;
+    } else {
+        e -= 1023;
+        /* Note: handling denormals is not necessary because we
+           compare to integers hence f >= 0 */
+        /* compute f so that 2^f <= abs(a) < 2^(f+1) */
+        a_mant = js_bigint_get_mant_exp(ctx, &f, a);
+        if (f != e) {
+            if (f < e)
+                return -1;
+            else
+                return 1;
+        } else {
+            mant = (mant | ((uint64_t)1 << 52)) << 11; /* align to a_mant */
+            if (a_mant < mant)
+                return 2 * a_sign - 1;
+            else if (a_mant > mant)
+                return 1 - 2 * a_sign;
+            else
+                return 0;
         }
-        break;
-#endif
-    default:
-        return FALSE;
     }
 }
 
-static JSValue js_bigint_to_string1(JSContext *ctx, JSValueConst val, int radix)
-{
-    JSValue ret;
-    bf_t a_s, *a;
-    char *str;
-    int saved_sign;
-
-    a = JS_ToBigInt(ctx, &a_s, val);
-    if (!a)
-        return JS_EXCEPTION;
-    saved_sign = a->sign;
-    if (a->expn == BF_EXP_ZERO)
-        a->sign = 0;
-    str = bf_ftoa(NULL, a, radix, 0, BF_RNDZ | BF_FTOA_FORMAT_FRAC |
-                  BF_FTOA_JS_QUIRKS);
-    a->sign = saved_sign;
-    JS_FreeBigInt(ctx, a, &a_s);
-    if (!str)
-        return JS_ThrowOutOfMemory(ctx);
-    ret = JS_NewString(ctx, str);
-    bf_free(ctx->bf_ctx, str);
-    return ret;
-}
-
-static JSValue js_bigint_to_string(JSContext *ctx, JSValueConst val)
+/* return -1, 0 or 1 */
+static int js_bigint_cmp(JSContext *ctx, const JSBigInt *a,
+                         const JSBigInt *b)
 {
-    return js_bigint_to_string1(ctx, val, 10);
+    int a_sign, b_sign, res, i;
+    a_sign = js_bigint_sign(a);
+    b_sign = js_bigint_sign(b);
+    if (a_sign != b_sign) {
+        res = 1 - 2 * a_sign;
+    } else {
+        /* we assume the numbers are normalized */
+        if (a->len != b->len) {
+            if (a->len < b->len)
+                res = 2 * a_sign - 1;
+            else
+                res = 1 - 2 * a_sign;
+        } else {
+            res = 0;
+            for(i = a->len -1; i >= 0; i--) {
+                if (a->tab[i] != b->tab[i]) {
+                    if (a->tab[i] < b->tab[i])
+                        res = -1;
+                    else
+                        res = 1;
+                    break;
+                }
+            }
+        }
+    }
+    return res;
 }
 
-#ifdef CONFIG_BIGNUM
+/* contains 10^i */
+static const js_limb_t js_pow_dec[JS_LIMB_DIGITS + 1] = {
+    1U,
+    10U,
+    100U,
+    1000U,
+    10000U,
+    100000U,
+    1000000U,
+    10000000U,
+    100000000U,
+    1000000000U,
+#if JS_LIMB_BITS == 64
+    10000000000U,
+    100000000000U,
+    1000000000000U,
+    10000000000000U,
+    100000000000000U,
+    1000000000000000U,
+    10000000000000000U,
+    100000000000000000U,
+    1000000000000000000U,
+    10000000000000000000U,
+#endif
+};
 
-static JSValue js_ftoa(JSContext *ctx, JSValueConst val1, int radix,
-                       limb_t prec, bf_flags_t flags)
+/* syntax: [-]digits in base radix. Return NULL if memory error. radix
+   = 10, 2, 8 or 16. */
+static JSBigInt *js_bigint_from_string(JSContext *ctx,
+                                       const char *str, int radix)
 {
-    JSValue val, ret;
-    bf_t a_s, *a;
-    char *str;
-    int saved_sign;
-
-    val = JS_ToNumeric(ctx, val1);
-    if (JS_IsException(val))
-        return val;
-    a = JS_ToBigFloat(ctx, &a_s, val);
-    if (!a) {
-        JS_FreeValue(ctx, val);
-        return JS_EXCEPTION;
+    const char *p = str;
+    int is_neg, n_digits, n_limbs, len, log2_radix, n_bits, i;
+    JSBigInt *r;
+    js_limb_t v, c, h;
+    
+    is_neg = 0;
+    if (*p == '-') {
+        is_neg = 1;
+        p++;
     }
-    saved_sign = a->sign;
-    if (a->expn == BF_EXP_ZERO)
-        a->sign = 0;
-    flags |= BF_FTOA_JS_QUIRKS;
-    if ((flags & BF_FTOA_FORMAT_MASK) == BF_FTOA_FORMAT_FREE_MIN) {
-        /* Note: for floating point numbers with a radix which is not
-           a power of two, the current precision is used to compute
-           the number of digits. */
-        if ((radix & (radix - 1)) != 0) {
-            bf_t r_s, *r = &r_s;
-            int prec, flags1;
-            /* must round first */
-            if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
-                prec = ctx->fp_env.prec;
-                flags1 = ctx->fp_env.flags &
-                    (BF_FLAG_SUBNORMAL | (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT));
+    while (*p == '0')
+        p++;
+    n_digits = strlen(p);
+    log2_radix = 32 - clz32(radix - 1); /* ceil(log2(radix)) */
+    /* compute the maximum number of limbs */
+    /* XXX: overflow */
+    if (radix == 10) {
+        n_bits = (n_digits * 27 + 7) / 8; /* >= ceil(n_digits * log2(10)) */
+    } else {
+        n_bits = n_digits * log2_radix;
+    }
+    /* we add one extra bit for the sign */
+    n_limbs = max_int(1, n_bits / JS_LIMB_BITS + 1);
+    r = js_bigint_new(ctx, n_limbs);
+    if (!r)
+        return NULL;
+    if (radix == 10) {
+        int digits_per_limb = JS_LIMB_DIGITS;
+        len = 1;
+        r->tab[0] = 0;
+        for(;;) {
+            /* XXX: slow */
+            v = 0;
+            for(i = 0; i < digits_per_limb; i++) {
+                c = to_digit(*p);
+                if (c >= radix)
+                    break;
+                p++;
+                v = v * 10 + c;
+            }
+            if (i == 0)
+                break;
+            if (len == 1 && r->tab[0] == 0) {
+                r->tab[0] = v;
             } else {
-                prec = 53;
-                flags1 = bf_set_exp_bits(11) | BF_FLAG_SUBNORMAL;
-            }
-            bf_init(ctx->bf_ctx, r);
-            bf_set(r, a);
-            bf_round(r, prec, flags1 | BF_RNDN);
-            str = bf_ftoa(NULL, r, radix, prec, flags1 | flags);
-            bf_delete(r);
-        } else {
-            str = bf_ftoa(NULL, a, radix, BF_PREC_INF, flags);
+                h = mp_mul1(r->tab, r->tab, len, js_pow_dec[i], v);
+                if (h != 0) {
+                    r->tab[len++] = h;
+                }
+            }
         }
+        /* add one extra limb to have the correct sign*/
+        if ((r->tab[len - 1] >> (JS_LIMB_BITS - 1)) != 0)
+            r->tab[len++] = 0;
+        r->len = len;
     } else {
-        str = bf_ftoa(NULL, a, radix, prec, flags);
+        unsigned int bit_pos, shift, pos;
+        
+        /* power of two base: no multiplication is needed */
+        r->len = n_limbs;
+        memset(r->tab, 0, sizeof(r->tab[0]) * n_limbs);
+        for(i = 0; i < n_digits; i++) {
+            c = to_digit(p[n_digits - 1 - i]);
+            assert(c < radix);
+            bit_pos = i * log2_radix;
+            shift = bit_pos & (JS_LIMB_BITS - 1);
+            pos = bit_pos / JS_LIMB_BITS;
+            r->tab[pos] |= c << shift;
+            /* if log2_radix does not divide JS_LIMB_BITS, needed an
+               additional op */
+            if (shift + log2_radix > JS_LIMB_BITS) {
+                r->tab[pos + 1] |= c >> (JS_LIMB_BITS - shift);
+            }
+        }
+    }
+    r = js_bigint_normalize(ctx, r);
+    /* XXX: could do it in place */
+    if (is_neg) {
+        JSBigInt *r1;
+        r1 = js_bigint_neg(ctx, r);
+        js_free(ctx, r);
+        r = r1;
     }
-    a->sign = saved_sign;
-    if (a == &a_s)
-        bf_delete(a);
-    JS_FreeValue(ctx, val);
-    if (!str)
-        return JS_ThrowOutOfMemory(ctx);
-    ret = JS_NewString(ctx, str);
-    bf_free(ctx->bf_ctx, str);
-    return ret;
+    return r;
 }
 
-static JSValue js_bigfloat_to_string(JSContext *ctx, JSValueConst val)
-{
-    return js_ftoa(ctx, val, 10, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
-}
+/* 2 <= base <= 36 */
+static char const digits[36] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
-static JSValue js_bigdecimal_to_string1(JSContext *ctx, JSValueConst val,
-                                        limb_t prec, int flags)
+/* special version going backwards */
+/* XXX: use dtoa.c */
+static char *js_u64toa(char *q, int64_t n, unsigned int base)
 {
-    JSValue ret;
-    bfdec_t *a;
-    char *str;
-    int saved_sign;
-
-    a = JS_ToBigDecimal(ctx, val);
-    if (!a)
-        return JS_EXCEPTION;
-    saved_sign = a->sign;
-    if (a->expn == BF_EXP_ZERO)
-        a->sign = 0;
-    str = bfdec_ftoa(NULL, a, prec, flags | BF_FTOA_JS_QUIRKS);
-    a->sign = saved_sign;
-    if (!str)
-        return JS_ThrowOutOfMemory(ctx);
-    ret = JS_NewString(ctx, str);
-    bf_free(ctx->bf_ctx, str);
-    return ret;
+    int digit;
+    if (base == 10) {
+        /* division by known base uses multiplication */
+        do {
+            digit = (uint64_t)n % 10;
+            n = (uint64_t)n / 10;
+            *--q = '0' + digit;
+        } while (n != 0);
+    } else {
+        do {
+            digit = (uint64_t)n % base;
+            n = (uint64_t)n / base;
+            *--q = digits[digit];
+        } while (n != 0);
+    }
+    return q;
 }
 
-static JSValue js_bigdecimal_to_string(JSContext *ctx, JSValueConst val)
+/* len >= 1. 2 <= radix <= 36 */
+static char *limb_to_a(char *q, js_limb_t n, unsigned int radix, int len)
 {
-    return js_bigdecimal_to_string1(ctx, val, 0,
-                                    BF_RNDZ | BF_FTOA_FORMAT_FREE);
+    int digit, i;
+
+    if (radix == 10) {
+        /* specific case with constant divisor */
+        /* XXX: optimize */
+        for(i = 0; i < len; i++) {
+            digit = (js_limb_t)n % 10;
+            n = (js_limb_t)n / 10;
+            *--q = digit + '0';
+        }
+    } else {
+        for(i = 0; i < len; i++) {
+            digit = (js_limb_t)n % radix;
+            n = (js_limb_t)n / radix;
+            *--q = digits[digit];
+        }
+    }
+    return q;
 }
 
-#endif /* CONFIG_BIGNUM */
+#define JS_RADIX_MAX 36
 
-/* 2 <= base <= 36 */
-static char *i64toa(char *buf_end, int64_t n, unsigned int base)
-{
-    char *q = buf_end;
-    int digit, is_neg;
+static const uint8_t digits_per_limb_table[JS_RADIX_MAX - 1] = {
+#if JS_LIMB_BITS == 32
+32,20,16,13,12,11,10,10, 9, 9, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+#else
+64,40,32,27,24,22,21,20,19,18,17,17,16,16,16,15,15,15,14,14,14,14,13,13,13,13,13,13,13,12,12,12,12,12,12,
+#endif
+};
 
-    is_neg = 0;
-    if (n < 0) {
-        is_neg = 1;
-        n = -n;
-    }
-    *--q = '\0';
-    do {
-        digit = (uint64_t)n % base;
-        n = (uint64_t)n / base;
-        if (digit < 10)
-            digit += '0';
-        else
-            digit += 'a' - 10;
-        *--q = digit;
-    } while (n != 0);
-    if (is_neg)
-        *--q = '-';
-    return q;
-}
+static const js_limb_t radix_base_table[JS_RADIX_MAX - 1] = {
+#if JS_LIMB_BITS == 32
+ 0x00000000, 0xcfd41b91, 0x00000000, 0x48c27395,
+ 0x81bf1000, 0x75db9c97, 0x40000000, 0xcfd41b91,
+ 0x3b9aca00, 0x8c8b6d2b, 0x19a10000, 0x309f1021,
+ 0x57f6c100, 0x98c29b81, 0x00000000, 0x18754571,
+ 0x247dbc80, 0x3547667b, 0x4c4b4000, 0x6b5a6e1d,
+ 0x94ace180, 0xcaf18367, 0x0b640000, 0x0e8d4a51,
+ 0x1269ae40, 0x17179149, 0x1cb91000, 0x23744899,
+ 0x2b73a840, 0x34e63b41, 0x40000000, 0x4cfa3cc1,
+ 0x5c13d840, 0x6d91b519, 0x81bf1000,
+#else
+ 0x0000000000000000, 0xa8b8b452291fe821, 0x0000000000000000, 0x6765c793fa10079d,
+ 0x41c21cb8e1000000, 0x3642798750226111, 0x8000000000000000, 0xa8b8b452291fe821,
+ 0x8ac7230489e80000, 0x4d28cb56c33fa539, 0x1eca170c00000000, 0x780c7372621bd74d,
+ 0x1e39a5057d810000, 0x5b27ac993df97701, 0x0000000000000000, 0x27b95e997e21d9f1,
+ 0x5da0e1e53c5c8000, 0xd2ae3299c1c4aedb, 0x16bcc41e90000000, 0x2d04b7fdd9c0ef49,
+ 0x5658597bcaa24000, 0xa0e2073737609371, 0x0c29e98000000000, 0x14adf4b7320334b9,
+ 0x226ed36478bfa000, 0x383d9170b85ff80b, 0x5a3c23e39c000000, 0x8e65137388122bcd,
+ 0xdd41bb36d259e000, 0x0aee5720ee830681, 0x1000000000000000, 0x172588ad4f5f0981,
+ 0x211e44f7d02c1000, 0x2ee56725f06e5c71, 0x41c21cb8e1000000,
+#endif
+};
 
-/* buf1 contains the printf result */
-static void js_ecvt1(double d, int n_digits, int *decpt, int *sign, char *buf,
-                     int rounding_mode, char *buf1, int buf1_size)
-{
-    if (rounding_mode != FE_TONEAREST)
-        fesetround(rounding_mode);
-    snprintf(buf1, buf1_size, "%+.*e", n_digits - 1, d);
-    if (rounding_mode != FE_TONEAREST)
-        fesetround(FE_TONEAREST);
-    *sign = (buf1[0] == '-');
-    /* mantissa */
-    buf[0] = buf1[1];
-    if (n_digits > 1)
-        memcpy(buf + 1, buf1 + 3, n_digits - 1);
-    buf[n_digits] = '\0';
-    /* exponent */
-    *decpt = atoi(buf1 + n_digits + 2 + (n_digits > 1)) + 1;
-}
-
-/* maximum buffer size for js_dtoa */
-#define JS_DTOA_BUF_SIZE 128
-
-/* needed because ecvt usually limits the number of digits to
-   17. Return the number of digits. */
-static int js_ecvt(double d, int n_digits, int *decpt, int *sign, char *buf,
-                   BOOL is_fixed)
-{
-    int rounding_mode;
-    char buf_tmp[JS_DTOA_BUF_SIZE];
-
-    if (!is_fixed) {
-        unsigned int n_digits_min, n_digits_max;
-        /* find the minimum amount of digits (XXX: inefficient but simple) */
-        n_digits_min = 1;
-        n_digits_max = 17;
-        while (n_digits_min < n_digits_max) {
-            n_digits = (n_digits_min + n_digits_max) / 2;
-            js_ecvt1(d, n_digits, decpt, sign, buf, FE_TONEAREST,
-                     buf_tmp, sizeof(buf_tmp));
-            if (strtod(buf_tmp, NULL) == d) {
-                /* no need to keep the trailing zeros */
-                while (n_digits >= 2 && buf[n_digits - 1] == '0')
-                    n_digits--;
-                n_digits_max = n_digits;
-            } else {
-                n_digits_min = n_digits + 1;
-            }
-        }
-        n_digits = n_digits_max;
-        rounding_mode = FE_TONEAREST;
+static JSValue js_bigint_to_string1(JSContext *ctx, JSValueConst val, int radix)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_SHORT_BIG_INT) {
+        char buf[66];
+        int len;
+        len = i64toa_radix(buf, JS_VALUE_GET_SHORT_BIG_INT(val), radix);
+        return js_new_string8_len(ctx, buf, len);
     } else {
-        rounding_mode = FE_TONEAREST;
-#ifdef CONFIG_PRINTF_RNDN
-        {
-            char buf1[JS_DTOA_BUF_SIZE], buf2[JS_DTOA_BUF_SIZE];
-            int decpt1, sign1, decpt2, sign2;
-            /* The JS rounding is specified as round to nearest ties away
-               from zero (RNDNA), but in printf the "ties" case is not
-               specified (for example it is RNDN for glibc, RNDNA for
-               Windows), so we must round manually. */
-            js_ecvt1(d, n_digits + 1, &decpt1, &sign1, buf1, FE_TONEAREST,
-                     buf_tmp, sizeof(buf_tmp));
-            /* XXX: could use 2 digits to reduce the average running time */
-            if (buf1[n_digits] == '5') {
-                js_ecvt1(d, n_digits + 1, &decpt1, &sign1, buf1, FE_DOWNWARD,
-                         buf_tmp, sizeof(buf_tmp));
-                js_ecvt1(d, n_digits + 1, &decpt2, &sign2, buf2, FE_UPWARD,
-                         buf_tmp, sizeof(buf_tmp));
-                if (memcmp(buf1, buf2, n_digits + 1) == 0 && decpt1 == decpt2) {
-                    /* exact result: round away from zero */
-                    if (sign1)
-                        rounding_mode = FE_DOWNWARD;
-                    else
-                        rounding_mode = FE_UPWARD;
+        JSBigInt *r, *tmp = NULL;
+        char *buf, *q, *buf_end;
+        int is_neg, n_bits, log2_radix, n_digits;
+        BOOL is_binary_radix;
+        JSValue res;
+        
+        assert(JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT);
+        r = JS_VALUE_GET_PTR(val);
+        if (r->len == 1 && r->tab[0] == 0) {
+            /* '0' case */
+            return js_new_string8_len(ctx, "0", 1);
+        }
+        is_binary_radix = ((radix & (radix - 1)) == 0);
+        is_neg = js_bigint_sign(r);
+        if (is_neg) {
+            tmp = js_bigint_neg(ctx, r);
+            if (!tmp)
+                return JS_EXCEPTION;
+            r = tmp;
+        } else if (!is_binary_radix) {
+            /* need to modify 'r' */
+            tmp = js_bigint_new(ctx, r->len);
+            if (!tmp)
+                return JS_EXCEPTION;
+            memcpy(tmp->tab, r->tab, r->len * sizeof(r->tab[0]));
+            r = tmp;
+        }
+        log2_radix = 31 - clz32(radix); /* floor(log2(radix)) */
+        n_bits = r->len * JS_LIMB_BITS - js_limb_safe_clz(r->tab[r->len - 1]);
+        /* n_digits is exact only if radix is a power of
+           two. Otherwise it is >= the exact number of digits */
+        n_digits = (n_bits + log2_radix - 1) / log2_radix;
+        /* XXX: could directly build the JSString */
+        buf = js_malloc(ctx, n_digits + is_neg + 1);
+        if (!buf) {
+            js_free(ctx, tmp);
+            return JS_EXCEPTION;
+        }
+        q = buf + n_digits + is_neg + 1;
+        *--q = '\0';
+        buf_end = q;
+        if (!is_binary_radix) {
+            int len;
+            js_limb_t radix_base, v;
+            radix_base = radix_base_table[radix - 2];
+            len = r->len;
+            for(;;) {
+                /* remove leading zero limbs */
+                while (len > 1 && r->tab[len - 1] == 0)
+                    len--;
+                if (len == 1 && r->tab[0] < radix_base) {
+                    v = r->tab[0];
+                    if (v != 0) {
+                        q = js_u64toa(q, v, radix);
+                    }
+                    break;
+                } else {
+                    v = mp_div1(r->tab, r->tab, len, radix_base, 0);
+                    q = limb_to_a(q, v, radix, digits_per_limb_table[radix - 2]);
+                }
+            }
+        } else {
+            int i, shift;
+            unsigned int bit_pos, pos, c;
+
+            /* radix is a power of two */
+            for(i = 0; i < n_digits; i++) {
+                bit_pos = i * log2_radix;
+                pos = bit_pos / JS_LIMB_BITS;
+                shift = bit_pos % JS_LIMB_BITS;
+                if (likely((shift + log2_radix) <= JS_LIMB_BITS)) {
+                    c = r->tab[pos] >> shift;
+                } else {
+                    c = (r->tab[pos] >> shift) |
+                        (r->tab[pos + 1] << (JS_LIMB_BITS - shift));
                 }
+                c &= (radix - 1);
+                *--q = digits[c];
             }
         }
-#endif /* CONFIG_PRINTF_RNDN */
+        if (is_neg)
+            *--q = '-';
+        js_free(ctx, tmp);
+        res = js_new_string8_len(ctx, q, buf_end - q);
+        js_free(ctx, buf);
+        return res;
     }
-    js_ecvt1(d, n_digits, decpt, sign, buf, rounding_mode,
-             buf_tmp, sizeof(buf_tmp));
-    return n_digits;
-}
-
-static int js_fcvt1(char *buf, int buf_size, double d, int n_digits,
-                    int rounding_mode)
-{
-    int n;
-    if (rounding_mode != FE_TONEAREST)
-        fesetround(rounding_mode);
-    n = snprintf(buf, buf_size, "%.*f", n_digits, d);
-    if (rounding_mode != FE_TONEAREST)
-        fesetround(FE_TONEAREST);
-    assert(n < buf_size);
-    return n;
 }
 
-static void js_fcvt(char *buf, int buf_size, double d, int n_digits)
+/* if possible transform a BigInt to short big and free it, otherwise
+   return a normal bigint */
+static JSValue JS_CompactBigInt(JSContext *ctx, JSBigInt *p)
 {
-    int rounding_mode;
-    rounding_mode = FE_TONEAREST;
-#ifdef CONFIG_PRINTF_RNDN
-    {
-        int n1, n2;
-        char buf1[JS_DTOA_BUF_SIZE];
-        char buf2[JS_DTOA_BUF_SIZE];
-
-        /* The JS rounding is specified as round to nearest ties away from
-           zero (RNDNA), but in printf the "ties" case is not specified
-           (for example it is RNDN for glibc, RNDNA for Windows), so we
-           must round manually. */
-        n1 = js_fcvt1(buf1, sizeof(buf1), d, n_digits + 1, FE_TONEAREST);
-        rounding_mode = FE_TONEAREST;
-        /* XXX: could use 2 digits to reduce the average running time */
-        if (buf1[n1 - 1] == '5') {
-            n1 = js_fcvt1(buf1, sizeof(buf1), d, n_digits + 1, FE_DOWNWARD);
-            n2 = js_fcvt1(buf2, sizeof(buf2), d, n_digits + 1, FE_UPWARD);
-            if (n1 == n2 && memcmp(buf1, buf2, n1) == 0) {
-                /* exact result: round away from zero */
-                if (buf1[0] == '-')
-                    rounding_mode = FE_DOWNWARD;
-                else
-                    rounding_mode = FE_UPWARD;
-            }
-        }
+    JSValue res;
+    if (p->len == 1) {
+        res = __JS_NewShortBigInt(ctx, (js_slimb_t)p->tab[0]);
+        js_free(ctx, p);
+        return res;
+    } else {
+        return JS_MKPTR(JS_TAG_BIG_INT, p);
     }
-#endif /* CONFIG_PRINTF_RNDN */
-    js_fcvt1(buf, buf_size, d, n_digits, rounding_mode);
 }
 
-/* radix != 10 is only supported with flags = JS_DTOA_VAR_FORMAT */
-/* use as many digits as necessary */
-#define JS_DTOA_VAR_FORMAT   (0 << 0)
-/* use n_digits significant digits (1 <= n_digits <= 101) */
-#define JS_DTOA_FIXED_FORMAT (1 << 0)
-/* force fractional format: [-]dd.dd with n_digits fractional digits */
-#define JS_DTOA_FRAC_FORMAT  (2 << 0)
-/* force exponential notation either in fixed or variable format */
-#define JS_DTOA_FORCE_EXP    (1 << 2)
+#define ATOD_INT_ONLY        (1 << 0)
+/* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
+#define ATOD_ACCEPT_BIN_OCT  (1 << 2)
+/* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
+#define ATOD_ACCEPT_LEGACY_OCTAL  (1 << 4)
+/* accept _ between digits as a digit separator */
+#define ATOD_ACCEPT_UNDERSCORES  (1 << 5)
+/* allow a suffix to override the type */
+#define ATOD_ACCEPT_SUFFIX    (1 << 6)
+/* default type */
+#define ATOD_TYPE_MASK        (3 << 7)
+#define ATOD_TYPE_FLOAT64     (0 << 7)
+#define ATOD_TYPE_BIG_INT     (1 << 7)
+/* accept -0x1 */
+#define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
-/* XXX: slow and maybe not fully correct. Use libbf when it is fast enough.
-   XXX: radix != 10 is only supported for small integers
-*/
-static void js_dtoa1(char *buf, double d, int radix, int n_digits, int flags)
+/* return an exception in case of memory error. Return JS_NAN if
+   invalid syntax */
+/* XXX: directly use js_atod() */
+static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
+                       int radix, int flags)
 {
-    char *q;
+    const char *p, *p_start;
+    int sep, is_neg;
+    BOOL is_float, has_legacy_octal;
+    int atod_type = flags & ATOD_TYPE_MASK;
+    char buf1[64], *buf;
+    int i, j, len;
+    BOOL buf_allocated = FALSE;
+    JSValue val;
+    JSATODTempMem atod_mem;
+    
+    /* optional separator between digits */
+    sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
+    has_legacy_octal = FALSE;
 
-    if (!isfinite(d)) {
-        if (isnan(d)) {
-            strcpy(buf, "NaN");
-        } else {
-            q = buf;
-            if (d < 0)
-                *q++ = '-';
-            strcpy(q, "Infinity");
-        }
-    } else if (flags == JS_DTOA_VAR_FORMAT) {
-        int64_t i64;
-        char buf1[70], *ptr;
-        i64 = (int64_t)d;
-        if (d != i64 || i64 > MAX_SAFE_INTEGER || i64 < -MAX_SAFE_INTEGER)
-            goto generic_conv;
-        /* fast path for integers */
-        ptr = i64toa(buf1 + sizeof(buf1), i64, radix);
-        strcpy(buf, ptr);
-    } else {
-        if (d == 0.0)
-            d = 0.0; /* convert -0 to 0 */
-        if (flags == JS_DTOA_FRAC_FORMAT) {
-            js_fcvt(buf, JS_DTOA_BUF_SIZE, d, n_digits);
+    p = str;
+    p_start = p;
+    is_neg = 0;
+    if (p[0] == '+') {
+        p++;
+        p_start++;
+        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
+            goto no_radix_prefix;
+    } else if (p[0] == '-') {
+        p++;
+        p_start++;
+        is_neg = 1;
+        if (!(flags & ATOD_ACCEPT_PREFIX_AFTER_SIGN))
+            goto no_radix_prefix;
+    }
+    if (p[0] == '0') {
+        if ((p[1] == 'x' || p[1] == 'X') &&
+            (radix == 0 || radix == 16)) {
+            p += 2;
+            radix = 16;
+        } else if ((p[1] == 'o' || p[1] == 'O') &&
+                   radix == 0 && (flags & ATOD_ACCEPT_BIN_OCT)) {
+            p += 2;
+            radix = 8;
+        } else if ((p[1] == 'b' || p[1] == 'B') &&
+                   radix == 0 && (flags & ATOD_ACCEPT_BIN_OCT)) {
+            p += 2;
+            radix = 2;
+        } else if ((p[1] >= '0' && p[1] <= '9') &&
+                   radix == 0 && (flags & ATOD_ACCEPT_LEGACY_OCTAL)) {
+            int i;
+            has_legacy_octal = TRUE;
+            sep = 256;
+            for (i = 1; (p[i] >= '0' && p[i] <= '7'); i++)
+                continue;
+            if (p[i] == '8' || p[i] == '9')
+                goto no_prefix;
+            p += 1;
+            radix = 8;
         } else {
-            char buf1[JS_DTOA_BUF_SIZE];
-            int sign, decpt, k, n, i, p, n_max;
-            BOOL is_fixed;
-        generic_conv:
-            is_fixed = ((flags & 3) == JS_DTOA_FIXED_FORMAT);
-            if (is_fixed) {
-                n_max = n_digits;
-            } else {
-                n_max = 21;
+            goto no_prefix;
+        }
+        /* there must be a digit after the prefix */
+        if (to_digit((uint8_t)*p) >= radix)
+            goto fail;
+    no_prefix: ;
+    } else {
+ no_radix_prefix:
+        if (!(flags & ATOD_INT_ONLY) &&
+            (atod_type == ATOD_TYPE_FLOAT64) &&
+            strstart(p, "Infinity", &p)) {
+            double d = 1.0 / 0.0;
+            if (is_neg)
+                d = -d;
+            val = JS_NewFloat64(ctx, d);
+            goto done;
+        }
+    }
+    if (radix == 0)
+        radix = 10;
+    is_float = FALSE;
+    p_start = p;
+    while (to_digit((uint8_t)*p) < radix
+           ||  (*p == sep && (radix != 10 ||
+                              p != p_start + 1 || p[-1] != '0') &&
+                to_digit((uint8_t)p[1]) < radix)) {
+        p++;
+    }
+    if (!(flags & ATOD_INT_ONLY)) {
+        if (*p == '.' && (p > p_start || to_digit((uint8_t)p[1]) < radix)) {
+            is_float = TRUE;
+            p++;
+            if (*p == sep)
+                goto fail;
+            while (to_digit((uint8_t)*p) < radix ||
+                   (*p == sep && to_digit((uint8_t)p[1]) < radix))
+                p++;
+        }
+        if (p > p_start &&
+            (((*p == 'e' || *p == 'E') && radix == 10) ||
+             ((*p == 'p' || *p == 'P') && (radix == 2 || radix == 8 || radix == 16)))) {
+            const char *p1 = p + 1;
+            is_float = TRUE;
+            if (*p1 == '+') {
+                p1++;
+            } else if (*p1 == '-') {
+                p1++;
             }
-            /* the number has k digits (k >= 1) */
-            k = js_ecvt(d, n_digits, &decpt, &sign, buf1, is_fixed);
-            n = decpt; /* d=10^(n-k)*(buf1) i.e. d= < x.yyyy 10^(n-1) */
-            q = buf;
-            if (sign)
-                *q++ = '-';
-            if (flags & JS_DTOA_FORCE_EXP)
-                goto force_exp;
-            if (n >= 1 && n <= n_max) {
-                if (k <= n) {
-                    memcpy(q, buf1, k);
-                    q += k;
-                    for(i = 0; i < (n - k); i++)
-                        *q++ = '0';
-                    *q = '\0';
-                } else {
-                    /* k > n */
-                    memcpy(q, buf1, n);
-                    q += n;
-                    *q++ = '.';
-                    for(i = 0; i < (k - n); i++)
-                        *q++ = buf1[n + i];
-                    *q = '\0';
-                }
-            } else if (n >= -5 && n <= 0) {
-                *q++ = '0';
-                *q++ = '.';
-                for(i = 0; i < -n; i++)
-                    *q++ = '0';
-                memcpy(q, buf1, k);
-                q += k;
-                *q = '\0';
-            } else {
-            force_exp:
-                /* exponential notation */
-                *q++ = buf1[0];
-                if (k > 1) {
-                    *q++ = '.';
-                    for(i = 1; i < k; i++)
-                        *q++ = buf1[i];
-                }
-                *q++ = 'e';
-                p = n - 1;
-                if (p >= 0)
-                    *q++ = '+';
-                sprintf(q, "%d", p);
+            if (is_digit((uint8_t)*p1)) {
+                p = p1 + 1;
+                while (is_digit((uint8_t)*p) || (*p == sep && is_digit((uint8_t)p[1])))
+                    p++;
             }
         }
     }
-}
+    if (p == p_start)
+        goto fail;
 
-static JSValue js_dtoa(JSContext *ctx,
-                       double d, int radix, int n_digits, int flags)
-{
-    char buf[JS_DTOA_BUF_SIZE];
-    js_dtoa1(buf, d, radix, n_digits, flags);
-    return JS_NewString(ctx, buf);
+    buf = buf1;
+    buf_allocated = FALSE;
+    len = p - p_start;
+    if (unlikely((len + 2) > sizeof(buf1))) {
+        buf = js_malloc_rt(ctx->rt, len + 2); /* no exception raised */
+        if (!buf)
+            goto mem_error;
+        buf_allocated = TRUE;
+    }
+    /* remove the separators and the radix prefixes */
+    j = 0;
+    if (is_neg)
+        buf[j++] = '-';
+    for (i = 0; i < len; i++) {
+        if (p_start[i] != '_')
+            buf[j++] = p_start[i];
+    }
+    buf[j] = '\0';
+
+    if (flags & ATOD_ACCEPT_SUFFIX) {
+        if (*p == 'n') {
+            p++;
+            atod_type = ATOD_TYPE_BIG_INT;
+        } else {
+            if (is_float && radix != 10)
+                goto fail;
+        }
+    } else {
+        if (atod_type == ATOD_TYPE_FLOAT64) {
+            if (is_float && radix != 10)
+                goto fail;
+        }
+    }
+
+    switch(atod_type) {
+    case ATOD_TYPE_FLOAT64:
+        {
+            double d;
+            d = js_atod(buf, NULL, radix, is_float ? 0 : JS_ATOD_INT_ONLY,
+                        &atod_mem);
+            /* return int or float64 */
+            val = JS_NewFloat64(ctx, d);
+        }
+        break;
+    case ATOD_TYPE_BIG_INT:
+        {
+            JSBigInt *r;
+            if (has_legacy_octal || is_float)
+                goto fail;
+            r = js_bigint_from_string(ctx, buf, radix);
+            if (!r)
+                goto mem_error;
+            val = JS_CompactBigInt(ctx, r);
+        }
+        break;
+    default:
+        abort();
+    }
+
+done:
+    if (buf_allocated)
+        js_free_rt(ctx->rt, buf);
+    if (pp)
+        *pp = p;
+    return val;
+ fail:
+    val = JS_NAN;
+    goto done;
+ mem_error:
+    val = JS_ThrowOutOfMemory(ctx);
+    goto done;
 }
 
-JSValue JS_ToStringInternal(JSContext *ctx, JSValueConst val, BOOL is_ToPropertyKey)
+typedef enum JSToNumberHintEnum {
+    TON_FLAG_NUMBER,
+    TON_FLAG_NUMERIC,
+} JSToNumberHintEnum;
+
+static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
+                                   JSToNumberHintEnum flag)
 {
     uint32_t tag;
-    const char *str;
-    char buf[32];
+    JSValue ret;
 
+ redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
-    case JS_TAG_STRING:
-        return JS_DupValue(ctx, val);
+    case JS_TAG_BIG_INT:
+    case JS_TAG_SHORT_BIG_INT:
+        if (flag != TON_FLAG_NUMERIC) {
+            JS_FreeValue(ctx, val);
+            return JS_ThrowTypeError(ctx, "cannot convert bigint to number");
+        }
+        ret = val;
+        break;
+    case JS_TAG_FLOAT64:
     case JS_TAG_INT:
-        snprintf(buf, sizeof(buf), "%d", JS_VALUE_GET_INT(val));
-        str = buf;
-        goto new_string;
+    case JS_TAG_EXCEPTION:
+        ret = val;
+        break;
     case JS_TAG_BOOL:
-        return JS_AtomToString(ctx, JS_VALUE_GET_BOOL(val) ?
-                          JS_ATOM_true : JS_ATOM_false);
     case JS_TAG_NULL:
-        return JS_AtomToString(ctx, JS_ATOM_null);
+        ret = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
+        break;
     case JS_TAG_UNDEFINED:
-        return JS_AtomToString(ctx, JS_ATOM_undefined);
-    case JS_TAG_EXCEPTION:
-        return JS_EXCEPTION;
+        ret = JS_NAN;
+        break;
     case JS_TAG_OBJECT:
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        goto redo;
+    case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         {
-            JSValue val1, ret;
-            val1 = JS_ToPrimitive(ctx, val, HINT_STRING);
-            if (JS_IsException(val1))
-                return val1;
-            ret = JS_ToStringInternal(ctx, val1, is_ToPropertyKey);
-            JS_FreeValue(ctx, val1);
-            return ret;
+            const char *str;
+            const char *p;
+            size_t len;
+
+            str = JS_ToCStringLen(ctx, &len, val);
+            JS_FreeValue(ctx, val);
+            if (!str)
+                return JS_EXCEPTION;
+            p = str;
+            p += skip_spaces(p);
+            if ((p - str) == len) {
+                ret = JS_NewInt32(ctx, 0);
+            } else {
+                int flags = ATOD_ACCEPT_BIN_OCT;
+                ret = js_atof(ctx, p, &p, 0, flags);
+                if (!JS_IsException(ret)) {
+                    p += skip_spaces(p);
+                    if ((p - str) != len) {
+                        JS_FreeValue(ctx, ret);
+                        ret = JS_NAN;
+                    }
+                }
+            }
+            JS_FreeCString(ctx, str);
         }
         break;
-    case JS_TAG_FUNCTION_BYTECODE:
-        str = "[function bytecode]";
-        goto new_string;
     case JS_TAG_SYMBOL:
-        if (is_ToPropertyKey) {
-            return JS_DupValue(ctx, val);
-        } else {
-            return JS_ThrowTypeError(ctx, "cannot convert symbol to string");
-        }
-    case JS_TAG_FLOAT64:
-        return js_dtoa(ctx, JS_VALUE_GET_FLOAT64(val), 10, 0,
-                       JS_DTOA_VAR_FORMAT);
-    case JS_TAG_BIG_INT:
-        return ctx->rt->bigint_ops.to_string(ctx, val);
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        return ctx->rt->bigfloat_ops.to_string(ctx, val);
-    case JS_TAG_BIG_DECIMAL:
-        return ctx->rt->bigdecimal_ops.to_string(ctx, val);
-#endif
+        JS_FreeValue(ctx, val);
+        return JS_ThrowTypeError(ctx, "cannot convert symbol to number");
     default:
-        str = "[unsupported type]";
-    new_string:
-        return JS_NewString(ctx, str);
+        JS_FreeValue(ctx, val);
+        ret = JS_NAN;
+        break;
     }
+    return ret;
 }
 
-JSValue JS_ToString(JSContext *ctx, JSValueConst val)
+static JSValue JS_ToNumberFree(JSContext *ctx, JSValue val)
 {
-    return JS_ToStringInternal(ctx, val, FALSE);
+    return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMBER);
 }
 
-static JSValue JS_ToStringFree(JSContext *ctx, JSValue val)
+static JSValue JS_ToNumericFree(JSContext *ctx, JSValue val)
 {
-    JSValue ret;
-    ret = JS_ToString(ctx, val);
-    JS_FreeValue(ctx, val);
-    return ret;
+    return JS_ToNumberHintFree(ctx, val, TON_FLAG_NUMERIC);
 }
 
-static JSValue JS_ToLocaleStringFree(JSContext *ctx, JSValue val)
+static JSValue JS_ToNumeric(JSContext *ctx, JSValueConst val)
 {
-    if (JS_IsUndefined(val) || JS_IsNull(val))
-        return JS_ToStringFree(ctx, val);
-    return JS_InvokeFree(ctx, val, JS_ATOM_toLocaleString, 0, NULL);
+    return JS_ToNumericFree(ctx, JS_DupValue(ctx, val));
 }
 
-JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val)
+static __exception int __JS_ToFloat64Free(JSContext *ctx, double *pres,
+                                          JSValue val)
 {
-    return JS_ToStringInternal(ctx, val, TRUE);
+    double d;
+    uint32_t tag;
+    
+    val = JS_ToNumberFree(ctx, val);
+    if (JS_IsException(val))
+        goto fail;
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+        d = JS_VALUE_GET_INT(val);
+        break;
+    case JS_TAG_FLOAT64:
+        d = JS_VALUE_GET_FLOAT64(val);
+        break;
+    default:
+        abort();
+    }
+    *pres = d;
+    return 0;
+ fail:
+    *pres = JS_FLOAT64_NAN;
+    return -1;
 }
 
-static JSValue JS_ToStringCheckObject(JSContext *ctx, JSValueConst val)
+static inline int JS_ToFloat64Free(JSContext *ctx, double *pres, JSValue val)
 {
-    uint32_t tag = JS_VALUE_GET_TAG(val);
-    if (tag == JS_TAG_NULL || tag == JS_TAG_UNDEFINED)
-        return JS_ThrowTypeError(ctx, "null or undefined are forbidden");
-    return JS_ToString(ctx, val);
+    uint32_t tag;
+
+    tag = JS_VALUE_GET_TAG(val);
+    if (tag <= JS_TAG_NULL) {
+        *pres = JS_VALUE_GET_INT(val);
+        return 0;
+    } else if (JS_TAG_IS_FLOAT64(tag)) {
+        *pres = JS_VALUE_GET_FLOAT64(val);
+        return 0;
+    } else {
+        return __JS_ToFloat64Free(ctx, pres, val);
+    }
 }
 
-static JSValue JS_ToQuotedString(JSContext *ctx, JSValueConst val1)
+int JS_ToFloat64(JSContext *ctx, double *pres, JSValueConst val)
 {
-    JSValue val;
-    JSString *p;
-    int i;
-    uint32_t c;
-    StringBuffer b_s, *b = &b_s;
-    char buf[16];
-
-    val = JS_ToStringCheckObject(ctx, val1);
-    if (JS_IsException(val))
-        return val;
-    p = JS_VALUE_GET_STRING(val);
+    return JS_ToFloat64Free(ctx, pres, JS_DupValue(ctx, val));
+}
 
-    if (string_buffer_init(ctx, b, p->len + 2))
-        goto fail;
+static JSValue JS_ToNumber(JSContext *ctx, JSValueConst val)
+{
+    return JS_ToNumberFree(ctx, JS_DupValue(ctx, val));
+}
 
-    if (string_buffer_putc8(b, '\"'))
-        goto fail;
-    for(i = 0; i < p->len; ) {
-        c = string_getc(p, &i);
-        switch(c) {
-        case '\t':
-            c = 't';
-            goto quote;
-        case '\r':
-            c = 'r';
-            goto quote;
-        case '\n':
-            c = 'n';
-            goto quote;
-        case '\b':
-            c = 'b';
-            goto quote;
-        case '\f':
-            c = 'f';
-            goto quote;
-        case '\"':
-        case '\\':
-        quote:
-            if (string_buffer_putc8(b, '\\'))
-                goto fail;
-            if (string_buffer_putc8(b, c))
-                goto fail;
-            break;
-        default:
-            if (c < 32 || (c >= 0xd800 && c < 0xe000)) {
-                snprintf(buf, sizeof(buf), "\\u%04x", c);
-                if (string_buffer_puts8(b, buf))
-                    goto fail;
+/* same as JS_ToNumber() but return 0 in case of NaN/Undefined */
+static __maybe_unused JSValue JS_ToIntegerFree(JSContext *ctx, JSValue val)
+{
+    uint32_t tag;
+    JSValue ret;
+
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_BOOL:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+        ret = JS_NewInt32(ctx, JS_VALUE_GET_INT(val));
+        break;
+    case JS_TAG_FLOAT64:
+        {
+            double d = JS_VALUE_GET_FLOAT64(val);
+            if (isnan(d)) {
+                ret = JS_NewInt32(ctx, 0);
             } else {
-                if (string_buffer_putc(b, c))
-                    goto fail;
+                /* convert -0 to +0 */
+                d = trunc(d) + 0.0;
+                ret = JS_NewFloat64(ctx, d);
             }
-            break;
         }
+        break;
+    default:
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val))
+            return val;
+        goto redo;
     }
-    if (string_buffer_putc8(b, '\"'))
-        goto fail;
-    JS_FreeValue(ctx, val);
-    return string_buffer_end(b);
- fail:
-    JS_FreeValue(ctx, val);
-    string_buffer_free(b);
-    return JS_EXCEPTION;
-}
-
-static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt)
-{
-    printf("%14s %4s %4s %14s %10s %s\n",
-           "ADDRESS", "REFS", "SHRF", "PROTO", "CLASS", "PROPS");
+    return ret;
 }
 
-/* for debug only: dump an object without side effect */
-static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
+/* Note: the integer value is satured to 32 bits */
+static int JS_ToInt32SatFree(JSContext *ctx, int *pres, JSValue val)
 {
-    uint32_t i;
-    char atom_buf[ATOM_GET_STR_BUF_SIZE];
-    JSShape *sh;
-    JSShapeProperty *prs;
-    JSProperty *pr;
-    BOOL is_first = TRUE;
-
-    /* XXX: should encode atoms with special characters */
-    sh = p->shape; /* the shape can be NULL while freeing an object */
-    printf("%14p %4d ",
-           (void *)p,
-           p->header.ref_count);
-    if (sh) {
-        printf("%3d%c %14p ",
-               sh->header.ref_count,
-               " *"[sh->is_hashed],
-               (void *)sh->proto);
-    } else {
-        printf("%3s  %14s ", "-", "-");
-    }
-    printf("%10s ",
-           JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), rt->class_array[p->class_id].class_name));
-    if (p->is_exotic && p->fast_array) {
-        printf("[ ");
-        for(i = 0; i < p->u.array.count; i++) {
-            if (i != 0)
-                printf(", ");
-            switch (p->class_id) {
-            case JS_CLASS_ARRAY:
-            case JS_CLASS_ARGUMENTS:
-                JS_DumpValueShort(rt, p->u.array.u.values[i]);
-                break;
-            case JS_CLASS_UINT8C_ARRAY:
-            case JS_CLASS_INT8_ARRAY:
-            case JS_CLASS_UINT8_ARRAY:
-            case JS_CLASS_INT16_ARRAY:
-            case JS_CLASS_UINT16_ARRAY:
-            case JS_CLASS_INT32_ARRAY:
-            case JS_CLASS_UINT32_ARRAY:
-            case JS_CLASS_BIG_INT64_ARRAY:
-            case JS_CLASS_BIG_UINT64_ARRAY:
-            case JS_CLASS_FLOAT32_ARRAY:
-            case JS_CLASS_FLOAT64_ARRAY:
-                {
-                    int size = 1 << typed_array_size_log2(p->class_id);
-                    const uint8_t *b = p->u.array.u.uint8_ptr + i * size;
-                    while (size-- > 0)
-                        printf("%02X", *b++);
-                }
-                break;
-            }
-        }
-        printf(" ] ");
-    }
+    uint32_t tag;
+    int ret;
 
-    if (sh) {
-        printf("{ ");
-        for(i = 0, prs = get_shape_prop(sh); i < sh->prop_count; i++, prs++) {
-            if (prs->atom != JS_ATOM_NULL) {
-                pr = &p->prop[i];
-                if (!is_first)
-                    printf(", ");
-                printf("%s: ",
-                       JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), prs->atom));
-                if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
-                    printf("[getset %p %p]", (void *)pr->u.getset.getter,
-                           (void *)pr->u.getset.setter);
-                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
-                    printf("[varref %p]", (void *)pr->u.var_ref);
-                } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
-                    printf("[autoinit %p %d %p]",
-                           (void *)js_autoinit_get_realm(pr),
-                           js_autoinit_get_id(pr),
-                           (void *)pr->u.init.opaque);
-                } else {
-                    JS_DumpValueShort(rt, pr->u.value);
-                }
-                is_first = FALSE;
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_BOOL:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+        ret = JS_VALUE_GET_INT(val);
+        break;
+    case JS_TAG_EXCEPTION:
+        *pres = 0;
+        return -1;
+    case JS_TAG_FLOAT64:
+        {
+            double d = JS_VALUE_GET_FLOAT64(val);
+            if (isnan(d)) {
+                ret = 0;
+            } else {
+                if (d < INT32_MIN)
+                    ret = INT32_MIN;
+                else if (d > INT32_MAX)
+                    ret = INT32_MAX;
+                else
+                    ret = (int)d;
             }
         }
-        printf(" }");
-    }
-    
-    if (js_class_has_bytecode(p->class_id)) {
-        JSFunctionBytecode *b = p->u.func.function_bytecode;
-        JSVarRef **var_refs;
-        if (b->closure_var_count) {
-            var_refs = p->u.func.var_refs;
-            printf(" Closure:");
-            for(i = 0; i < b->closure_var_count; i++) {
-                printf(" ");
-                JS_DumpValueShort(rt, var_refs[i]->value);
-            }
-            if (p->u.func.home_object) {
-                printf(" HomeObject: ");
-                JS_DumpValueShort(rt, JS_MKPTR(JS_TAG_OBJECT, p->u.func.home_object));
-            }
+        break;
+    default:
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val)) {
+            *pres = 0;
+            return -1;
         }
+        goto redo;
     }
-    printf("\n");
+    *pres = ret;
+    return 0;
 }
 
-static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p)
+int JS_ToInt32Sat(JSContext *ctx, int *pres, JSValueConst val)
 {
-    if (p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT) {
-        JS_DumpObject(rt, (JSObject *)p);
-    } else {
-        printf("%14p %4d ",
-               (void *)p,
-               p->ref_count);
-        switch(p->gc_obj_type) {
-        case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
-            printf("[function bytecode]");
-            break;
-        case JS_GC_OBJ_TYPE_SHAPE:
-            printf("[shape]");
-            break;
-        case JS_GC_OBJ_TYPE_VAR_REF:
-            printf("[var_ref]");
-            break;
-        case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
-            printf("[async_function]");
-            break;
-        case JS_GC_OBJ_TYPE_JS_CONTEXT:
-            printf("[js_context]");
-            break;
-        default:
-            printf("[unknown %d]", p->gc_obj_type);
-            break;
+    return JS_ToInt32SatFree(ctx, pres, JS_DupValue(ctx, val));
+}
+
+int JS_ToInt32Clamp(JSContext *ctx, int *pres, JSValueConst val,
+                    int min, int max, int min_offset)
+{
+    int res = JS_ToInt32SatFree(ctx, pres, JS_DupValue(ctx, val));
+    if (res == 0) {
+        if (*pres < min) {
+            *pres += min_offset;
+            if (*pres < min)
+                *pres = min;
+        } else {
+            if (*pres > max)
+                *pres = max;
         }
-        printf("\n");
     }
+    return res;
 }
 
-static __maybe_unused void JS_DumpValueShort(JSRuntime *rt,
-                                                      JSValueConst val)
+static int JS_ToInt64SatFree(JSContext *ctx, int64_t *pres, JSValue val)
 {
-    uint32_t tag = JS_VALUE_GET_NORM_TAG(val);
-    const char *str;
+    uint32_t tag;
 
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
     case JS_TAG_INT:
-        printf("%d", JS_VALUE_GET_INT(val));
-        break;
     case JS_TAG_BOOL:
-        if (JS_VALUE_GET_BOOL(val))
-            str = "true";
-        else
-            str = "false";
-        goto print_str;
     case JS_TAG_NULL:
-        str = "null";
-        goto print_str;
-    case JS_TAG_EXCEPTION:
-        str = "exception";
-        goto print_str;
-    case JS_TAG_UNINITIALIZED:
-        str = "uninitialized";
-        goto print_str;
     case JS_TAG_UNDEFINED:
-        str = "undefined";
-    print_str:
-        printf("%s", str);
-        break;
+        *pres = JS_VALUE_GET_INT(val);
+        return 0;
+    case JS_TAG_EXCEPTION:
+        *pres = 0;
+        return -1;
     case JS_TAG_FLOAT64:
-        printf("%.14g", JS_VALUE_GET_FLOAT64(val));
-        break;
-    case JS_TAG_BIG_INT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            char *str;
-            str = bf_ftoa(NULL, &p->num, 10, 0,
-                          BF_RNDZ | BF_FTOA_FORMAT_FRAC);
-            printf("%sn", str);
-            bf_realloc(&rt->bf_ctx, str, 0);
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            char *str;
-            str = bf_ftoa(NULL, &p->num, 16, BF_PREC_INF,
-                          BF_RNDZ | BF_FTOA_FORMAT_FREE | BF_FTOA_ADD_PREFIX);
-            printf("%sl", str);
-            bf_free(&rt->bf_ctx, str);
-        }
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        {
-            JSBigDecimal *p = JS_VALUE_GET_PTR(val);
-            char *str;
-            str = bfdec_ftoa(NULL, &p->num, BF_PREC_INF,
-                             BF_RNDZ | BF_FTOA_FORMAT_FREE);
-            printf("%sm", str);
-            bf_free(&rt->bf_ctx, str);
-        }
-        break;
-#endif
-    case JS_TAG_STRING:
-        {
-            JSString *p;
-            p = JS_VALUE_GET_STRING(val);
-            JS_DumpString(rt, p);
-        }
-        break;
-    case JS_TAG_FUNCTION_BYTECODE:
-        {
-            JSFunctionBytecode *b = JS_VALUE_GET_PTR(val);
-            char buf[ATOM_GET_STR_BUF_SIZE];
-            printf("[bytecode %s]", JS_AtomGetStrRT(rt, buf, sizeof(buf), b->func_name));
-        }
-        break;
-    case JS_TAG_OBJECT:
-        {
-            JSObject *p = JS_VALUE_GET_OBJ(val);
-            JSAtom atom = rt->class_array[p->class_id].class_name;
-            char atom_buf[ATOM_GET_STR_BUF_SIZE];
-            printf("[%s %p]",
-                   JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), atom), (void *)p);
-        }
-        break;
-    case JS_TAG_SYMBOL:
         {
-            JSAtomStruct *p = JS_VALUE_GET_PTR(val);
-            char atom_buf[ATOM_GET_STR_BUF_SIZE];
-            printf("Symbol(%s)",
-                   JS_AtomGetStrRT(rt, atom_buf, sizeof(atom_buf), js_get_atom_index(rt, p)));
+            double d = JS_VALUE_GET_FLOAT64(val);
+            if (isnan(d)) {
+                *pres = 0;
+            } else {
+                if (d < INT64_MIN)
+                    *pres = INT64_MIN;
+                else if (d >= 0x1p63) /* must use INT64_MAX + 1 because INT64_MAX cannot be exactly represented as a double */
+                    *pres = INT64_MAX;
+                else
+                    *pres = (int64_t)d;
+            }
         }
-        break;
-    case JS_TAG_MODULE:
-        printf("[module]");
-        break;
+        return 0;
     default:
-        printf("[unknown tag %d]", tag);
-        break;
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val)) {
+            *pres = 0;
+            return -1;
+        }
+        goto redo;
     }
 }
 
-static __maybe_unused void JS_DumpValue(JSContext *ctx,
-                                                 JSValueConst val)
-{
-    JS_DumpValueShort(ctx->rt, val);
-}
-
-static __maybe_unused void JS_PrintValue(JSContext *ctx,
-                                                  const char *str,
-                                                  JSValueConst val)
+int JS_ToInt64Sat(JSContext *ctx, int64_t *pres, JSValueConst val)
 {
-    printf("%s=", str);
-    JS_DumpValueShort(ctx->rt, val);
-    printf("\n");
+    return JS_ToInt64SatFree(ctx, pres, JS_DupValue(ctx, val));
 }
 
-/* return -1 if exception (proxy case) or TRUE/FALSE */
-int JS_IsArray(JSContext *ctx, JSValueConst val)
+int JS_ToInt64Clamp(JSContext *ctx, int64_t *pres, JSValueConst val,
+                    int64_t min, int64_t max, int64_t neg_offset)
 {
-    JSObject *p;
-    if (JS_VALUE_GET_TAG(val) == JS_TAG_OBJECT) {
-        p = JS_VALUE_GET_OBJ(val);
-        if (unlikely(p->class_id == JS_CLASS_PROXY))
-            return js_proxy_isArray(ctx, val);
-        else
-            return p->class_id == JS_CLASS_ARRAY;
-    } else {
-        return FALSE;
+    int res = JS_ToInt64SatFree(ctx, pres, JS_DupValue(ctx, val));
+    if (res == 0) {
+        if (*pres < 0)
+            *pres += neg_offset;
+        if (*pres < min)
+            *pres = min;
+        else if (*pres > max)
+            *pres = max;
     }
+    return res;
 }
 
-static double js_pow(double a, double b)
+/* Same as JS_ToInt32Free() but with a 64 bit result. Return (<0, 0)
+   in case of exception */
+static int JS_ToInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
 {
-    if (unlikely(!isfinite(b)) && fabs(a) == 1) {
-        /* not compatible with IEEE 754 */
-        return JS_FLOAT64_NAN;
-    } else {
-        return pow(a, b);
+    uint32_t tag;
+    int64_t ret;
+
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_BOOL:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+        ret = JS_VALUE_GET_INT(val);
+        break;
+    case JS_TAG_FLOAT64:
+        {
+            JSFloat64Union u;
+            double d;
+            int e;
+            d = JS_VALUE_GET_FLOAT64(val);
+            u.d = d;
+            /* we avoid doing fmod(x, 2^64) */
+            e = (u.u64 >> 52) & 0x7ff;
+            if (likely(e <= (1023 + 62))) {
+                /* fast case */
+                ret = (int64_t)d;
+            } else if (e <= (1023 + 62 + 53)) {
+                uint64_t v;
+                /* remainder modulo 2^64 */
+                v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
+                ret = v << ((e - 1023) - 52);
+                /* take the sign into account */
+                if (u.u64 >> 63)
+                    ret = -ret;
+            } else {
+                ret = 0; /* also handles NaN and +inf */
+            }
+        }
+        break;
+    default:
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val)) {
+            *pres = 0;
+            return -1;
+        }
+        goto redo;
     }
+    *pres = ret;
+    return 0;
 }
 
-JSValue JS_NewBigInt64_1(JSContext *ctx, int64_t v)
+int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
 {
-    JSValue val;
-    bf_t *a;
-    val = JS_NewBigInt(ctx);
-    if (JS_IsException(val))
-        return val;
-    a = JS_GetBigInt(val);
-    if (bf_set_si(a, v)) {
-        JS_FreeValue(ctx, val);
-        return JS_ThrowOutOfMemory(ctx);
-    }
-    return val;
+    return JS_ToInt64Free(ctx, pres, JS_DupValue(ctx, val));
 }
 
-JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
+int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val)
 {
-    if (is_math_mode(ctx) &&
-        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
-        return JS_NewInt64(ctx, v);
-    } else {
-        return JS_NewBigInt64_1(ctx, v);
-    }
+    if (JS_IsBigInt(ctx, val))
+        return JS_ToBigInt64(ctx, pres, val);
+    else
+        return JS_ToInt64(ctx, pres, val);
 }
 
-JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
+/* return (<0, 0) in case of exception */
+static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
 {
-    JSValue val;
-    if (is_math_mode(ctx) && v <= MAX_SAFE_INTEGER) {
-        val = JS_NewInt64(ctx, v);
-    } else {
-        bf_t *a;
-        val = JS_NewBigInt(ctx);
-        if (JS_IsException(val))
-            return val;
-        a = JS_GetBigInt(val);
-        if (bf_set_ui(a, v)) {
-            JS_FreeValue(ctx, val);
-            return JS_ThrowOutOfMemory(ctx);
+    uint32_t tag;
+    int32_t ret;
+
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_BOOL:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+        ret = JS_VALUE_GET_INT(val);
+        break;
+    case JS_TAG_FLOAT64:
+        {
+            JSFloat64Union u;
+            double d;
+            int e;
+            d = JS_VALUE_GET_FLOAT64(val);
+            u.d = d;
+            /* we avoid doing fmod(x, 2^32) */
+            e = (u.u64 >> 52) & 0x7ff;
+            if (likely(e <= (1023 + 30))) {
+                /* fast case */
+                ret = (int32_t)d;
+            } else if (e <= (1023 + 30 + 53)) {
+                uint64_t v;
+                /* remainder modulo 2^32 */
+                v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
+                v = v << ((e - 1023) - 52 + 32);
+                ret = v >> 32;
+                /* take the sign into account */
+                if (u.u64 >> 63)
+                    ret = -ret;
+            } else {
+                ret = 0; /* also handles NaN and +inf */
+            }
+        }
+        break;
+    default:
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val)) {
+            *pres = 0;
+            return -1;
         }
+        goto redo;
     }
-    return val;
+    *pres = ret;
+    return 0;
 }
 
-/* return NaN if bad bigint literal */
-static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
+int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val)
 {
-    const char *str, *p;
-    size_t len;
-    int flags;
-    
-    str = JS_ToCStringLen(ctx, &len, val);
-    JS_FreeValue(ctx, val);
-    if (!str)
-        return JS_EXCEPTION;
-    p = str;
-    p += skip_spaces(p);
-    if ((p - str) == len) {
-        val = JS_NewBigInt64(ctx, 0);
-    } else {
-        flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
-#ifdef CONFIG_BIGNUM
-        if (is_math_mode(ctx))
-            flags |= ATOD_MODE_BIGINT;
-#endif        
-        val = js_atof(ctx, p, &p, 0, flags);
-        p += skip_spaces(p);
-        if (!JS_IsException(val)) {
-            if ((p - str) != len) {
-                JS_FreeValue(ctx, val);
-                val = JS_NAN;
-            }
-        }
-    }
-    JS_FreeCString(ctx, str);
-    return val;
+    return JS_ToInt32Free(ctx, pres, JS_DupValue(ctx, val));
 }
 
-static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
+static inline int JS_ToUint32Free(JSContext *ctx, uint32_t *pres, JSValue val)
 {
-    val = JS_StringToBigInt(ctx, val);
-    if (JS_VALUE_IS_NAN(val))
-        return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
-    return val;
+    return JS_ToInt32Free(ctx, (int32_t *)pres, val);
 }
 
-/* if the returned bigfloat is allocated it is equal to
-   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. */
-static bf_t *JS_ToBigIntFree(JSContext *ctx, bf_t *buf, JSValue val)
+static int JS_ToUint8ClampFree(JSContext *ctx, int32_t *pres, JSValue val)
 {
     uint32_t tag;
-    bf_t *r;
-    JSBigFloat *p;
+    int res;
 
  redo:
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
     case JS_TAG_INT:
+    case JS_TAG_BOOL:
     case JS_TAG_NULL:
     case JS_TAG_UNDEFINED:
-        if (!is_math_mode(ctx))
-            goto fail;
-        /* fall tru */
-    case JS_TAG_BOOL:
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        bf_set_si(r, JS_VALUE_GET_INT(val));
+        res = JS_VALUE_GET_INT(val);
+        res = max_int(0, min_int(255, res));
         break;
     case JS_TAG_FLOAT64:
         {
             double d = JS_VALUE_GET_FLOAT64(val);
-            if (!is_math_mode(ctx))
-                goto fail;
-            if (!isfinite(d))
-                goto fail;
-            r = buf;
-            bf_init(ctx->bf_ctx, r);
-            d = trunc(d);
-            bf_set_float64(r, d);
+            if (isnan(d)) {
+                res = 0;
+            } else {
+                if (d < 0)
+                    res = 0;
+                else if (d > 255)
+                    res = 255;
+                else
+                    res = lrint(d);
+            }
         }
         break;
-    case JS_TAG_BIG_INT:
-        p = JS_VALUE_GET_PTR(val);
-        r = &p->num;
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        if (!is_math_mode(ctx))
-            goto fail;
-        p = JS_VALUE_GET_PTR(val);
-        if (!bf_is_finite(&p->num))
-            goto fail;
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        bf_set(r, &p->num);
-        bf_rint(r, BF_RNDZ);
-        JS_FreeValue(ctx, val);
-        break;
-#endif        
-    case JS_TAG_STRING:
-        val = JS_StringToBigIntErr(ctx, val);
-        if (JS_IsException(val))
-            return NULL;
-        goto redo;
-    case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
-        if (JS_IsException(val))
-            return NULL;
-        goto redo;
     default:
-    fail:
-        JS_FreeValue(ctx, val);
-        JS_ThrowTypeError(ctx, "cannot convert to bigint");
-        return NULL;
+        val = JS_ToNumberFree(ctx, val);
+        if (JS_IsException(val)) {
+            *pres = 0;
+            return -1;
+        }
+        goto redo;
     }
-    return r;
-}
-
-static bf_t *JS_ToBigInt(JSContext *ctx, bf_t *buf, JSValueConst val)
-{
-    return JS_ToBigIntFree(ctx, buf, JS_DupValue(ctx, val));
+    *pres = res;
+    return 0;
 }
 
-static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
+static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
+                                            JSValue val, BOOL is_array_ctor)
 {
-    if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_INT) {
-        return val;
-    } else {
-        bf_t a_s, *a, *r;
-        int ret;
-        JSValue res; 
+    uint32_t tag, len;
 
-        res = JS_NewBigInt(ctx);
-        if (JS_IsException(res))
-            return JS_EXCEPTION;
-        a = JS_ToBigIntFree(ctx, &a_s, val);
-        if (!a) {
-            JS_FreeValue(ctx, res);
-            return JS_EXCEPTION;
+    tag = JS_VALUE_GET_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+    case JS_TAG_BOOL:
+    case JS_TAG_NULL:
+        {
+            int v;
+            v = JS_VALUE_GET_INT(val);
+            if (v < 0)
+                goto fail;
+            len = v;
         }
-        r = JS_GetBigInt(res);
-        ret = bf_set(r, a);
-        JS_FreeBigInt(ctx, a, &a_s);
-        if (ret) {
-            JS_FreeValue(ctx, res);
-            return JS_ThrowOutOfMemory(ctx);
+        break;
+    default:
+        if (JS_TAG_IS_FLOAT64(tag)) {
+            double d;
+            d = JS_VALUE_GET_FLOAT64(val);
+            if (!(d >= 0 && d <= UINT32_MAX))
+                goto fail;
+            len = (uint32_t)d;
+            if (len != d)
+                goto fail;
+        } else {
+            uint32_t len1;
+
+            if (is_array_ctor) {
+                val = JS_ToNumberFree(ctx, val);
+                if (JS_IsException(val))
+                    return -1;
+                /* cannot recurse because val is a number */
+                if (JS_ToArrayLengthFree(ctx, &len, val, TRUE))
+                    return -1;
+            } else {
+                /* legacy behavior: must do the conversion twice and compare */
+                if (JS_ToUint32(ctx, &len, val)) {
+                    JS_FreeValue(ctx, val);
+                    return -1;
+                }
+                val = JS_ToNumberFree(ctx, val);
+                if (JS_IsException(val))
+                    return -1;
+                /* cannot recurse because val is a number */
+                if (JS_ToArrayLengthFree(ctx, &len1, val, FALSE))
+                    return -1;
+                if (len1 != len) {
+                fail:
+                    JS_ThrowRangeError(ctx, "invalid array length");
+                    return -1;
+                }
+            }
         }
-        return JS_CompactBigInt(ctx, res);
+        break;
     }
+    *plen = len;
+    return 0;
 }
 
-/* free the bf_t allocated by JS_ToBigInt */
-static void JS_FreeBigInt(JSContext *ctx, bf_t *a, bf_t *buf)
+#define MAX_SAFE_INTEGER (((int64_t)1 << 53) - 1)
+
+static BOOL is_safe_integer(double d)
 {
-    if (a == buf) {
-        bf_delete(a);
-    } else {
-        JSBigFloat *p = (JSBigFloat *)((uint8_t *)a -
-                                       offsetof(JSBigFloat, num));
-        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_BIG_INT, p));
-    }
+    return isfinite(d) && floor(d) == d &&
+        fabs(d) <= (double)MAX_SAFE_INTEGER;
 }
 
-/* XXX: merge with JS_ToInt64Free with a specific flag */
-static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
+int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val)
 {
-    bf_t a_s, *a;
-
-    a = JS_ToBigIntFree(ctx, &a_s, val);
-    if (!a) {
-        *pres = 0;
+    int64_t v;
+    if (JS_ToInt64Sat(ctx, &v, val))
+        return -1;
+    if (v < 0 || v > MAX_SAFE_INTEGER) {
+        JS_ThrowRangeError(ctx, "invalid array index");
+        *plen = 0;
         return -1;
     }
-    bf_get_int64(pres, a, BF_GET_INT_MOD);
-    JS_FreeBigInt(ctx, a, &a_s);
+    *plen = v;
     return 0;
 }
 
-int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
+/* convert a value to a length between 0 and MAX_SAFE_INTEGER.
+   return -1 for exception */
+static __exception int JS_ToLengthFree(JSContext *ctx, int64_t *plen,
+                                       JSValue val)
 {
-    return JS_ToBigInt64Free(ctx, pres, JS_DupValue(ctx, val));
+    int res = JS_ToInt64Clamp(ctx, plen, val, 0, MAX_SAFE_INTEGER, 0);
+    JS_FreeValue(ctx, val);
+    return res;
 }
 
-static JSBigFloat *js_new_bf(JSContext *ctx)
+/* Note: can return an exception */
+static int JS_NumberIsInteger(JSContext *ctx, JSValueConst val)
 {
-    JSBigFloat *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return NULL;
-    p->header.ref_count = 1;
-    bf_init(ctx->bf_ctx, &p->num);
-    return p;
+    double d;
+    if (!JS_IsNumber(val))
+        return FALSE;
+    if (unlikely(JS_ToFloat64(ctx, &d, val)))
+        return -1;
+    return isfinite(d) && floor(d) == d;
 }
 
-static JSValue JS_NewBigInt(JSContext *ctx)
+static BOOL JS_NumberIsNegativeOrMinusZero(JSContext *ctx, JSValueConst val)
 {
-    JSBigFloat *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return JS_EXCEPTION;
-    p->header.ref_count = 1;
-    bf_init(ctx->bf_ctx, &p->num);
-    return JS_MKPTR(JS_TAG_BIG_INT, p);
-}
+    uint32_t tag;
 
-static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
-                                 BOOL convert_to_safe_integer)
-{
-    int64_t v;
-    bf_t *a;
-    
-    if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
-        return val; /* fail safe */
-    a = JS_GetBigInt(val);
-    if (convert_to_safe_integer && bf_get_int64(&v, a, 0) == 0 &&
-        v >= -MAX_SAFE_INTEGER && v <= MAX_SAFE_INTEGER) {
-        JS_FreeValue(ctx, val);
-        return JS_NewInt64(ctx, v);
-    } else if (a->expn == BF_EXP_ZERO && a->sign) {
-        JSBigFloat *p = JS_VALUE_GET_PTR(val);
-        assert(p->header.ref_count == 1);
-        a->sign = 0;
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_INT:
+        {
+            int v;
+            v = JS_VALUE_GET_INT(val);
+            return (v < 0);
+        }
+    case JS_TAG_FLOAT64:
+        {
+            JSFloat64Union u;
+            u.d = JS_VALUE_GET_FLOAT64(val);
+            return (u.u64 >> 63);
+        }
+    case JS_TAG_SHORT_BIG_INT:
+        return (JS_VALUE_GET_SHORT_BIG_INT(val) < 0);
+    case JS_TAG_BIG_INT:
+        {
+            JSBigInt *p = JS_VALUE_GET_PTR(val);
+            return js_bigint_sign(p);
+        }
+    default:
+        return FALSE;
     }
-    return val;
 }
 
-/* Convert the big int to a safe integer if in math mode. normalize
-   the zero representation. Could also be used to convert the bigint
-   to a short bigint value. The reference count of the value must be
-   1. Cannot fail */
-static JSValue JS_CompactBigInt(JSContext *ctx, JSValue val)
+static JSValue js_bigint_to_string(JSContext *ctx, JSValueConst val)
 {
-    return JS_CompactBigInt1(ctx, val, is_math_mode(ctx));
+    return js_bigint_to_string1(ctx, val, 10);
 }
 
-static JSValue throw_bf_exception(JSContext *ctx, int status)
+static JSValue js_dtoa2(JSContext *ctx,
+                        double d, int radix, int n_digits, int flags)
 {
-    const char *str;
-    if (status & BF_ST_MEM_ERROR)
-        return JS_ThrowOutOfMemory(ctx);
-    if (status & BF_ST_DIVIDE_ZERO) {
-        str = "division by zero";
-    } else if (status & BF_ST_INVALID_OP) {
-        str = "invalid operation";
+    char static_buf[128], *buf, *tmp_buf;
+    int len, len_max;
+    JSValue res;
+    JSDTOATempMem dtoa_mem;
+    len_max = js_dtoa_max_len(d, radix, n_digits, flags);
+    
+    /* longer buffer may be used if radix != 10 */
+    if (len_max > sizeof(static_buf) - 1) {
+        tmp_buf = js_malloc(ctx, len_max + 1);
+        if (!tmp_buf)
+            return JS_EXCEPTION;
+        buf = tmp_buf;
     } else {
-        str = "integer overflow";
+        tmp_buf = NULL;
+        buf = static_buf;
     }
-    return JS_ThrowRangeError(ctx, "%s", str);
+    len = js_dtoa(buf, d, radix, n_digits, flags, &dtoa_mem);
+    res = js_new_string8_len(ctx, buf, len);
+    js_free(ctx, tmp_buf);
+    return res;
 }
 
-/* if the returned bigfloat is allocated it is equal to
-   'buf'. Otherwise it is a pointer to the bigfloat in 'val'. Return
-   NULL in case of error. */
-static bf_t *JS_ToBigFloat(JSContext *ctx, bf_t *buf, JSValueConst val)
+static JSValue JS_ToStringInternal(JSContext *ctx, JSValueConst val, BOOL is_ToPropertyKey)
 {
     uint32_t tag;
-    bf_t *r;
-    JSBigFloat *p;
+    char buf[32];
 
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
+    case JS_TAG_STRING:
+        return JS_DupValue(ctx, val);
+    case JS_TAG_STRING_ROPE:
+        return js_linearize_string_rope(ctx, JS_DupValue(ctx, val));
     case JS_TAG_INT:
+        {
+            size_t len;
+            len = i32toa(buf, JS_VALUE_GET_INT(val));
+            return js_new_string8_len(ctx, buf, len);
+        }
+        break;
     case JS_TAG_BOOL:
+        return JS_AtomToString(ctx, JS_VALUE_GET_BOOL(val) ?
+                          JS_ATOM_true : JS_ATOM_false);
     case JS_TAG_NULL:
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        if (bf_set_si(r, JS_VALUE_GET_INT(val)))
-            goto fail;
-        break;
-    case JS_TAG_FLOAT64:
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        if (bf_set_float64(r, JS_VALUE_GET_FLOAT64(val))) {
-        fail:
-            bf_delete(r);
-            return NULL;
+        return JS_AtomToString(ctx, JS_ATOM_null);
+    case JS_TAG_UNDEFINED:
+        return JS_AtomToString(ctx, JS_ATOM_undefined);
+    case JS_TAG_EXCEPTION:
+        return JS_EXCEPTION;
+    case JS_TAG_OBJECT:
+        {
+            JSValue val1, ret;
+            val1 = JS_ToPrimitive(ctx, val, HINT_STRING);
+            if (JS_IsException(val1))
+                return val1;
+            ret = JS_ToStringInternal(ctx, val1, is_ToPropertyKey);
+            JS_FreeValue(ctx, val1);
+            return ret;
         }
         break;
+    case JS_TAG_FUNCTION_BYTECODE:
+        return js_new_string8(ctx, "[function bytecode]");
+    case JS_TAG_SYMBOL:
+        if (is_ToPropertyKey) {
+            return JS_DupValue(ctx, val);
+        } else {
+            return JS_ThrowTypeError(ctx, "cannot convert symbol to string");
+        }
+    case JS_TAG_FLOAT64:
+        return js_dtoa2(ctx, JS_VALUE_GET_FLOAT64(val), 10, 0,
+                        JS_DTOA_FORMAT_FREE);
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif
-        p = JS_VALUE_GET_PTR(val);
-        r = &p->num;
-        break;
-    case JS_TAG_UNDEFINED:
+        return js_bigint_to_string(ctx, val);
     default:
-        r = buf;
-        bf_init(ctx->bf_ctx, r);
-        bf_set_nan(r);
-        break;
+        return js_new_string8(ctx, "[unsupported type]");
     }
-    return r;
 }
 
-#ifdef CONFIG_BIGNUM
-/* return NULL if invalid type */
-static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val)
+JSValue JS_ToString(JSContext *ctx, JSValueConst val)
 {
-    uint32_t tag;
-    JSBigDecimal *p;
-    bfdec_t *r;
-    
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_BIG_DECIMAL:
-        p = JS_VALUE_GET_PTR(val);
-        r = &p->num;
-        break;
-    default:
-        JS_ThrowTypeError(ctx, "bigdecimal expected");
-        r = NULL;
-        break;
-    }
-    return r;
+    return JS_ToStringInternal(ctx, val, FALSE);
 }
 
-static JSValue JS_NewBigFloat(JSContext *ctx)
+static JSValue JS_ToStringFree(JSContext *ctx, JSValue val)
 {
-    JSBigFloat *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return JS_EXCEPTION;
-    p->header.ref_count = 1;
-    bf_init(ctx->bf_ctx, &p->num);
-    return JS_MKPTR(JS_TAG_BIG_FLOAT, p);
+    JSValue ret;
+    ret = JS_ToString(ctx, val);
+    JS_FreeValue(ctx, val);
+    return ret;
 }
 
-static JSValue JS_NewBigDecimal(JSContext *ctx)
+static JSValue JS_ToLocaleStringFree(JSContext *ctx, JSValue val)
 {
-    JSBigDecimal *p;
-    p = js_malloc(ctx, sizeof(*p));
-    if (!p)
-        return JS_EXCEPTION;
-    p->header.ref_count = 1;
-    bfdec_init(ctx->bf_ctx, &p->num);
-    return JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
-}
-
-/* must be kept in sync with JSOverloadableOperatorEnum */
-/* XXX: use atoms ? */
-static const char js_overloadable_operator_names[JS_OVOP_COUNT][4] = {
-    "+",
-    "-",
-    "*",
-    "/",
-    "%",
-    "**",
-    "|",
-    "&",
-    "^",
-    "<<",
-    ">>",
-    ">>>",
-    "==",
-    "<",
-    "pos",
-    "neg",
-    "++",
-    "--",
-    "~",
-};
+    if (JS_IsUndefined(val) || JS_IsNull(val))
+        return JS_ToStringFree(ctx, val);
+    return JS_InvokeFree(ctx, val, JS_ATOM_toLocaleString, 0, NULL);
+}
 
-static int get_ovop_from_opcode(OPCodeEnum op)
+JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val)
 {
-    switch(op) {
-    case OP_add:
-        return JS_OVOP_ADD;
-    case OP_sub:
-        return JS_OVOP_SUB;
-    case OP_mul:
-        return JS_OVOP_MUL;
-    case OP_div:
-        return JS_OVOP_DIV;
-    case OP_mod:
-    case OP_math_mod:
-        return JS_OVOP_MOD;
-    case OP_pow:
-        return JS_OVOP_POW;
-    case OP_or:
-        return JS_OVOP_OR;
-    case OP_and:
-        return JS_OVOP_AND;
-    case OP_xor:
-        return JS_OVOP_XOR;
-    case OP_shl:
-        return JS_OVOP_SHL;
-    case OP_sar:
-        return JS_OVOP_SAR;
-    case OP_shr:
-        return JS_OVOP_SHR;
-    case OP_eq:
-    case OP_neq:
-        return JS_OVOP_EQ;
-    case OP_lt:
-    case OP_lte:
-    case OP_gt:
-    case OP_gte:
-        return JS_OVOP_LESS;
-    case OP_plus:
-        return JS_OVOP_POS;
-    case OP_neg:
-        return JS_OVOP_NEG;
-    case OP_inc:
-        return JS_OVOP_INC;
-    case OP_dec:
-        return JS_OVOP_DEC;
-    default:
-        abort();
-    }
+    return JS_ToStringInternal(ctx, val, TRUE);
+}
+
+static JSValue JS_ToStringCheckObject(JSContext *ctx, JSValueConst val)
+{
+    uint32_t tag = JS_VALUE_GET_TAG(val);
+    if (tag == JS_TAG_NULL || tag == JS_TAG_UNDEFINED)
+        return JS_ThrowTypeError(ctx, "null or undefined are forbidden");
+    return JS_ToString(ctx, val);
 }
 
-/* return NULL if not present */
-static JSObject *find_binary_op(JSBinaryOperatorDef *def,
-                                uint32_t operator_index,
-                                JSOverloadableOperatorEnum op)
+static JSValue JS_ToQuotedString(JSContext *ctx, JSValueConst val1)
 {
-    JSBinaryOperatorDefEntry *ent;
+    JSValue val;
+    JSString *p;
     int i;
-    for(i = 0; i < def->count; i++) {
-        ent = &def->tab[i];
-        if (ent->operator_index == operator_index)
-            return ent->ops[op];
+    uint32_t c;
+    StringBuffer b_s, *b = &b_s;
+    char buf[16];
+
+    val = JS_ToStringCheckObject(ctx, val1);
+    if (JS_IsException(val))
+        return val;
+    p = JS_VALUE_GET_STRING(val);
+
+    if (string_buffer_init(ctx, b, p->len + 2))
+        goto fail;
+
+    if (string_buffer_putc8(b, '\"'))
+        goto fail;
+    for(i = 0; i < p->len; ) {
+        c = string_getc(p, &i);
+        switch(c) {
+        case '\t':
+            c = 't';
+            goto quote;
+        case '\r':
+            c = 'r';
+            goto quote;
+        case '\n':
+            c = 'n';
+            goto quote;
+        case '\b':
+            c = 'b';
+            goto quote;
+        case '\f':
+            c = 'f';
+            goto quote;
+        case '\"':
+        case '\\':
+        quote:
+            if (string_buffer_putc8(b, '\\'))
+                goto fail;
+            if (string_buffer_putc8(b, c))
+                goto fail;
+            break;
+        default:
+            if (c < 32 || is_surrogate(c)) {
+                snprintf(buf, sizeof(buf), "\\u%04x", c);
+                if (string_buffer_puts8(b, buf))
+                    goto fail;
+            } else {
+                if (string_buffer_putc(b, c))
+                    goto fail;
+            }
+            break;
+        }
     }
-    return NULL;
+    if (string_buffer_putc8(b, '\"'))
+        goto fail;
+    JS_FreeValue(ctx, val);
+    return string_buffer_end(b);
+ fail:
+    JS_FreeValue(ctx, val);
+    string_buffer_free(b);
+    return JS_EXCEPTION;
+}
+
+#define JS_PRINT_MAX_DEPTH 8
+
+typedef struct {
+    JSRuntime *rt;
+    JSContext *ctx; /* may be NULL */
+    JSPrintValueOptions options;
+    JSPrintValueWrite *write_func;
+    void *write_opaque;
+    int level;
+    JSObject *print_stack[JS_PRINT_MAX_DEPTH]; /* level values */
+} JSPrintValueState;
+
+static void js_print_value(JSPrintValueState *s, JSValueConst val);
+
+static void js_putc(JSPrintValueState *s, char c)
+{
+    s->write_func(s->write_opaque, &c, 1);
 }
 
-/* return -1 if exception, 0 if no operator overloading, 1 if
-   overloaded operator called */
-static __exception int js_call_binary_op_fallback(JSContext *ctx,
-                                                  JSValue *pret,
-                                                  JSValueConst op1,
-                                                  JSValueConst op2,
-                                                  OPCodeEnum op,
-                                                  BOOL is_numeric,
-                                                  int hint)
+static void js_puts(JSPrintValueState *s, const char *str)
 {
-    JSValue opset1_obj, opset2_obj, method, ret, new_op1, new_op2;
-    JSOperatorSetData *opset1, *opset2;
-    JSOverloadableOperatorEnum ovop;
-    JSObject *p;
-    JSValueConst args[2];
-    
-    if (!ctx->allow_operator_overloading)
-        return 0;
+    s->write_func(s->write_opaque, str, strlen(str));
+}
+
+static void __attribute__((format(printf, 2, 3))) js_printf(JSPrintValueState *s, const char *fmt, ...)
+{
+    va_list ap;
+    char buf[256];
     
-    opset2_obj = JS_UNDEFINED;
-    opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
-    if (JS_IsException(opset1_obj))
-        goto exception;
-    if (JS_IsUndefined(opset1_obj))
-        return 0;
-    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
-    if (!opset1)
-        goto exception;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    s->write_func(s->write_opaque, buf, strlen(buf));
+}
 
-    opset2_obj = JS_GetProperty(ctx, op2, JS_ATOM_Symbol_operatorSet);
-    if (JS_IsException(opset2_obj))
-        goto exception;
-    if (JS_IsUndefined(opset2_obj)) {
-        JS_FreeValue(ctx, opset1_obj);
-        return 0;
-    }
-    opset2 = JS_GetOpaque2(ctx, opset2_obj, JS_CLASS_OPERATOR_SET);
-    if (!opset2)
-        goto exception;
+static void js_print_float64(JSPrintValueState *s, double d)
+{
+    JSDTOATempMem dtoa_mem;
+    char buf[32];
+    int len;
+    len = js_dtoa(buf, d, 10, 0, JS_DTOA_FORMAT_FREE | JS_DTOA_MINUS_ZERO, &dtoa_mem);
+    s->write_func(s->write_opaque, buf, len);
+}
 
-    if (opset1->is_primitive && opset2->is_primitive) {
-        JS_FreeValue(ctx, opset1_obj);
-        JS_FreeValue(ctx, opset2_obj);
+static uint32_t js_string_get_length(JSValueConst val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        return p->len;
+    } else if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING_ROPE) {
+        JSStringRope *r = JS_VALUE_GET_PTR(val);
+        return r->len;
+    } else {
         return 0;
     }
+}
 
-    ovop = get_ovop_from_opcode(op);
-    
-    if (opset1->operator_counter == opset2->operator_counter) {
-        p = opset1->self_ops[ovop];
-    } else if (opset1->operator_counter > opset2->operator_counter) {
-        p = find_binary_op(&opset1->left, opset2->operator_counter, ovop);
+static void js_dump_char(JSPrintValueState *s, int c, int sep)
+{
+    if (c == sep || c == '\\') {
+        js_putc(s, '\\');
+        js_putc(s, c);
+    } else if (c >= ' ' && c <= 126) {
+        js_putc(s, c);
+    } else if (c == '\n') {
+        js_putc(s, '\\');
+        js_putc(s, 'n');
     } else {
-        p = find_binary_op(&opset2->right, opset1->operator_counter, ovop);
-    }
-    if (!p) {
-        JS_ThrowTypeError(ctx, "operator %s: no function defined",
-                          js_overloadable_operator_names[ovop]);
-        goto exception;
+        js_printf(s, "\\u%04x", c);
     }
+}
 
-    if (opset1->is_primitive) {
-        if (is_numeric) {
-            new_op1 = JS_ToNumeric(ctx, op1);
-        } else {
-            new_op1 = JS_ToPrimitive(ctx, op1, hint);
-        }
-        if (JS_IsException(new_op1))
-            goto exception;
-    } else {
-        new_op1 = JS_DupValue(ctx, op1);
-    }
-    
-    if (opset2->is_primitive) {
-        if (is_numeric) {
-            new_op2 = JS_ToNumeric(ctx, op2);
-        } else {
-            new_op2 = JS_ToPrimitive(ctx, op2, hint);
-        }
-        if (JS_IsException(new_op2)) {
-            JS_FreeValue(ctx, new_op1);
-            goto exception;
+static void js_print_string_rec(JSPrintValueState *s, JSValueConst val,
+                                int sep, uint32_t pos)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        uint32_t i, len;
+        if (pos < s->options.max_string_length) {
+            len = min_uint32(p->len, s->options.max_string_length - pos);
+            for(i = 0; i < len; i++) {
+                js_dump_char(s, string_get(p, i), sep);
+            }
         }
+    } else if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING_ROPE) {
+        JSStringRope *r = JS_VALUE_GET_PTR(val);
+        js_print_string_rec(s, r->left, sep, pos);
+        js_print_string_rec(s, r->right, sep, pos + js_string_get_length(r->left));
     } else {
-        new_op2 = JS_DupValue(ctx, op2);
+        js_printf(s, "<invalid string tag %d>", (int)JS_VALUE_GET_TAG(val));
     }
+}
 
-    /* XXX: could apply JS_ToPrimitive() if primitive type so that the
-       operator function does not get a value object */
-    
-    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
-    if (ovop == JS_OVOP_LESS && (op == OP_lte || op == OP_gt)) {
-        args[0] = new_op2;
-        args[1] = new_op1;
+static void js_print_string(JSPrintValueState *s, JSValueConst val)
+{
+    int sep;
+    if (s->options.raw_dump && JS_VALUE_GET_TAG(val) == JS_TAG_STRING) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        js_printf(s, "%d", p->header.ref_count);
+        sep = (p->header.ref_count == 1) ? '\"' : '\'';
     } else {
-        args[0] = new_op1;
-        args[1] = new_op2;
+        sep = '\"';
     }
-    ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
-    JS_FreeValue(ctx, new_op1);
-    JS_FreeValue(ctx, new_op2);
-    if (JS_IsException(ret))
-        goto exception;
-    if (ovop == JS_OVOP_EQ) {
-        BOOL res = JS_ToBoolFree(ctx, ret);
-        if (op == OP_neq)
-            res ^= 1;
-        ret = JS_NewBool(ctx, res);
-    } else if (ovop == JS_OVOP_LESS) {
-        if (JS_IsUndefined(ret)) {
-            ret = JS_FALSE;
-        } else {
-            BOOL res = JS_ToBoolFree(ctx, ret);
-            if (op == OP_lte || op == OP_gte)
-                res ^= 1;
-            ret = JS_NewBool(ctx, res);
-        }
+    js_putc(s, sep);
+    js_print_string_rec(s, val, sep, 0);
+    js_putc(s, sep);
+    if (js_string_get_length(val) > s->options.max_string_length) {
+        uint32_t n = js_string_get_length(val) - s->options.max_string_length;
+        js_printf(s, "... %u more character%s", n, n > 1 ? "s" : "");
     }
-    JS_FreeValue(ctx, opset1_obj);
-    JS_FreeValue(ctx, opset2_obj);
-    *pret = ret;
-    return 1;
- exception:
-    JS_FreeValue(ctx, opset1_obj);
-    JS_FreeValue(ctx, opset2_obj);
-    *pret = JS_UNDEFINED;
-    return -1;
 }
 
-/* try to call the operation on the operatorSet field of 'obj'. Only
-   used for "/" and "**" on the BigInt prototype in math mode */
-static __exception int js_call_binary_op_simple(JSContext *ctx,
-                                                JSValue *pret,
-                                                JSValueConst obj,
-                                                JSValueConst op1,
-                                                JSValueConst op2,
-                                                OPCodeEnum op)
+static void js_print_raw_string2(JSPrintValueState *s, JSValueConst val, BOOL remove_last_lf)
 {
-    JSValue opset1_obj, method, ret, new_op1, new_op2;
-    JSOperatorSetData *opset1;
-    JSOverloadableOperatorEnum ovop;
-    JSObject *p;
-    JSValueConst args[2];
-
-    opset1_obj = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
-    if (JS_IsException(opset1_obj))
-        goto exception;
-    if (JS_IsUndefined(opset1_obj))
-        return 0;
-    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
-    if (!opset1)
-        goto exception;
-    ovop = get_ovop_from_opcode(op);
-
-    p = opset1->self_ops[ovop];
-    if (!p) {
-        JS_FreeValue(ctx, opset1_obj);
-        return 0;
-    }
-
-    new_op1 = JS_ToNumeric(ctx, op1);
-    if (JS_IsException(new_op1))
-        goto exception;
-    new_op2 = JS_ToNumeric(ctx, op2);
-    if (JS_IsException(new_op2)) {
-        JS_FreeValue(ctx, new_op1);
-        goto exception;
+    const char *cstr;
+    size_t len;
+    cstr = JS_ToCStringLen(s->ctx, &len, val);
+    if (cstr) {
+        if (remove_last_lf && len > 0 && cstr[len - 1] == '\n')
+            len--;
+        s->write_func(s->write_opaque, cstr, len);
+        JS_FreeCString(s->ctx, cstr);
     }
+}
 
-    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
-    args[0] = new_op1;
-    args[1] = new_op2;
-    ret = JS_CallFree(ctx, method, JS_UNDEFINED, 2, args);
-    JS_FreeValue(ctx, new_op1);
-    JS_FreeValue(ctx, new_op2);
-    if (JS_IsException(ret))
-        goto exception;
-    JS_FreeValue(ctx, opset1_obj);
-    *pret = ret;
-    return 1;
- exception:
-    JS_FreeValue(ctx, opset1_obj);
-    *pret = JS_UNDEFINED;
-    return -1;
+static void js_print_raw_string(JSPrintValueState *s, JSValueConst val)
+{
+    js_print_raw_string2(s, val, FALSE);
 }
 
-/* return -1 if exception, 0 if no operator overloading, 1 if
-   overloaded operator called */
-static __exception int js_call_unary_op_fallback(JSContext *ctx,
-                                                 JSValue *pret,
-                                                 JSValueConst op1,
-                                                 OPCodeEnum op)
+static BOOL is_ascii_ident(const JSString *p)
 {
-    JSValue opset1_obj, method, ret;
-    JSOperatorSetData *opset1;
-    JSOverloadableOperatorEnum ovop;
-    JSObject *p;
+    int i, c;
 
-    if (!ctx->allow_operator_overloading)
-        return 0;
-    
-    opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
-    if (JS_IsException(opset1_obj))
-        goto exception;
-    if (JS_IsUndefined(opset1_obj))
-        return 0;
-    opset1 = JS_GetOpaque2(ctx, opset1_obj, JS_CLASS_OPERATOR_SET);
-    if (!opset1)
-        goto exception;
-    if (opset1->is_primitive) {
-        JS_FreeValue(ctx, opset1_obj);
-        return 0;
+    if (p->len == 0)
+        return FALSE;
+    for(i = 0; i < p->len; i++) {
+        c = string_get(p, i);
+        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+              (c == '_' || c == '$') || (c >= '0' && c <= '9' && i > 0)))
+            return FALSE;
     }
+    return TRUE;
+}
 
-    ovop = get_ovop_from_opcode(op);
-
-    p = opset1->self_ops[ovop];
-    if (!p) {
-        JS_ThrowTypeError(ctx, "no overloaded operator %s",
-                          js_overloadable_operator_names[ovop]);
-        goto exception;
+static void js_print_atom(JSPrintValueState *s, JSAtom atom)
+{
+    int i;
+    if (__JS_AtomIsTaggedInt(atom)) {
+        js_printf(s, "%u", __JS_AtomToUInt32(atom));
+    } else if (atom == JS_ATOM_NULL) {
+        js_puts(s, "<null>");
+    } else {
+        assert(atom < s->rt->atom_size);
+        JSString *p;
+        p = s->rt->atom_array[atom];
+        if (is_ascii_ident(p)) {
+            for(i = 0; i < p->len; i++) {
+                js_putc(s, string_get(p, i));
+            }
+        } else {
+            js_putc(s, '"');
+            for(i = 0; i < p->len; i++) {
+                js_dump_char(s, string_get(p, i), '\"');
+            }
+            js_putc(s, '"');
+        }
     }
-    method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
-    ret = JS_CallFree(ctx, method, JS_UNDEFINED, 1, &op1);
-    if (JS_IsException(ret))
-        goto exception;
-    JS_FreeValue(ctx, opset1_obj);
-    *pret = ret;
-    return 1;
- exception:
-    JS_FreeValue(ctx, opset1_obj);
-    *pret = JS_UNDEFINED;
-    return -1;
 }
 
-static int js_unary_arith_bigfloat(JSContext *ctx,
-                                   JSValue *pres, OPCodeEnum op, JSValue op1)
+/* return 0 if invalid length */
+static uint32_t js_print_array_get_length(JSObject *p)
 {
-    bf_t a_s, *r, *a;
-    int ret, v;
-    JSValue res;
-    
-    if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
+    JSProperty *pr;
+    JSShapeProperty *prs;
+    JSValueConst val;
 
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res)) {
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    r = JS_GetBigFloat(res);
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    ret = 0;
-    switch(op) {
-    case OP_inc:
-    case OP_dec:
-        v = 2 * (op - OP_dec) - 1;
-        ret = bf_add_si(r, a, v, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_plus:
-        ret = bf_set(r, a);
-        break;
-    case OP_neg:
-        ret = bf_set(r, a);
-        bf_neg(r);
-        break;
+    prs = find_own_property(&pr, p, JS_ATOM_length);
+    if (!prs)
+        return 0;
+    if ((prs->flags & JS_PROP_TMASK) != JS_PROP_NORMAL)
+        return 0;
+    val = pr->u.value;
+    switch(JS_VALUE_GET_NORM_TAG(val)) {
+    case JS_TAG_INT:
+        return JS_VALUE_GET_INT(val);
+    case JS_TAG_FLOAT64:
+        return (uint32_t)JS_VALUE_GET_FLOAT64(val);
     default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    JS_FreeValue(ctx, op1);
-    if (unlikely(ret & BF_ST_MEM_ERROR)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
+        return 0;
     }
-    *pres = res;
-    return 0;
 }
 
-static int js_unary_arith_bigdecimal(JSContext *ctx,
-                                     JSValue *pres, OPCodeEnum op, JSValue op1)
+static void js_print_comma(JSPrintValueState *s, int *pcomma_state)
 {
-    bfdec_t *r, *a;
-    int ret, v;
-    JSValue res;
-    
-    if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-
-    res = JS_NewBigDecimal(ctx);
-    if (JS_IsException(res)) {
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    r = JS_GetBigDecimal(res);
-    a = JS_ToBigDecimal(ctx, op1);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    ret = 0;
-    switch(op) {
-    case OP_inc:
-    case OP_dec:
-        v = 2 * (op - OP_dec) - 1;
-        ret = bfdec_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+    switch(*pcomma_state) {
+    case 0:
         break;
-    case OP_plus:
-        ret = bfdec_set(r, a);
+    case 1:
+        js_printf(s, ", ");
         break;
-    case OP_neg:
-        ret = bfdec_set(r, a);
-        bfdec_neg(r);
+    case 2:
+        js_printf(s, " { ");
         break;
-    default:
-        abort();
-    }
-    JS_FreeValue(ctx, op1);
-    if (unlikely(ret)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
     }
-    *pres = res;
-    return 0;
+    *pcomma_state = 1;
 }
 
-#endif /* CONFIG_BIGNUM */
+static void js_print_more_items(JSPrintValueState *s, int *pcomma_state,
+                                uint32_t n)
+{
+    js_print_comma(s, pcomma_state);
+    js_printf(s, "... %u more item%s", n, n > 1 ? "s" : "");
+}
 
-static int js_unary_arith_bigint(JSContext *ctx,
-                                 JSValue *pres, OPCodeEnum op, JSValue op1)
+static void js_print_object(JSPrintValueState *s, JSObject *p)
 {
-    bf_t a_s, *r, *a;
-    int ret, v;
-    JSValue res;
+    JSRuntime *rt = s->rt;
+    JSShape *sh;
+    JSShapeProperty *prs;
+    JSProperty *pr;
+    int comma_state;
+    BOOL is_array;
+    uint32_t i;
     
-    if (op == OP_plus && !is_math_mode(ctx)) {
-        JS_ThrowTypeError(ctx, "bigint argument with unary +");
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    res = JS_NewBigInt(ctx);
-    if (JS_IsException(res)) {
-        JS_FreeValue(ctx, op1);
-        return -1;
+    comma_state = 0;
+    is_array = FALSE;
+    if (p->class_id == JS_CLASS_ARRAY) {
+        is_array = TRUE;
+        js_printf(s, "[ ");
+        /* XXX: print array like properties even if not fast array */
+        if (p->fast_array) {
+            uint32_t len, n, len1;
+            len = js_print_array_get_length(p);
+
+            len1 = min_uint32(p->u.array.count, s->options.max_item_count);
+            for(i = 0; i < len1; i++) {
+                js_print_comma(s, &comma_state);
+                js_print_value(s, p->u.array.u.values[i]);
+            }
+            if (len1 < p->u.array.count)
+                js_print_more_items(s, &comma_state, p->u.array.count - len1);
+            if (p->u.array.count < len) {
+                n = len - p->u.array.count;
+                js_print_comma(s, &comma_state);
+                js_printf(s, "<%u empty item%s>", n, n > 1 ? "s" : "");
+            }
+        }
+    } else if (p->class_id >= JS_CLASS_UINT8C_ARRAY && p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
+        uint32_t size = 1 << typed_array_size_log2(p->class_id);
+        uint32_t len1;
+        int64_t v;
+
+        js_print_atom(s, rt->class_array[p->class_id].class_name);
+        js_printf(s, "(%u) [ ", p->u.array.count);
+        
+        is_array = TRUE;
+        len1 = min_uint32(p->u.array.count, s->options.max_item_count);
+        for(i = 0; i < len1; i++) {
+            const uint8_t *ptr = p->u.array.u.uint8_ptr + i * size;
+            js_print_comma(s, &comma_state);
+            switch(p->class_id) {
+            case JS_CLASS_UINT8C_ARRAY:
+            case JS_CLASS_UINT8_ARRAY:
+                v = *ptr;
+                goto ta_int64;
+            case JS_CLASS_INT8_ARRAY:
+                v = *(int8_t *)ptr;
+                goto ta_int64;
+            case JS_CLASS_INT16_ARRAY:
+                v = *(int16_t *)ptr;
+                goto ta_int64;
+            case JS_CLASS_UINT16_ARRAY:
+                v = *(uint16_t *)ptr;
+                goto ta_int64;
+            case JS_CLASS_INT32_ARRAY:
+                v = *(int32_t *)ptr;
+                goto ta_int64;
+            case JS_CLASS_UINT32_ARRAY:
+                v = *(uint32_t *)ptr;
+                goto ta_int64;
+            case JS_CLASS_BIG_INT64_ARRAY:
+                v = *(int64_t *)ptr;
+            ta_int64:
+                js_printf(s, "%" PRId64, v);
+                break;
+            case JS_CLASS_BIG_UINT64_ARRAY:
+                js_printf(s, "%" PRIu64, *(uint64_t *)ptr);
+                break;
+            case JS_CLASS_FLOAT16_ARRAY:
+                js_print_float64(s, fromfp16(*(uint16_t *)ptr));
+                break;
+            case JS_CLASS_FLOAT32_ARRAY:
+                js_print_float64(s, *(float *)ptr);
+                break;
+            case JS_CLASS_FLOAT64_ARRAY:
+                js_print_float64(s, *(double *)ptr);
+                break;
+            }
+        }
+        if (len1 < p->u.array.count)
+            js_print_more_items(s, &comma_state, p->u.array.count - len1);
+    } else if (p->class_id == JS_CLASS_BYTECODE_FUNCTION ||
+               (rt->class_array[p->class_id].call != NULL &&
+                p->class_id != JS_CLASS_PROXY)) {
+        js_printf(s, "[Function");
+        /* XXX: allow dump without ctx */
+        if (!s->options.raw_dump && s->ctx) {
+            const char *func_name_str;
+            js_putc(s, ' ');
+            func_name_str = get_func_name(s->ctx, JS_MKPTR(JS_TAG_OBJECT, p));
+            if (!func_name_str || func_name_str[0] == '\0')
+                js_puts(s, "(anonymous)");
+            else
+                js_puts(s, func_name_str);
+            JS_FreeCString(s->ctx, func_name_str);
+        }
+        js_printf(s, "]");
+        comma_state = 2;
+    } else if (p->class_id == JS_CLASS_MAP || p->class_id == JS_CLASS_SET) {
+        JSMapState *ms = p->u.opaque;
+        struct list_head *el;
+        
+        if (!ms)
+            goto default_obj;
+        js_print_atom(s, rt->class_array[p->class_id].class_name);
+        js_printf(s, "(%u) { ", ms->record_count);
+        i = 0;
+        list_for_each(el, &ms->records) {
+            JSMapRecord *mr = list_entry(el, JSMapRecord, link);
+            js_print_comma(s, &comma_state);
+            if (mr->empty)
+                continue;
+            js_print_value(s, mr->key);
+            if (p->class_id == JS_CLASS_MAP) {
+                js_printf(s, " => ");
+                js_print_value(s, mr->value);
+            }
+            i++;
+            if (i >= s->options.max_item_count)
+                break;
+        }
+        if (i < ms->record_count)
+            js_print_more_items(s, &comma_state, ms->record_count - i);
+    } else if (p->class_id == JS_CLASS_REGEXP && s->ctx && !s->options.raw_dump) {
+        JSValue str = js_regexp_toString(s->ctx, JS_MKPTR(JS_TAG_OBJECT, p), 0, NULL);
+        if (JS_IsException(str))
+            goto default_obj;
+        js_print_raw_string(s, str);
+        JS_FreeValueRT(s->rt, str);
+        comma_state = 2;
+    } else if (p->class_id == JS_CLASS_DATE && s->ctx && !s->options.raw_dump) {
+        JSValue str = get_date_string(s->ctx, JS_MKPTR(JS_TAG_OBJECT, p), 0, NULL, 0x23); /* toISOString() */
+        if (JS_IsException(str))
+            goto default_obj;
+        js_print_raw_string(s, str);
+        JS_FreeValueRT(s->rt, str);
+        comma_state = 2;
+    } else if (p->class_id == JS_CLASS_ERROR && s->ctx && !s->options.raw_dump) {
+        JSValue str = js_error_toString(s->ctx, JS_MKPTR(JS_TAG_OBJECT, p), 0, NULL);
+        if (JS_IsException(str))
+            goto default_obj;
+        js_print_raw_string(s, str);
+        JS_FreeValueRT(s->rt, str);
+        /* dump the stack if present */
+        str = JS_GetProperty(s->ctx, JS_MKPTR(JS_TAG_OBJECT, p), JS_ATOM_stack);
+        if (JS_IsString(str)) {
+            js_putc(s, '\n');
+            /* XXX: should remove the last '\n' in stack as
+               v8. SpiderMonkey does not do it */
+            js_print_raw_string2(s, str, TRUE);
+        }
+        JS_FreeValueRT(s->rt, str);
+        comma_state = 2;
+    } else {
+        default_obj:
+        if (p->class_id != JS_CLASS_OBJECT) {
+            js_print_atom(s, rt->class_array[p->class_id].class_name);
+            js_printf(s, " ");
+        }
+        js_printf(s, "{ ");
     }
-    r = JS_GetBigInt(res);
-    a = JS_ToBigInt(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        JS_FreeValue(ctx, op1);
-        return -1;
+    
+    sh = p->shape; /* the shape can be NULL while freeing an object */
+    if (sh) {
+        uint32_t j;
+        
+        j = 0;
+        for(i = 0, prs = get_shape_prop(sh); i < sh->prop_count; i++, prs++) {
+            if (prs->atom != JS_ATOM_NULL) {
+                if (!(prs->flags & JS_PROP_ENUMERABLE) &&
+                    !s->options.show_hidden) {
+                    continue;
+                }
+                if (j < s->options.max_item_count) {
+                    pr = &p->prop[i];
+                    js_print_comma(s, &comma_state);
+                    js_print_atom(s, prs->atom);
+                    js_printf(s, ": ");
+                    
+                    /* XXX: autoinit property */
+                    if ((prs->flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
+                        if (s->options.raw_dump) {
+                            js_printf(s, "[Getter %p Setter %p]",
+                                    pr->u.getset.getter, pr->u.getset.setter);
+                        } else {
+                            if (pr->u.getset.getter && pr->u.getset.setter) {
+                                js_printf(s, "[Getter/Setter]");
+                            } else if (pr->u.getset.setter) {
+                                js_printf(s, "[Setter]");
+                            } else {
+                                js_printf(s, "[Getter]");
+                            }
+                        }
+                    } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_VARREF) {
+                        if (s->options.raw_dump) {
+                            js_printf(s, "[varref %p]", (void *)pr->u.var_ref);
+                        } else {
+                            js_print_value(s, *pr->u.var_ref->pvalue);
+                        }
+                    } else if ((prs->flags & JS_PROP_TMASK) == JS_PROP_AUTOINIT) {
+                        if (s->options.raw_dump) {
+                            js_printf(s, "[autoinit %p %d %p]",
+                                    (void *)js_autoinit_get_realm(pr),
+                                    js_autoinit_get_id(pr),
+                                    (void *)pr->u.init.opaque);
+                        } else {
+                            /* XXX: could autoinit but need to restart
+                               the iteration */
+                            js_printf(s, "[autoinit]");
+                        }
+                    } else {
+                        js_print_value(s, pr->u.value);
+                    }
+                }
+                j++;
+            }
+        }
+        if (j > s->options.max_item_count)
+            js_print_more_items(s, &comma_state, j - s->options.max_item_count);
     }
-    ret = 0;
-    switch(op) {
-    case OP_inc:
-    case OP_dec:
-        v = 2 * (op - OP_dec) - 1;
-        ret = bf_add_si(r, a, v, BF_PREC_INF, BF_RNDZ);
+    if (s->options.raw_dump && js_class_has_bytecode(p->class_id)) {
+        JSFunctionBytecode *b = p->u.func.function_bytecode;
+        if (b->closure_var_count) {
+            JSVarRef **var_refs;
+            var_refs = p->u.func.var_refs;
+            
+            js_print_comma(s, &comma_state);
+            js_printf(s, "[[Closure]]: [");
+            for(i = 0; i < b->closure_var_count; i++) {
+                if (i != 0)
+                    js_printf(s, ", ");
+                js_print_value(s, var_refs[i]->value);
+            }
+            js_printf(s, " ]");
+        }
+        if (p->u.func.home_object) {
+            js_print_comma(s, &comma_state);
+            js_printf(s, "[[HomeObject]]: ");
+            js_print_value(s, JS_MKPTR(JS_TAG_OBJECT, p->u.func.home_object));
+        }
+    }
+
+    if (!is_array) {
+        if (comma_state != 2) {
+            js_printf(s, " }");
+        }
+    } else {
+        js_printf(s, " ]");
+    }
+}
+
+static int js_print_stack_index(JSPrintValueState *s, JSObject *p)
+{
+    int i;
+    for(i = 0; i < s->level; i++)
+        if (s->print_stack[i] == p)
+            return i;
+    return -1;
+}
+
+static void js_print_value(JSPrintValueState *s, JSValueConst val)
+{
+    uint32_t tag = JS_VALUE_GET_NORM_TAG(val);
+    const char *str;
+
+    switch(tag) {
+    case JS_TAG_INT:
+        js_printf(s, "%d", JS_VALUE_GET_INT(val));
+        break;
+    case JS_TAG_BOOL:
+        if (JS_VALUE_GET_BOOL(val))
+            str = "true";
+        else
+            str = "false";
+        goto print_str;
+    case JS_TAG_NULL:
+        str = "null";
+        goto print_str;
+    case JS_TAG_EXCEPTION:
+        str = "exception";
+        goto print_str;
+    case JS_TAG_UNINITIALIZED:
+        str = "uninitialized";
+        goto print_str;
+    case JS_TAG_UNDEFINED:
+        str = "undefined";
+    print_str:
+        js_puts(s, str);
+        break;
+    case JS_TAG_FLOAT64:
+        js_print_float64(s, JS_VALUE_GET_FLOAT64(val));
+        break;
+    case JS_TAG_SHORT_BIG_INT:
+        js_printf(s, "%" PRId64 "n", (int64_t)JS_VALUE_GET_SHORT_BIG_INT(val));
+        break;
+    case JS_TAG_BIG_INT:
+        if (!s->options.raw_dump && s->ctx) {
+            JSValue str = js_bigint_to_string(s->ctx, val);
+            if (JS_IsException(str))
+                goto raw_bigint;
+            js_print_raw_string(s, str);
+            js_putc(s, 'n');
+            JS_FreeValueRT(s->rt, str);
+        } else {
+            JSBigInt *p;
+            int sgn, i;
+        raw_bigint:
+            p = JS_VALUE_GET_PTR(val);
+            /* In order to avoid allocations we just dump the limbs */
+            sgn = js_bigint_sign(p);
+            if (sgn)
+                js_printf(s, "BigInt.asIntN(%d,", p->len * JS_LIMB_BITS);
+            js_printf(s, "0x");
+            for(i = p->len - 1; i >= 0; i--) {
+                if (i != p->len - 1)
+                    js_putc(s, '_');
+#if JS_LIMB_BITS == 32
+                js_printf(s, "%08x", p->tab[i]);
+#else
+                js_printf(s, "%016" PRIx64, p->tab[i]);
+#endif
+            }
+            js_putc(s, 'n');
+            if (sgn)
+                js_putc(s, ')');
+        }
+        break;
+    case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
+        if (s->options.raw_dump && tag == JS_TAG_STRING_ROPE) {
+            JSStringRope *r = JS_VALUE_GET_STRING_ROPE(val);
+            js_printf(s, "[rope len=%d depth=%d]", r->len, r->depth);
+        } else {
+            js_print_string(s, val);
+        }
+        break;
+    case JS_TAG_FUNCTION_BYTECODE:
+        {
+            JSFunctionBytecode *b = JS_VALUE_GET_PTR(val);
+            js_puts(s, "[bytecode ");
+            js_print_atom(s, b->func_name);
+            js_putc(s, ']');
+        }
         break;
-    case OP_plus:
-        ret = bf_set(r, a);
+    case JS_TAG_OBJECT:
+        {
+            JSObject *p = JS_VALUE_GET_OBJ(val);
+            int idx;
+            idx = js_print_stack_index(s, p);
+            if (idx >= 0) {
+                js_printf(s, "[circular %d]", idx);
+            } else if (s->level < s->options.max_depth) {
+                s->print_stack[s->level++] = p;
+                js_print_object(s, JS_VALUE_GET_OBJ(val));
+                s->level--;
+            } else {
+                JSAtom atom = s->rt->class_array[p->class_id].class_name;
+                js_putc(s, '[');
+                js_print_atom(s, atom);
+                if (s->options.raw_dump) {
+                    js_printf(s, " %p", (void *)p);
+                }
+                js_putc(s, ']');
+            }
+        }
         break;
-    case OP_neg:
-        ret = bf_set(r, a);
-        bf_neg(r);
+    case JS_TAG_SYMBOL:
+        {
+            JSAtomStruct *p = JS_VALUE_GET_PTR(val);
+            js_puts(s, "Symbol(");
+            js_print_atom(s, js_get_atom_index(s->rt, p));
+            js_putc(s, ')');
+        }
         break;
-    case OP_not:
-        ret = bf_add_si(r, a, 1, BF_PREC_INF, BF_RNDZ);
-        bf_neg(r);
+    case JS_TAG_MODULE:
+        js_puts(s, "[module]");
         break;
     default:
-        abort();
+        js_printf(s, "[unknown tag %d]", tag);
+        break;
     }
-    JS_FreeBigInt(ctx, a, &a_s);
-    JS_FreeValue(ctx, op1);
-    if (unlikely(ret)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
+}
+
+void JS_PrintValueSetDefaultOptions(JSPrintValueOptions *options)
+{
+    memset(options, 0, sizeof(*options));
+    options->max_depth = 2;
+    options->max_string_length = 1000;
+    options->max_item_count = 100;
+}
+
+static void JS_PrintValueInternal(JSRuntime *rt, JSContext *ctx, 
+                                  JSPrintValueWrite *write_func, void *write_opaque,
+                                  JSValueConst val, const JSPrintValueOptions *options)
+{
+    JSPrintValueState ss, *s = &ss;
+    if (options)
+        s->options = *options;
+    else
+        JS_PrintValueSetDefaultOptions(&s->options);
+    if (s->options.max_depth <= 0)
+        s->options.max_depth = JS_PRINT_MAX_DEPTH;
+    else
+        s->options.max_depth = min_int(s->options.max_depth, JS_PRINT_MAX_DEPTH);
+    if (s->options.max_string_length == 0)
+        s->options.max_string_length = UINT32_MAX;
+    if (s->options.max_item_count == 0)
+        s->options.max_item_count = UINT32_MAX;
+    s->rt = rt;
+    s->ctx = ctx;
+    s->write_func = write_func;
+    s->write_opaque = write_opaque;
+    s->level = 0;
+    js_print_value(s, val);
+}
+
+void JS_PrintValueRT(JSRuntime *rt, JSPrintValueWrite *write_func, void *write_opaque,
+                     JSValueConst val, const JSPrintValueOptions *options)
+{
+    JS_PrintValueInternal(rt, NULL, write_func, write_opaque, val, options);
+}
+
+void JS_PrintValue(JSContext *ctx, JSPrintValueWrite *write_func, void *write_opaque,
+                   JSValueConst val, const JSPrintValueOptions *options)
+{
+    JS_PrintValueInternal(ctx->rt, ctx, write_func, write_opaque, val, options);
+}
+
+static void js_dump_value_write(void *opaque, const char *buf, size_t len)
+{
+    FILE *fo = opaque;
+    fwrite(buf, 1, len, fo);
+}
+
+static __maybe_unused void print_atom(JSContext *ctx, JSAtom atom)
+{
+    JSPrintValueState ss, *s = &ss;
+    memset(s, 0, sizeof(*s));
+    s->rt = ctx->rt;
+    s->ctx = ctx;
+    s->write_func = js_dump_value_write;
+    s->write_opaque = stdout;
+    js_print_atom(s, atom);
+}
+
+static __maybe_unused void JS_DumpValue(JSContext *ctx, const char *str, JSValueConst val)
+{
+    printf("%s=", str);
+    JS_PrintValue(ctx, js_dump_value_write, stdout, val, NULL);
+    printf("\n");
+}
+
+static __maybe_unused void JS_DumpValueRT(JSRuntime *rt, const char *str, JSValueConst val)
+{
+    printf("%s=", str);
+    JS_PrintValueRT(rt, js_dump_value_write, stdout, val, NULL);
+    printf("\n");
+}
+
+static __maybe_unused void JS_DumpObjectHeader(JSRuntime *rt)
+{
+    printf("%14s %4s %4s %14s %s\n",
+           "ADDRESS", "REFS", "SHRF", "PROTO", "CONTENT");
+}
+
+/* for debug only: dump an object without side effect */
+static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
+{
+    JSShape *sh;
+    JSPrintValueOptions options;
+    
+    /* XXX: should encode atoms with special characters */
+    sh = p->shape; /* the shape can be NULL while freeing an object */
+    printf("%14p %4d ",
+           (void *)p,
+           p->header.ref_count);
+    if (sh) {
+        printf("%3d%c %14p ",
+               sh->header.ref_count,
+               " *"[sh->is_hashed],
+               (void *)sh->proto);
+    } else {
+        printf("%3s  %14s ", "-", "-");
+    }
+
+    JS_PrintValueSetDefaultOptions(&options);
+    options.max_depth = 1;
+    options.show_hidden = TRUE;
+    options.raw_dump = TRUE;
+    JS_PrintValueRT(rt, js_dump_value_write, stdout, JS_MKPTR(JS_TAG_OBJECT, p), &options);
+
+    printf("\n");
+}
+
+static __maybe_unused void JS_DumpGCObject(JSRuntime *rt, JSGCObjectHeader *p)
+{
+    if (p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT) {
+        JS_DumpObject(rt, (JSObject *)p);
+    } else {
+        printf("%14p %4d ",
+               (void *)p,
+               p->ref_count);
+        switch(p->gc_obj_type) {
+        case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
+            printf("[function bytecode]");
+            break;
+        case JS_GC_OBJ_TYPE_SHAPE:
+            printf("[shape]");
+            break;
+        case JS_GC_OBJ_TYPE_VAR_REF:
+            printf("[var_ref]");
+            break;
+        case JS_GC_OBJ_TYPE_ASYNC_FUNCTION:
+            printf("[async_function]");
+            break;
+        case JS_GC_OBJ_TYPE_JS_CONTEXT:
+            printf("[js_context]");
+            break;
+        case JS_GC_OBJ_TYPE_MODULE:
+            printf("[module]");
+            break;
+        default:
+            printf("[unknown %d]", p->gc_obj_type);
+            break;
+        }
+        printf("\n");
+    }
+}
+
+/* return -1 if exception (proxy case) or TRUE/FALSE */
+// TODO: should take flags to make proxy resolution and exceptions optional
+int JS_IsArray(JSContext *ctx, JSValueConst val)
+{
+    if (js_resolve_proxy(ctx, &val, TRUE))
+        return -1;
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(val);
+        return p->class_id == JS_CLASS_ARRAY;
+    } else {
+        return FALSE;
+    }
+}
+
+static double js_pow(double a, double b)
+{
+    if (unlikely(!isfinite(b)) && fabs(a) == 1) {
+        /* not compatible with IEEE 754 */
+        return JS_FLOAT64_NAN;
+    } else {
+        return pow(a, b);
+    }
+}
+
+JSValue JS_NewBigInt64(JSContext *ctx, int64_t v)
+{
+#if JS_SHORT_BIG_INT_BITS == 64
+    return __JS_NewShortBigInt(ctx, v);
+#else
+    if (v >= JS_SHORT_BIG_INT_MIN && v <= JS_SHORT_BIG_INT_MAX) {
+        return __JS_NewShortBigInt(ctx, v);
+    } else {
+        JSBigInt *p;
+        p = js_bigint_new_si64(ctx, v);
+        if (!p)
+            return JS_EXCEPTION;
+        return JS_MKPTR(JS_TAG_BIG_INT, p);
+    }
+#endif
+}
+
+JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v)
+{
+    if (v <= JS_SHORT_BIG_INT_MAX) {
+        return __JS_NewShortBigInt(ctx, v);
+    } else {
+        JSBigInt *p;
+        p = js_bigint_new_ui64(ctx, v);
+        if (!p)
+            return JS_EXCEPTION;
+        return JS_MKPTR(JS_TAG_BIG_INT, p);
+    }
+}
+
+/* return NaN if bad bigint literal */
+static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
+{
+    const char *str, *p;
+    size_t len;
+    int flags;
+
+    str = JS_ToCStringLen(ctx, &len, val);
+    JS_FreeValue(ctx, val);
+    if (!str)
+        return JS_EXCEPTION;
+    p = str;
+    p += skip_spaces(p);
+    if ((p - str) == len) {
+        val = JS_NewBigInt64(ctx, 0);
+    } else {
+        flags = ATOD_INT_ONLY | ATOD_ACCEPT_BIN_OCT | ATOD_TYPE_BIG_INT;
+        val = js_atof(ctx, p, &p, 0, flags);
+        p += skip_spaces(p);
+        if (!JS_IsException(val)) {
+            if ((p - str) != len) {
+                JS_FreeValue(ctx, val);
+                val = JS_NAN;
+            }
+        }
+    }
+    JS_FreeCString(ctx, str);
+    return val;
+}
+
+static JSValue JS_StringToBigIntErr(JSContext *ctx, JSValue val)
+{
+    val = JS_StringToBigInt(ctx, val);
+    if (JS_VALUE_IS_NAN(val))
+        return JS_ThrowSyntaxError(ctx, "invalid bigint literal");
+    return val;
+}
+
+/* JS Numbers are not allowed */
+static JSValue JS_ToBigIntFree(JSContext *ctx, JSValue val)
+{
+    uint32_t tag;
+
+ redo:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
+    case JS_TAG_SHORT_BIG_INT:
+    case JS_TAG_BIG_INT:
+        break;
+    case JS_TAG_INT:
+    case JS_TAG_NULL:
+    case JS_TAG_UNDEFINED:
+    case JS_TAG_FLOAT64:
+        goto fail;
+    case JS_TAG_BOOL:
+        val = __JS_NewShortBigInt(ctx, JS_VALUE_GET_INT(val));
+        break;
+    case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
+        val = JS_StringToBigIntErr(ctx, val);
+        if (JS_IsException(val))
+            return val;
+        goto redo;
+    case JS_TAG_OBJECT:
+        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
+        if (JS_IsException(val))
+            return val;
+        goto redo;
+    default:
+    fail:
+        JS_FreeValue(ctx, val);
+        return JS_ThrowTypeError(ctx, "cannot convert to bigint");
+    }
+    return val;
+}
+
+static JSValue JS_ToBigInt(JSContext *ctx, JSValueConst val)
+{
+    return JS_ToBigIntFree(ctx, JS_DupValue(ctx, val));
+}
+
+/* XXX: merge with JS_ToInt64Free with a specific flag ? */
+static int JS_ToBigInt64Free(JSContext *ctx, int64_t *pres, JSValue val)
+{
+    uint64_t res;
+
+    val = JS_ToBigIntFree(ctx, val);
+    if (JS_IsException(val)) {
+        *pres = 0;
         return -1;
     }
-    res = JS_CompactBigInt(ctx, res);
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_SHORT_BIG_INT) {
+        res = JS_VALUE_GET_SHORT_BIG_INT(val);
+    } else {
+        JSBigInt *p = JS_VALUE_GET_PTR(val);
+        /* return the value mod 2^64 */
+        res = p->tab[0];
+#if JS_LIMB_BITS == 32
+        if (p->len >= 2)
+            res |= (uint64_t)p->tab[1] << 32;
+#endif
+        JS_FreeValue(ctx, val);
+    }
     *pres = res;
     return 0;
 }
 
+int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val)
+{
+    return JS_ToBigInt64Free(ctx, pres, JS_DupValue(ctx, val));
+}
+
 static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
                                                      JSValue *sp,
                                                      OPCodeEnum op)
@@ -12810,24 +13962,13 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
     JSValue op1;
     int v;
     uint32_t tag;
+    JSBigIntBuf buf1;
+    JSBigInt *p1;
 
     op1 = sp[-1];
     /* fast path for float64 */
     if (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(op1)))
         goto handle_float64;
-#ifdef CONFIG_BIGNUM
-    if (JS_IsObject(op1)) {
-        JSValue val;
-        int ret = js_call_unary_op_fallback(ctx, &val, op1, op);
-        if (ret < 0)
-            return -1;
-        if (ret) {
-            JS_FreeValue(ctx, op1);
-            sp[-1] = val;
-            return 0;
-        }
-    }
-#endif
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1))
         goto exception;
@@ -12859,27 +14000,76 @@ static no_inline __exception int js_unary_arith_slow(JSContext *ctx,
             sp[-1] = JS_NewInt64(ctx, v64);
         }
         break;
-    case JS_TAG_BIG_INT:
-    handle_bigint:
-        if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, op, op1))
-            goto exception;
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        if (ctx->rt->bigfloat_ops.unary_arith(ctx, sp - 1, op, op1))
-            goto exception;
+    case JS_TAG_SHORT_BIG_INT:
+        {
+            int64_t v;
+            v = JS_VALUE_GET_SHORT_BIG_INT(op1);
+            switch(op) {
+            case OP_plus:
+                JS_ThrowTypeError(ctx, "bigint argument with unary +");
+                goto exception;
+            case OP_inc:
+                if (v == JS_SHORT_BIG_INT_MAX)
+                    goto bigint_slow_case;
+                sp[-1] = __JS_NewShortBigInt(ctx, v + 1);
+                break;
+            case OP_dec:
+                if (v == JS_SHORT_BIG_INT_MIN)
+                    goto bigint_slow_case;
+                sp[-1] = __JS_NewShortBigInt(ctx, v - 1);
+                break;
+            case OP_neg:
+                v = JS_VALUE_GET_SHORT_BIG_INT(op1);
+                if (v == JS_SHORT_BIG_INT_MIN) {
+                bigint_slow_case:
+                    p1 = js_bigint_set_short(&buf1, op1);
+                    goto bigint_slow_case1;
+                }
+                sp[-1] = __JS_NewShortBigInt(ctx, -v);
+                break;
+            default:
+                abort();
+            }
+        }
         break;
-    case JS_TAG_BIG_DECIMAL:
-        if (ctx->rt->bigdecimal_ops.unary_arith(ctx, sp - 1, op, op1))
-            goto exception;
+    case JS_TAG_BIG_INT:
+        {
+            JSBigInt *r;
+            p1 = JS_VALUE_GET_PTR(op1);
+        bigint_slow_case1:
+            switch(op) {
+            case OP_plus:
+                JS_ThrowTypeError(ctx, "bigint argument with unary +");
+                JS_FreeValue(ctx, op1);
+                goto exception;
+            case OP_inc:
+            case OP_dec:
+                {
+                    JSBigIntBuf buf2;
+                    JSBigInt *p2;
+                    p2 = js_bigint_set_si(&buf2, 2 * (op - OP_dec) - 1);
+                    r = js_bigint_add(ctx, p1, p2, 0);
+                }
+                break;
+            case OP_neg:
+                r = js_bigint_neg(ctx, p1);
+                break;
+            case OP_not:
+                r = js_bigint_not(ctx, p1);
+                break;
+            default:
+                abort();
+            }
+            JS_FreeValue(ctx, op1);
+            if (!r)
+                goto exception;
+            sp[-1] = JS_CompactBigInt(ctx, r);
+        }
         break;
-#endif        
     default:
     handle_float64:
         {
             double d;
-            if (is_math_mode(ctx))
-                goto handle_bigint;
             d = JS_VALUE_GET_FLOAT64(op1);
             switch(op) {
             case OP_inc:
@@ -12925,27 +14115,20 @@ static __exception int js_post_inc_slow(JSContext *ctx,
 static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 {
     JSValue op1;
-    
+
     op1 = sp[-1];
-#ifdef CONFIG_BIGNUM
-    if (JS_IsObject(op1)) {
-        JSValue val;
-        int ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
-        if (ret < 0)
-            return -1;
-        if (ret) {
-            JS_FreeValue(ctx, op1);
-            sp[-1] = val;
-            return 0;
-        }
-    }
-#endif
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1))
         goto exception;
-    if (is_math_mode(ctx) || JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
-        if (ctx->rt->bigint_ops.unary_arith(ctx, sp - 1, OP_not, op1))
+    if (JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT) {
+        sp[-1] = __JS_NewShortBigInt(ctx, ~JS_VALUE_GET_SHORT_BIG_INT(op1));
+    } else if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT) {
+        JSBigInt *r;
+        r = js_bigint_not(ctx, JS_VALUE_GET_PTR(op1));
+        JS_FreeValue(ctx, op1);
+        if (!r)
             goto exception;
+        sp[-1] = JS_CompactBigInt(ctx, r);
     } else {
         int32_t v1;
         if (unlikely(JS_ToInt32Free(ctx, &v1, op1)))
@@ -12958,367 +14141,67 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
-static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
-                                  JSValue *pres, JSValue op1, JSValue op2)
+static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *sp,
+                                                      OPCodeEnum op)
 {
-    bf_t a_s, b_s, *r, *a, *b;
-    int ret;
-    JSValue res;
-    
-    res = JS_NewBigInt(ctx);
-    if (JS_IsException(res))
-        goto fail;
-    a = JS_ToBigInt(ctx, &a_s, op1);
-    if (!a)
-        goto fail;
-    b = JS_ToBigInt(ctx, &b_s, op2);
-    if (!b) {
-        JS_FreeBigInt(ctx, a, &a_s);
-        goto fail;
+    JSValue op1, op2;
+    uint32_t tag1, tag2;
+    double d1, d2;
+
+    op1 = sp[-2];
+    op2 = sp[-1];
+    tag1 = JS_VALUE_GET_NORM_TAG(op1);
+    tag2 = JS_VALUE_GET_NORM_TAG(op2);
+    /* fast path for float operations */
+    if (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_FLOAT64) {
+        d1 = JS_VALUE_GET_FLOAT64(op1);
+        d2 = JS_VALUE_GET_FLOAT64(op2);
+        goto handle_float64;
     }
-    r = JS_GetBigInt(res);
-    ret = 0;
-    switch(op) {
-    case OP_add:
-        ret = bf_add(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_sub:
-        ret = bf_sub(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_mul:
-        ret = bf_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_div:
-        if (!is_math_mode(ctx)) {
-            bf_t rem_s, *rem = &rem_s;
-            bf_init(ctx->bf_ctx, rem);
-            ret = bf_divrem(r, rem, a, b, BF_PREC_INF, BF_RNDZ,
-                            BF_RNDZ);
-            bf_delete(rem);
-        } else {
-            goto math_mode_div_pow;
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case OP_math_mod:
-        /* Euclidian remainder */
-        ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
-                     BF_DIVREM_EUCLIDIAN) & BF_ST_INVALID_OP;
-        break;
-#endif        
-    case OP_mod:
-        ret = bf_rem(r, a, b, BF_PREC_INF, BF_RNDZ,
-                     BF_RNDZ) & BF_ST_INVALID_OP;
-        break;
-    case OP_pow:
-        if (b->sign) {
-            if (!is_math_mode(ctx)) {
-                ret = BF_ST_INVALID_OP;
-            } else {
-            math_mode_div_pow:
-#ifdef CONFIG_BIGNUM
-                JS_FreeValue(ctx, res);
-                ret = js_call_binary_op_simple(ctx, &res, ctx->class_proto[JS_CLASS_BIG_INT], op1, op2, op);
-                if (ret != 0) {
-                    JS_FreeBigInt(ctx, a, &a_s);
-                    JS_FreeBigInt(ctx, b, &b_s);
-                    JS_FreeValue(ctx, op1);
-                    JS_FreeValue(ctx, op2);
-                    if (ret < 0) {
-                        return -1;
-                    } else {
-                        *pres = res;
-                        return 0;
-                    }
-                }
-                /* if no BigInt power operator defined, return a
-                   bigfloat */
-                res = JS_NewBigFloat(ctx);
-                if (JS_IsException(res)) {
-                    JS_FreeBigInt(ctx, a, &a_s);
-                    JS_FreeBigInt(ctx, b, &b_s);
-                    goto fail;
-                }
-                r = JS_GetBigFloat(res);
-                if (op == OP_div) {
-                    ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags) & BF_ST_MEM_ERROR;
-                } else {
-                    ret = bf_pow(r, a, b, ctx->fp_env.prec,
-                                 ctx->fp_env.flags | BF_POW_JS_QUIRKS) & BF_ST_MEM_ERROR;
-                }
-                JS_FreeBigInt(ctx, a, &a_s);
-                JS_FreeBigInt(ctx, b, &b_s);
-                JS_FreeValue(ctx, op1);
-                JS_FreeValue(ctx, op2);
-                if (unlikely(ret)) {
-                    JS_FreeValue(ctx, res);
-                    throw_bf_exception(ctx, ret);
-                    return -1;
-                }
-                *pres = res;
-                return 0;
-#else
-                abort();
-#endif
+    /* fast path for short big int operations */
+    if (tag1 == JS_TAG_SHORT_BIG_INT && tag2 == JS_TAG_SHORT_BIG_INT) {
+        js_slimb_t v1, v2;
+        js_sdlimb_t v;
+        v1 = JS_VALUE_GET_SHORT_BIG_INT(op1);
+        v2 = JS_VALUE_GET_SHORT_BIG_INT(op2);
+        switch(op) {
+        case OP_sub:
+            v = (js_sdlimb_t)v1 - (js_sdlimb_t)v2;
+            break;
+        case OP_mul:
+            v = (js_sdlimb_t)v1 * (js_sdlimb_t)v2;
+            break;
+        case OP_div:
+            if (v2 == 0 ||
+                ((js_limb_t)v1 == (js_limb_t)1 << (JS_LIMB_BITS - 1) &&
+                 v2 == -1)) {
+                goto slow_big_int;
             }
-        } else {
-            ret = bf_pow(r, a, b, BF_PREC_INF, BF_RNDZ | BF_POW_JS_QUIRKS);
-        }
-        break;
-
-        /* logical operations */
-    case OP_shl:
-    case OP_sar:
-        {
-            slimb_t v2;
-#if LIMB_BITS == 32
-            bf_get_int32(&v2, b, 0);
-            if (v2 == INT32_MIN)
-                v2 = INT32_MIN + 1;
-#else
-            bf_get_int64(&v2, b, 0);
-            if (v2 == INT64_MIN)
-                v2 = INT64_MIN + 1;
-#endif
-            if (op == OP_sar)
-                v2 = -v2;
-            ret = bf_set(r, a);
-            ret |= bf_mul_2exp(r, v2, BF_PREC_INF, BF_RNDZ);
-            if (v2 < 0) {
-                ret |= bf_rint(r, BF_RNDD) & (BF_ST_OVERFLOW | BF_ST_MEM_ERROR);
+            sp[-2] = __JS_NewShortBigInt(ctx, v1 / v2);
+            return 0;
+        case OP_mod:
+            if (v2 == 0 ||
+                ((js_limb_t)v1 == (js_limb_t)1 << (JS_LIMB_BITS - 1) &&
+                 v2 == -1)) {
+                goto slow_big_int;
             }
+            sp[-2] = __JS_NewShortBigInt(ctx, v1 % v2);
+            return 0;
+        case OP_pow:
+            goto slow_big_int;
+        default:
+            abort();
         }
-        break;
-    case OP_and:
-        ret = bf_logic_and(r, a, b);
-        break;
-    case OP_or:
-        ret = bf_logic_or(r, a, b);
-        break;
-    case OP_xor:
-        ret = bf_logic_xor(r, a, b);
-        break;
-    default:
-        abort();
-    }
-    JS_FreeBigInt(ctx, a, &a_s);
-    JS_FreeBigInt(ctx, b, &b_s);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    if (unlikely(ret)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
-    }
-    *pres = JS_CompactBigInt(ctx, res);
-    return 0;
- fail:
-    JS_FreeValue(ctx, res);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return -1;
-}
-
-#ifdef CONFIG_BIGNUM
-static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
-                                    JSValue *pres, JSValue op1, JSValue op2)
-{
-    bf_t a_s, b_s, *r, *a, *b;
-    int ret;
-    JSValue res;
-    
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res))
-        goto fail;
-    r = JS_GetBigFloat(res);
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        goto fail;
-    }
-    b = JS_ToBigFloat(ctx, &b_s, op2);
-    if (!b) {
-        if (a == &a_s)
-            bf_delete(a);
-        JS_FreeValue(ctx, res);
-        goto fail;
-    }
-    bf_init(ctx->bf_ctx, r);
-    switch(op) {
-    case OP_add:
-        ret = bf_add(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_sub:
-        ret = bf_sub(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_mul:
-        ret = bf_mul(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_div:
-        ret = bf_div(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags);
-        break;
-    case OP_math_mod:
-        /* Euclidian remainder */
-        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                     BF_DIVREM_EUCLIDIAN);
-        break;
-    case OP_mod:
-        ret = bf_rem(r, a, b, ctx->fp_env.prec, ctx->fp_env.flags,
-                     BF_RNDZ);
-        break;
-    case OP_pow:
-        ret = bf_pow(r, a, b, ctx->fp_env.prec,
-                     ctx->fp_env.flags | BF_POW_JS_QUIRKS);
-        break;
-    default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    if (b == &b_s)
-        bf_delete(b);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    if (unlikely(ret & BF_ST_MEM_ERROR)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
-    }
-    *pres = res;
-    return 0;
- fail:
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return -1;
-}
-
-/* b must be a positive integer */
-static int js_bfdec_pow(bfdec_t *r, const bfdec_t *a, const bfdec_t *b)
-{
-    bfdec_t b1;
-    int32_t b2;
-    int ret;
-
-    bfdec_init(b->ctx, &b1);
-    ret = bfdec_set(&b1, b);
-    if (ret) {
-        bfdec_delete(&b1);
-        return ret;
-    }
-    ret = bfdec_rint(&b1, BF_RNDZ);
-    if (ret) {
-        bfdec_delete(&b1);
-        return BF_ST_INVALID_OP; /* must be an integer */
-    }
-    ret = bfdec_get_int32(&b2, &b1);
-    bfdec_delete(&b1);
-    if (ret)
-        return ret; /* overflow */
-    if (b2 < 0)
-        return BF_ST_INVALID_OP; /* must be positive */
-    return bfdec_pow_ui(r, a, b2);
-}
-
-static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
-                                      JSValue *pres, JSValue op1, JSValue op2)
-{
-    bfdec_t *r, *a, *b;
-    int ret;
-    JSValue res;
-
-    res = JS_NewBigDecimal(ctx);
-    if (JS_IsException(res))
-        goto fail;
-    r = JS_GetBigDecimal(res);
-    
-    a = JS_ToBigDecimal(ctx, op1);
-    if (!a)
-        goto fail;
-    b = JS_ToBigDecimal(ctx, op2);
-    if (!b)
-        goto fail;
-    switch(op) {
-    case OP_add:
-        ret = bfdec_add(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_sub:
-        ret = bfdec_sub(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_mul:
-        ret = bfdec_mul(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_div:
-        ret = bfdec_div(r, a, b, BF_PREC_INF, BF_RNDZ);
-        break;
-    case OP_math_mod:
-        /* Euclidian remainder */
-        ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_DIVREM_EUCLIDIAN);
-        break;
-    case OP_mod:
-        ret = bfdec_rem(r, a, b, BF_PREC_INF, BF_RNDZ, BF_RNDZ);
-        break;
-    case OP_pow:
-        ret = js_bfdec_pow(r, a, b);
-        break;
-    default:
-        abort();
-    }
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    if (unlikely(ret)) {
-        JS_FreeValue(ctx, res);
-        throw_bf_exception(ctx, ret);
-        return -1;
-    }
-    *pres = res;
-    return 0;
- fail:
-    JS_FreeValue(ctx, res);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return -1;
-}
-#endif /* CONFIG_BIGNUM */
-
-static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *sp,
-                                                      OPCodeEnum op)
-{
-    JSValue op1, op2;
-    uint32_t tag1, tag2;
-    double d1, d2;
-
-    op1 = sp[-2];
-    op2 = sp[-1];
-    tag1 = JS_VALUE_GET_NORM_TAG(op1);
-    tag2 = JS_VALUE_GET_NORM_TAG(op2);
-    /* fast path for float operations */
-    if (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_FLOAT64) {
-        d1 = JS_VALUE_GET_FLOAT64(op1);
-        d2 = JS_VALUE_GET_FLOAT64(op2);
-        goto handle_float64;
-    }
-
-#ifdef CONFIG_BIGNUM
-    /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
-        JSValue res;
-        int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
-        if (ret != 0) {
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            if (ret < 0) {
+        if (likely(v >= JS_SHORT_BIG_INT_MIN && v <= JS_SHORT_BIG_INT_MAX)) {
+            sp[-2] = __JS_NewShortBigInt(ctx, v);
+        } else {
+            JSBigInt *r = js_bigint_new_di(ctx, v);
+            if (!r)
                 goto exception;
-            } else {
-                sp[-2] = res;
-                return 0;
-            }
+            sp[-2] = JS_MKPTR(JS_TAG_BIG_INT, r);
         }
+        return 0;
     }
-#endif
-
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1)) {
         JS_FreeValue(ctx, op2);
@@ -13343,34 +14226,14 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             break;
         case OP_mul:
             v = (int64_t)v1 * (int64_t)v2;
-            if (is_math_mode(ctx) &&
-                (v < -MAX_SAFE_INTEGER || v > MAX_SAFE_INTEGER))
-                goto handle_bigint;
             if (v == 0 && (v1 | v2) < 0) {
                 sp[-2] = __JS_NewFloat64(ctx, -0.0);
                 return 0;
             }
             break;
         case OP_div:
-            if (is_math_mode(ctx))
-                goto handle_bigint;
-            sp[-2] = __JS_NewFloat64(ctx, (double)v1 / (double)v2);
+            sp[-2] = JS_NewFloat64(ctx, (double)v1 / (double)v2);
             return 0;
-#ifdef CONFIG_BIGNUM
-        case OP_math_mod:
-            if (unlikely(v2 == 0)) {
-                throw_bf_exception(ctx, BF_ST_DIVIDE_ZERO);
-                goto exception;
-            }
-            v = (int64_t)v1 % (int64_t)v2;
-            if (v < 0) {
-                if (v2 < 0)
-                    v -= v2;
-                else
-                    v += v2;
-            }
-            break;
-#endif            
         case OP_mod:
             if (v1 < 0 || v2 <= 0) {
                 sp[-2] = JS_NewFloat64(ctx, fmod(v1, v2));
@@ -13380,31 +14243,53 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
             }
             break;
         case OP_pow:
-            if (!is_math_mode(ctx)) {
-                sp[-2] = JS_NewFloat64(ctx, js_pow(v1, v2));
-                return 0;
-            } else {
-                goto handle_bigint;
-            }
-            break;
+            sp[-2] = JS_NewFloat64(ctx, js_pow(v1, v2));
+            return 0;
         default:
             abort();
         }
         sp[-2] = JS_NewInt64(ctx, v);
-    } else
-#ifdef CONFIG_BIGNUM
-    if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
-        if (ctx->rt->bigdecimal_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-            goto exception;
-    } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
-        if (ctx->rt->bigfloat_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-            goto exception;
-    } else
-#endif        
-    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
-    handle_bigint:
-        if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
+    } else if ((tag1 == JS_TAG_SHORT_BIG_INT || tag1 == JS_TAG_BIG_INT) &&
+               (tag2 == JS_TAG_SHORT_BIG_INT || tag2 == JS_TAG_BIG_INT)) {
+        JSBigInt *p1, *p2, *r;
+        JSBigIntBuf buf1, buf2;
+    slow_big_int:
+        /* bigint result */
+        if (JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT)
+            p1 = js_bigint_set_short(&buf1, op1);
+        else
+            p1 = JS_VALUE_GET_PTR(op1);
+        if (JS_VALUE_GET_TAG(op2) == JS_TAG_SHORT_BIG_INT)
+            p2 = js_bigint_set_short(&buf2, op2);
+        else
+            p2 = JS_VALUE_GET_PTR(op2);
+        switch(op) {
+        case OP_add:
+            r = js_bigint_add(ctx, p1, p2, 0);
+            break;
+        case OP_sub:
+            r = js_bigint_add(ctx, p1, p2, 1);
+            break;
+        case OP_mul:
+            r = js_bigint_mul(ctx, p1, p2);
+            break;
+        case OP_div:
+            r = js_bigint_divrem(ctx, p1, p2, FALSE);
+            break;
+        case OP_mod:
+            r = js_bigint_divrem(ctx, p1, p2, TRUE);
+            break;
+        case OP_pow:
+            r = js_bigint_pow(ctx, p1, p2);
+            break;
+        default:
+            abort();
+        }
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        if (!r)
             goto exception;
+        sp[-2] = JS_CompactBigInt(ctx, r);
     } else {
         double dr;
         /* float64 result */
@@ -13415,8 +14300,6 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         if (JS_ToFloat64Free(ctx, &d2, op2))
             goto exception;
     handle_float64:
-        if (is_math_mode(ctx) && is_safe_integer(d1) && is_safe_integer(d2))
-            goto handle_bigint;
         switch(op) {
         case OP_sub:
             dr = d1 - d2;
@@ -13430,15 +14313,6 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
         case OP_mod:
             dr = fmod(d1, d2);
             break;
-#ifdef CONFIG_BIGNUM
-        case OP_math_mod:
-            d2 = fabs(d2);
-            dr = fmod(d1, d2);
-            /* XXX: loss of accuracy if dr < 0 */
-            if (dr < 0)
-                dr += d2;
-            break;
-#endif            
         case OP_pow:
             dr = js_pow(d1, d2);
             break;
@@ -13454,6 +14328,11 @@ static no_inline __exception int js_binary_arith_slow(JSContext *ctx, JSValue *s
     return -1;
 }
 
+static inline BOOL tag_is_string(uint32_t tag)
+{
+    return tag == JS_TAG_STRING || tag == JS_TAG_STRING_ROPE;
+}
+
 static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
 {
     JSValue op1, op2;
@@ -13472,31 +14351,25 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         sp[-2] = __JS_NewFloat64(ctx, d1 + d2);
         return 0;
     }
-
-    if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
-#ifdef CONFIG_BIGNUM
-        /* try to call an overloaded operator */
-        if ((tag1 == JS_TAG_OBJECT &&
-             (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED &&
-              tag2 != JS_TAG_STRING)) ||
-            (tag2 == JS_TAG_OBJECT &&
-             (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED &&
-              tag1 != JS_TAG_STRING))) {
-            JSValue res;
-            int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, OP_add,
-                                                 FALSE, HINT_NONE);
-            if (ret != 0) {
-                JS_FreeValue(ctx, op1);
-                JS_FreeValue(ctx, op2);
-                if (ret < 0) {
-                    goto exception;
-                } else {
-                    sp[-2] = res;
-                    return 0;
-                }
-            }
+    /* fast path for short bigint */
+    if (tag1 == JS_TAG_SHORT_BIG_INT && tag2 == JS_TAG_SHORT_BIG_INT) {
+        js_slimb_t v1, v2;
+        js_sdlimb_t v;
+        v1 = JS_VALUE_GET_SHORT_BIG_INT(op1);
+        v2 = JS_VALUE_GET_SHORT_BIG_INT(op2);
+        v = (js_sdlimb_t)v1 + (js_sdlimb_t)v2;
+        if (likely(v >= JS_SHORT_BIG_INT_MIN && v <= JS_SHORT_BIG_INT_MAX)) {
+            sp[-2] = __JS_NewShortBigInt(ctx, v);
+        } else {
+            JSBigInt *r = js_bigint_new_di(ctx, v);
+            if (!r)
+                goto exception;
+            sp[-2] = JS_MKPTR(JS_TAG_BIG_INT, r);
         }
-#endif
+        return 0;
+    }
+    
+    if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
         op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
         if (JS_IsException(op1)) {
             JS_FreeValue(ctx, op2);
@@ -13512,7 +14385,7 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         tag2 = JS_VALUE_GET_NORM_TAG(op2);
     }
 
-    if (tag1 == JS_TAG_STRING || tag2 == JS_TAG_STRING) {
+    if (tag_is_string(tag1) || tag_is_string(tag2)) {
         sp[-2] = JS_ConcatString(ctx, op1, op2);
         if (JS_IsException(sp[-2]))
             goto exception;
@@ -13539,20 +14412,25 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         v2 = JS_VALUE_GET_INT(op2);
         v = (int64_t)v1 + (int64_t)v2;
         sp[-2] = JS_NewInt64(ctx, v);
-    } else
-#ifdef CONFIG_BIGNUM
-    if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
-        if (ctx->rt->bigdecimal_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
-            goto exception;
-    } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
-        if (ctx->rt->bigfloat_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
-            goto exception;
-    } else
-#endif        
-    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
-    handle_bigint:
-        if (ctx->rt->bigint_ops.binary_arith(ctx, OP_add, sp - 2, op1, op2))
+    } else if ((tag1 == JS_TAG_BIG_INT || tag1 == JS_TAG_SHORT_BIG_INT) &&
+               (tag2 == JS_TAG_BIG_INT || tag2 == JS_TAG_SHORT_BIG_INT)) {
+        JSBigInt *p1, *p2, *r;
+        JSBigIntBuf buf1, buf2;
+        /* bigint result */
+        if (JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT)
+            p1 = js_bigint_set_short(&buf1, op1);
+        else
+            p1 = JS_VALUE_GET_PTR(op1);
+        if (JS_VALUE_GET_TAG(op2) == JS_TAG_SHORT_BIG_INT)
+            p2 = js_bigint_set_short(&buf2, op2);
+        else
+            p2 = JS_VALUE_GET_PTR(op2);
+        r = js_bigint_add(ctx, p1, p2, 0);
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        if (!r)
             goto exception;
+        sp[-2] = JS_CompactBigInt(ctx, r);
     } else {
         double d1, d2;
         /* float64 result */
@@ -13562,8 +14440,6 @@ static no_inline __exception int js_add_slow(JSContext *ctx, JSValue *sp)
         }
         if (JS_ToFloat64Free(ctx, &d2, op2))
             goto exception;
-        if (is_math_mode(ctx) && is_safe_integer(d1) && is_safe_integer(d2))
-            goto handle_bigint;
         sp[-2] = __JS_NewFloat64(ctx, d1 + d2);
     }
     return 0;
@@ -13586,27 +14462,62 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
-#ifdef CONFIG_BIGNUM
-    /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
-        JSValue res;
-        int ret = js_call_binary_op_fallback(ctx, &res, op1, op2, op, TRUE, 0);
-        if (ret != 0) {
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            if (ret < 0) {
-                goto exception;
+    if (tag1 == JS_TAG_SHORT_BIG_INT && tag2 == JS_TAG_SHORT_BIG_INT) {
+        js_slimb_t v1, v2, v;
+        js_sdlimb_t vd;
+        v1 = JS_VALUE_GET_SHORT_BIG_INT(op1);
+        v2 = JS_VALUE_GET_SHORT_BIG_INT(op2);
+        /* bigint fast path */
+        switch(op) {
+        case OP_and:
+            v = v1 & v2;
+            break;
+        case OP_or:
+            v = v1 | v2;
+            break;
+        case OP_xor:
+            v = v1 ^ v2;
+            break;
+        case OP_sar:
+            if (v2 > (JS_LIMB_BITS - 1)) {
+                goto slow_big_int;
+            } else if (v2 < 0) {
+                if (v2 < -(JS_LIMB_BITS - 1))
+                    goto slow_big_int;
+                v2 = -v2;
+                goto bigint_shl;
+            }
+        bigint_sar:
+            v = v1 >> v2;
+            break;
+        case OP_shl:
+            if (v2 > (JS_LIMB_BITS - 1)) {
+                goto slow_big_int;
+            } else if (v2 < 0) {
+                if (v2 < -(JS_LIMB_BITS - 1))
+                    goto slow_big_int;
+                v2 = -v2;
+                goto bigint_sar;
+            }
+        bigint_shl:
+            vd = (js_dlimb_t)v1 << v2;
+            if (likely(vd >= JS_SHORT_BIG_INT_MIN &&
+                       vd <= JS_SHORT_BIG_INT_MAX)) {
+                v = vd;
             } else {
-                sp[-2] = res;
+                JSBigInt *r = js_bigint_new_di(ctx, vd);
+                if (!r)
+                    goto exception;
+                sp[-2] = JS_MKPTR(JS_TAG_BIG_INT, r);
                 return 0;
             }
+            break;
+        default:
+            abort();
         }
+        sp[-2] = __JS_NewShortBigInt(ctx, v);
+        return 0;
     }
-#endif
-
     op1 = JS_ToNumericFree(ctx, op1);
     if (JS_IsException(op1)) {
         JS_FreeValue(ctx, op2);
@@ -13618,22 +14529,52 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
         goto exception;
     }
 
-    if (is_math_mode(ctx))
-        goto bigint_op;
-
     tag1 = JS_VALUE_GET_TAG(op1);
     tag2 = JS_VALUE_GET_TAG(op2);
-    if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
-        if (tag1 != tag2) {
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            JS_ThrowTypeError(ctx, "both operands must be bigint");
-            goto exception;
-        } else {
-        bigint_op:
-            if (ctx->rt->bigint_ops.binary_arith(ctx, op, sp - 2, op1, op2))
-                goto exception;
+    if ((tag1 == JS_TAG_BIG_INT || tag1 == JS_TAG_SHORT_BIG_INT) &&
+        (tag2 == JS_TAG_BIG_INT || tag2 == JS_TAG_SHORT_BIG_INT)) {
+        JSBigInt *p1, *p2, *r;
+        JSBigIntBuf buf1, buf2;
+    slow_big_int:
+        if (JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT)
+            p1 = js_bigint_set_short(&buf1, op1);
+        else
+            p1 = JS_VALUE_GET_PTR(op1);
+        if (JS_VALUE_GET_TAG(op2) == JS_TAG_SHORT_BIG_INT)
+            p2 = js_bigint_set_short(&buf2, op2);
+        else
+            p2 = JS_VALUE_GET_PTR(op2);
+        switch(op) {
+        case OP_and:
+        case OP_or:
+        case OP_xor:
+            r = js_bigint_logic(ctx, p1, p2, op);
+            break;
+        case OP_shl:
+        case OP_sar:
+            {
+                js_slimb_t shift;
+                shift = js_bigint_get_si_sat(p2);
+                if (shift > INT32_MAX)
+                    shift = INT32_MAX;
+                else if (shift < -INT32_MAX)
+                    shift = -INT32_MAX;
+                if (op == OP_sar)
+                    shift = -shift;
+                if (shift >= 0)
+                    r = js_bigint_shl(ctx, p1, shift);
+                else
+                    r = js_bigint_shr(ctx, p1, -shift);
+            }
+            break;
+        default:
+            abort();
         }
+        JS_FreeValue(ctx, op1);
+        JS_FreeValue(ctx, op2);
+        if (!r)
+            goto exception;
+        sp[-2] = JS_CompactBigInt(ctx, r);
     } else {
         if (unlikely(JS_ToInt32Free(ctx, (int32_t *)&v1, op1))) {
             JS_FreeValue(ctx, op2);
@@ -13669,100 +14610,98 @@ static no_inline __exception int js_binary_logic_slow(JSContext *ctx,
     return -1;
 }
 
-/* Note: also used for bigint */
-static int js_compare_bigfloat(JSContext *ctx, OPCodeEnum op,
-                               JSValue op1, JSValue op2)
+/* op1 must be a bigint or int. */
+static JSBigInt *JS_ToBigIntBuf(JSContext *ctx, JSBigIntBuf *buf1,
+                                JSValue op1)
 {
-    bf_t a_s, b_s, *a, *b;
-    int res;
+    JSBigInt *p1;
     
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, op2);
-        return -1;
-    }
-    b = JS_ToBigFloat(ctx, &b_s, op2);
-    if (!b) {
-        if (a == &a_s)
-            bf_delete(a);
-        JS_FreeValue(ctx, op1);
-        return -1;
-    }
-    switch(op) {
-    case OP_lt:
-        res = bf_cmp_lt(a, b); /* if NaN return false */
-        break;
-    case OP_lte:
-        res = bf_cmp_le(a, b); /* if NaN return false */
-        break;
-    case OP_gt:
-        res = bf_cmp_lt(b, a); /* if NaN return false */
+    switch(JS_VALUE_GET_TAG(op1)) {
+    case JS_TAG_INT:
+        p1 = js_bigint_set_si(buf1, JS_VALUE_GET_INT(op1));
         break;
-    case OP_gte:
-        res = bf_cmp_le(b, a); /* if NaN return false */
+    case JS_TAG_SHORT_BIG_INT:
+        p1 = js_bigint_set_short(buf1, op1);
         break;
-    case OP_eq:
-        res = bf_cmp_eq(a, b); /* if NaN return false */
+    case JS_TAG_BIG_INT:
+        p1 = JS_VALUE_GET_PTR(op1);
         break;
     default:
         abort();
     }
-    if (a == &a_s)
-        bf_delete(a);
-    if (b == &b_s)
-        bf_delete(b);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return res;
+    return p1;
 }
 
-#ifdef CONFIG_BIGNUM
-static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
-                                 JSValue op1, JSValue op2)
+/* op1 and op2 must be numeric types and at least one must be a
+   bigint. No exception is generated. */
+static int js_compare_bigint(JSContext *ctx, OPCodeEnum op,
+                             JSValue op1, JSValue op2)
 {
-    bfdec_t *a, *b;
-    int res;
-
-    /* Note: binary floats are converted to bigdecimal with
-       toString(). It is not mathematically correct but is consistent
-       with the BigDecimal() constructor behavior */
-    op1 = JS_ToBigDecimalFree(ctx, op1, TRUE);
-    if (JS_IsException(op1)) {
-        JS_FreeValue(ctx, op2);
-        return -1;
-    }
-    op2 = JS_ToBigDecimalFree(ctx, op2, TRUE);
-    if (JS_IsException(op2)) {
+    int res, val, tag1, tag2;
+    JSBigIntBuf buf1, buf2;
+    JSBigInt *p1, *p2;
+    
+    tag1 = JS_VALUE_GET_NORM_TAG(op1);
+    tag2 = JS_VALUE_GET_NORM_TAG(op2);
+    if ((tag1 == JS_TAG_SHORT_BIG_INT || tag1 == JS_TAG_INT) &&
+        (tag2 == JS_TAG_SHORT_BIG_INT || tag2 == JS_TAG_INT)) {
+        /* fast path */
+        js_slimb_t v1, v2;
+        if (tag1 == JS_TAG_INT)
+            v1 = JS_VALUE_GET_INT(op1);
+        else
+            v1 = JS_VALUE_GET_SHORT_BIG_INT(op1);
+        if (tag2 == JS_TAG_INT)
+            v2 = JS_VALUE_GET_INT(op2);
+        else
+            v2 = JS_VALUE_GET_SHORT_BIG_INT(op2);
+        val = (v1 > v2) - (v1 < v2);
+    } else {
+        if (tag1 == JS_TAG_FLOAT64) {
+            p2 = JS_ToBigIntBuf(ctx, &buf2, op2);
+            val = js_bigint_float64_cmp(ctx, p2, JS_VALUE_GET_FLOAT64(op1));
+            if (val == 2)
+                goto unordered;
+            val = -val;
+        } else if (tag2 == JS_TAG_FLOAT64) {
+            p1 = JS_ToBigIntBuf(ctx, &buf1, op1);
+            val = js_bigint_float64_cmp(ctx, p1, JS_VALUE_GET_FLOAT64(op2));
+            if (val == 2) {
+            unordered:
+                JS_FreeValue(ctx, op1);
+                JS_FreeValue(ctx, op2);
+                return FALSE;
+            }
+        } else {
+            p1 = JS_ToBigIntBuf(ctx, &buf1, op1);
+            p2 = JS_ToBigIntBuf(ctx, &buf2, op2);
+            val = js_bigint_cmp(ctx, p1, p2);
+        }
         JS_FreeValue(ctx, op1);
-        return -1;
+        JS_FreeValue(ctx, op2);
     }
-    a = JS_ToBigDecimal(ctx, op1); /* cannot fail */
-    b = JS_ToBigDecimal(ctx, op2); /* cannot fail */
-    
+
     switch(op) {
     case OP_lt:
-        res = bfdec_cmp_lt(a, b); /* if NaN return false */
+        res = val < 0;
         break;
     case OP_lte:
-        res = bfdec_cmp_le(a, b); /* if NaN return false */
+        res = val <= 0;
         break;
     case OP_gt:
-        res = bfdec_cmp_lt(b, a); /* if NaN return false */
+        res = val > 0;
         break;
     case OP_gte:
-        res = bfdec_cmp_le(b, a); /* if NaN return false */
+        res = val >= 0;
         break;
     case OP_eq:
-        res = bfdec_cmp_eq(a, b); /* if NaN return false */
+        res = val == 0;
         break;
     default:
         abort();
     }
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
     return res;
 }
-#endif /* !CONFIG_BIGNUM */
 
 static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
                                         OPCodeEnum op)
@@ -13775,27 +14714,6 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     op2 = sp[-1];
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
-#ifdef CONFIG_BIGNUM
-    /* try to call an overloaded operator */
-    if ((tag1 == JS_TAG_OBJECT &&
-         (tag2 != JS_TAG_NULL && tag2 != JS_TAG_UNDEFINED)) ||
-        (tag2 == JS_TAG_OBJECT &&
-         (tag1 != JS_TAG_NULL && tag1 != JS_TAG_UNDEFINED))) {
-        JSValue ret;
-        res = js_call_binary_op_fallback(ctx, &ret, op1, op2, op,
-                                         FALSE, HINT_NUMBER);
-        if (res != 0) {
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            if (res < 0) {
-                goto exception;
-            } else {
-                sp[-2] = ret;
-                return 0;
-            }
-        }
-    }
-#endif    
     op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NUMBER);
     if (JS_IsException(op1)) {
         JS_FreeValue(ctx, op2);
@@ -13809,11 +14727,13 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
     tag1 = JS_VALUE_GET_NORM_TAG(op1);
     tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
-    if (tag1 == JS_TAG_STRING && tag2 == JS_TAG_STRING) {
-        JSString *p1, *p2;
-        p1 = JS_VALUE_GET_STRING(op1);
-        p2 = JS_VALUE_GET_STRING(op2);
-        res = js_string_compare(ctx, p1, p2);
+    if (tag_is_string(tag1) && tag_is_string(tag2)) {
+        if (tag1 == JS_TAG_STRING && tag2 == JS_TAG_STRING) {
+            res = js_string_compare(ctx, JS_VALUE_GET_STRING(op1),
+                                    JS_VALUE_GET_STRING(op2));
+        } else {
+            res = js_string_rope_compare(ctx, op1, op2, FALSE);
+        }
         switch(op) {
         case OP_lt:
             res = (res < 0);
@@ -13836,17 +14756,20 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
         /* fast path for float64/int */
         goto float64_compare;
     } else {
-        if (((tag1 == JS_TAG_BIG_INT && tag2 == JS_TAG_STRING) ||
-             (tag2 == JS_TAG_BIG_INT && tag1 == JS_TAG_STRING)) &&
-            !is_math_mode(ctx)) {
-            if (tag1 == JS_TAG_STRING) {
+        if ((((tag1 == JS_TAG_BIG_INT || tag1 == JS_TAG_SHORT_BIG_INT) &&
+              tag_is_string(tag2)) ||
+             ((tag2 == JS_TAG_BIG_INT || tag2 == JS_TAG_SHORT_BIG_INT) &&
+              tag_is_string(tag1)))) {
+            if (tag_is_string(tag1)) {
                 op1 = JS_StringToBigInt(ctx, op1);
-                if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
+                if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT &&
+                    JS_VALUE_GET_TAG(op1) != JS_TAG_SHORT_BIG_INT)
                     goto invalid_bigint_string;
             }
-            if (tag2 == JS_TAG_STRING) {
+            if (tag_is_string(tag2)) {
                 op2 = JS_StringToBigInt(ctx, op2);
-                if (JS_VALUE_GET_TAG(op2) != JS_TAG_BIG_INT) {
+                if (JS_VALUE_GET_TAG(op2) != JS_TAG_BIG_INT &&
+                    JS_VALUE_GET_TAG(op2) != JS_TAG_SHORT_BIG_INT) {
                 invalid_bigint_string:
                     JS_FreeValue(ctx, op1);
                     JS_FreeValue(ctx, op2);
@@ -13870,21 +14793,9 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
         tag1 = JS_VALUE_GET_NORM_TAG(op1);
         tag2 = JS_VALUE_GET_NORM_TAG(op2);
 
-#ifdef CONFIG_BIGNUM
-        if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
-            res = ctx->rt->bigdecimal_ops.compare(ctx, op, op1, op2);
-            if (res < 0)
-                goto exception;
-        } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
-            res = ctx->rt->bigfloat_ops.compare(ctx, op, op1, op2);
-            if (res < 0)
-                goto exception;
-        } else
-#endif            
-        if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
-            res = ctx->rt->bigint_ops.compare(ctx, op, op1, op2);
-            if (res < 0)
-                goto exception;
+        if (tag1 == JS_TAG_BIG_INT || tag1 == JS_TAG_SHORT_BIG_INT ||
+            tag2 == JS_TAG_BIG_INT || tag2 == JS_TAG_SHORT_BIG_INT) {
+            res = js_compare_bigint(ctx, op, op1, op2);
         } else {
             double d1, d2;
 
@@ -13928,21 +14839,15 @@ static no_inline int js_relational_slow(JSContext *ctx, JSValue *sp,
 
 static BOOL tag_is_number(uint32_t tag)
 {
-    return (tag == JS_TAG_INT || tag == JS_TAG_BIG_INT ||
-            tag == JS_TAG_FLOAT64
-#ifdef CONFIG_BIGNUM
-            || tag == JS_TAG_BIG_FLOAT || tag == JS_TAG_BIG_DECIMAL
-#endif
-            );
+    return (tag == JS_TAG_INT || 
+            tag == JS_TAG_FLOAT64 ||
+            tag == JS_TAG_BIG_INT || tag == JS_TAG_SHORT_BIG_INT);
 }
 
 static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                                             BOOL is_neq)
 {
     JSValue op1, op2;
-#ifdef CONFIG_BIGNUM
-    JSValue ret;
-#endif
     int res;
     uint32_t tag1, tag2;
 
@@ -13970,59 +14875,32 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 d2 = JS_VALUE_GET_INT(op2);
             }
             res = (d1 == d2);
-        } else
-#ifdef CONFIG_BIGNUM
-        if (tag1 == JS_TAG_BIG_DECIMAL || tag2 == JS_TAG_BIG_DECIMAL) {
-            res = ctx->rt->bigdecimal_ops.compare(ctx, OP_eq, op1, op2);
-            if (res < 0)
-                goto exception;
-        } else if (tag1 == JS_TAG_BIG_FLOAT || tag2 == JS_TAG_BIG_FLOAT) {
-            res = ctx->rt->bigfloat_ops.compare(ctx, OP_eq, op1, op2);
-            if (res < 0)
-                goto exception;
-        } else
-#endif            
-        {
-            res = ctx->rt->bigint_ops.compare(ctx, OP_eq, op1, op2);
-            if (res < 0)
-                goto exception;
+        } else {
+            res = js_compare_bigint(ctx, OP_eq, op1, op2);
         }
     } else if (tag1 == tag2) {
-#ifdef CONFIG_BIGNUM
-        if (tag1 == JS_TAG_OBJECT) {
-            /* try the fallback operator */
-            res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
-                                             is_neq ? OP_neq : OP_eq,
-                                             FALSE, HINT_NONE);
-            if (res != 0) {
-                JS_FreeValue(ctx, op1);
-                JS_FreeValue(ctx, op2);
-                if (res < 0) {
-                    goto exception;
-                } else {
-                    sp[-2] = ret;
-                    return 0;
-                }
-            }
-        }
-#endif        
         res = js_strict_eq2(ctx, op1, op2, JS_EQ_STRICT);
     } else if ((tag1 == JS_TAG_NULL && tag2 == JS_TAG_UNDEFINED) ||
                (tag2 == JS_TAG_NULL && tag1 == JS_TAG_UNDEFINED)) {
         res = TRUE;
-    } else if ((tag1 == JS_TAG_STRING && tag_is_number(tag2)) ||
-               (tag2 == JS_TAG_STRING && tag_is_number(tag1))) {
+    } else if (tag_is_string(tag1) && tag_is_string(tag2)) {
+        /* needed when comparing strings and ropes */
+        res = js_strict_eq2(ctx, op1, op2, JS_EQ_STRICT);
+    } else if ((tag_is_string(tag1) && tag_is_number(tag2)) ||
+               (tag_is_string(tag2) && tag_is_number(tag1))) {
 
-        if ((tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) &&
-            !is_math_mode(ctx)) {
-            if (tag1 == JS_TAG_STRING) {
+        if (tag1 == JS_TAG_BIG_INT || tag1 == JS_TAG_SHORT_BIG_INT ||
+            tag2 == JS_TAG_BIG_INT || tag2 == JS_TAG_SHORT_BIG_INT) {
+            if (tag_is_string(tag1)) {
                 op1 = JS_StringToBigInt(ctx, op1);
-                if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT)
+                if (JS_VALUE_GET_TAG(op1) != JS_TAG_BIG_INT &&
+                    JS_VALUE_GET_TAG(op1) != JS_TAG_SHORT_BIG_INT)
                     goto invalid_bigint_string;
             }
-            if (tag2 == JS_TAG_STRING) {
+            if (tag_is_string(tag2)) {
                 op2 = JS_StringToBigInt(ctx, op2);
-                if (JS_VALUE_GET_TAG(op2) != JS_TAG_BIG_INT) {
+                if (JS_VALUE_GET_TAG(op2) != JS_TAG_BIG_INT &&
+                    JS_VALUE_GET_TAG(op2) != JS_TAG_SHORT_BIG_INT ) {
                 invalid_bigint_string:
                     JS_FreeValue(ctx, op1);
                     JS_FreeValue(ctx, op2);
@@ -14042,7 +14920,7 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
                 goto exception;
             }
         }
-        res = js_strict_eq(ctx, op1, op2);
+        res = js_strict_eq2(ctx, op1, op2, JS_EQ_STRICT);
     } else if (tag1 == JS_TAG_BOOL) {
         op1 = JS_NewInt32(ctx, JS_VALUE_GET_INT(op1));
         goto redo;
@@ -14050,25 +14928,9 @@ static no_inline __exception int js_eq_slow(JSContext *ctx, JSValue *sp,
         op2 = JS_NewInt32(ctx, JS_VALUE_GET_INT(op2));
         goto redo;
     } else if ((tag1 == JS_TAG_OBJECT &&
-                (tag_is_number(tag2) || tag2 == JS_TAG_STRING || tag2 == JS_TAG_SYMBOL)) ||
+                (tag_is_number(tag2) || tag_is_string(tag2) || tag2 == JS_TAG_SYMBOL)) ||
                (tag2 == JS_TAG_OBJECT &&
-                (tag_is_number(tag1) || tag1 == JS_TAG_STRING || tag1 == JS_TAG_SYMBOL))) {
-#ifdef CONFIG_BIGNUM
-        /* try the fallback operator */
-        res = js_call_binary_op_fallback(ctx, &ret, op1, op2,
-                                         is_neq ? OP_neq : OP_eq,
-                                         FALSE, HINT_NONE);
-        if (res != 0) {
-            JS_FreeValue(ctx, op1);
-            JS_FreeValue(ctx, op2);
-            if (res < 0) {
-                goto exception;
-            } else {
-                sp[-2] = ret;
-                return 0;
-            }
-        }
-#endif
+                (tag_is_number(tag1) || tag_is_string(tag1) || tag1 == JS_TAG_SYMBOL))) {
         op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
         if (JS_IsException(op1)) {
             JS_FreeValue(ctx, op2);
@@ -14119,10 +14981,10 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
         JS_FreeValue(ctx, op1);
         goto exception;
     }
-    /* XXX: could forbid >>> in bignum mode */
-    if (!is_math_mode(ctx) &&
-        (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
-         JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT)) {
+    if (JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
+        JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT ||
+        JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT ||
+        JS_VALUE_GET_TAG(op2) == JS_TAG_SHORT_BIG_INT) {
         JS_ThrowTypeError(ctx, "bigint operands are forbidden for >>>");
         JS_FreeValue(ctx, op1);
         JS_FreeValue(ctx, op2);
@@ -14140,67 +15002,6 @@ static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
     return -1;
 }
 
-#ifdef CONFIG_BIGNUM
-static JSValue js_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
-                                       int64_t exponent)
-{
-    bf_t r_s, *r = &r_s;
-    double d;
-    int ret;
-    
-    /* always convert to Float64 */
-    bf_init(ctx->bf_ctx, r);
-    ret = bf_mul_pow_radix(r, a, 10, exponent,
-                           53, bf_set_exp_bits(11) | BF_RNDN |
-                           BF_FLAG_SUBNORMAL);
-    bf_get_float64(r, &d, BF_RNDN);
-    bf_delete(r);
-    if (ret & BF_ST_MEM_ERROR)
-        return JS_ThrowOutOfMemory(ctx);
-    else
-        return __JS_NewFloat64(ctx, d);
-}
-
-static no_inline int js_mul_pow10(JSContext *ctx, JSValue *sp)
-{
-    bf_t a_s, *a, *r;
-    JSValue op1, op2, res;
-    int64_t e;
-    int ret;
-
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res))
-        return -1;
-    r = JS_GetBigFloat(res);
-    op1 = sp[-2];
-    op2 = sp[-1];
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        return -1;
-    }
-    if (JS_IsBigInt(ctx, op2)) {
-        ret = JS_ToBigInt64(ctx, &e, op2);
-    } else {
-        ret = JS_ToInt64(ctx, &e, op2);
-    }
-    if (ret) {
-        if (a == &a_s)
-            bf_delete(a);
-        JS_FreeValue(ctx, res);
-        return -1;
-    }
-
-    bf_mul_pow_radix(r, a, 10, e, ctx->fp_env.prec, ctx->fp_env.flags);
-    if (a == &a_s)
-        bf_delete(a);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    sp[-2] = res;
-    return 0;
-}
-#endif
-
 /* XXX: Should take JSValueConst arguments */
 static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
                           JSStrictEqModeEnum eq_mode)
@@ -14225,14 +15026,15 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
         res = (tag1 == tag2);
         break;
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         {
-            JSString *p1, *p2;
-            if (tag1 != tag2) {
+            if (!tag_is_string(tag2)) {
                 res = FALSE;
+            } else if (tag1 == JS_TAG_STRING && tag2 == JS_TAG_STRING) {
+                res = (js_string_compare(ctx, JS_VALUE_GET_STRING(op1),
+                                         JS_VALUE_GET_STRING(op2)) == 0);
             } else {
-                p1 = JS_VALUE_GET_STRING(op1);
-                p2 = JS_VALUE_GET_STRING(op2);
-                res = (js_string_compare(ctx, p1, p2) == 0);
+                res = (js_string_rope_compare(ctx, op1, op2, TRUE) == 0);
             }
         }
         break;
@@ -14293,63 +15095,29 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
             res = (d1 == d2); /* if NaN return false and +0 == -0 */
         }
         goto done_no_free;
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
         {
-            bf_t a_s, *a, b_s, *b;
-            if (tag1 != tag2) {
-                res = FALSE;
-                break;
-            }
-            a = JS_ToBigFloat(ctx, &a_s, op1); /* cannot fail */
-            b = JS_ToBigFloat(ctx, &b_s, op2); /* cannot fail */
-            res = bf_cmp_eq(a, b);
-            if (a == &a_s)
-                bf_delete(a);
-            if (b == &b_s)
-                bf_delete(b);
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p1, *p2;
-            const bf_t *a, *b;
-            if (tag1 != tag2) {
-                res = FALSE;
-                break;
-            }
-            p1 = JS_VALUE_GET_PTR(op1);
-            p2 = JS_VALUE_GET_PTR(op2);
-            a = &p1->num;
-            b = &p2->num;
-            if (unlikely(eq_mode >= JS_EQ_SAME_VALUE)) {
-                if (eq_mode == JS_EQ_SAME_VALUE_ZERO &&
-                           a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO) {
-                    res = TRUE;
-                } else {
-                    res = (bf_cmp_full(a, b) == 0);
-                }
-            } else {
-                res = bf_cmp_eq(a, b);
-            }
-        }
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        {
-            JSBigDecimal *p1, *p2;
-            const bfdec_t *a, *b;
-            if (tag1 != tag2) {
+            JSBigIntBuf buf1, buf2;
+            JSBigInt *p1, *p2;
+
+            if (tag2 != JS_TAG_SHORT_BIG_INT &&
+                tag2 != JS_TAG_BIG_INT) {
                 res = FALSE;
                 break;
             }
-            p1 = JS_VALUE_GET_PTR(op1);
-            p2 = JS_VALUE_GET_PTR(op2);
-            a = &p1->num;
-            b = &p2->num;
-            res = bfdec_cmp_eq(a, b);
+            
+            if (JS_VALUE_GET_TAG(op1) == JS_TAG_SHORT_BIG_INT)
+                p1 = js_bigint_set_short(&buf1, op1);
+            else
+                p1 = JS_VALUE_GET_PTR(op1);
+            if (JS_VALUE_GET_TAG(op2) == JS_TAG_SHORT_BIG_INT)
+                p2 = js_bigint_set_short(&buf2, op2);
+            else
+                p2 = JS_VALUE_GET_PTR(op2);
+            res = (js_bigint_cmp(ctx, p1, p2) == 0);
         }
         break;
-#endif
     default:
         res = FALSE;
         break;
@@ -14360,9 +15128,16 @@ static BOOL js_strict_eq2(JSContext *ctx, JSValue op1, JSValue op2,
     return res;
 }
 
-static BOOL js_strict_eq(JSContext *ctx, JSValue op1, JSValue op2)
+static BOOL js_strict_eq(JSContext *ctx, JSValueConst op1, JSValueConst op2)
+{
+    return js_strict_eq2(ctx,
+                         JS_DupValue(ctx, op1), JS_DupValue(ctx, op2),
+                         JS_EQ_STRICT);
+}
+
+BOOL JS_StrictEq(JSContext *ctx, JSValueConst op1, JSValueConst op2)
 {
-    return js_strict_eq2(ctx, op1, op2, JS_EQ_STRICT);
+    return js_strict_eq(ctx, op1, op2);
 }
 
 static BOOL js_same_value(JSContext *ctx, JSValueConst op1, JSValueConst op2)
@@ -14372,6 +15147,11 @@ static BOOL js_same_value(JSContext *ctx, JSValueConst op1, JSValueConst op2)
                          JS_EQ_SAME_VALUE);
 }
 
+BOOL JS_SameValue(JSContext *ctx, JSValueConst op1, JSValueConst op2)
+{
+    return js_same_value(ctx, op1, op2);
+}
+
 static BOOL js_same_value_zero(JSContext *ctx, JSValueConst op1, JSValueConst op2)
 {
     return js_strict_eq2(ctx,
@@ -14379,11 +15159,16 @@ static BOOL js_same_value_zero(JSContext *ctx, JSValueConst op1, JSValueConst op
                          JS_EQ_SAME_VALUE_ZERO);
 }
 
+BOOL JS_SameValueZero(JSContext *ctx, JSValueConst op1, JSValueConst op2)
+{
+    return js_same_value_zero(ctx, op1, op2);
+}
+
 static no_inline int js_strict_eq_slow(JSContext *ctx, JSValue *sp,
                                        BOOL is_neq)
 {
     BOOL res;
-    res = js_strict_eq(ctx, sp[-2], sp[-1]);
+    res = js_strict_eq2(ctx, sp[-2], sp[-1], JS_EQ_STRICT);
     sp[-2] = JS_NewBool(ctx, res ^ is_neq);
     return 0;
 }
@@ -14414,6 +15199,43 @@ static __exception int js_operator_in(JSContext *ctx, JSValue *sp)
     return 0;
 }
 
+static __exception int js_operator_private_in(JSContext *ctx, JSValue *sp)
+{
+    JSValue op1, op2;
+    int ret;
+
+    op1 = sp[-2]; /* object */
+    op2 = sp[-1]; /* field name or method function */
+
+    if (JS_VALUE_GET_TAG(op1) != JS_TAG_OBJECT) {
+        JS_ThrowTypeError(ctx, "invalid 'in' operand");
+        return -1;
+    }
+    if (JS_IsObject(op2)) {
+        /* method: use the brand */
+        ret = JS_CheckBrand(ctx, op1, op2);
+        if (ret < 0)
+            return -1;
+    } else {
+        JSAtom atom;
+        JSObject *p;
+        JSShapeProperty *prs;
+        JSProperty *pr;
+        /* field */
+        atom = JS_ValueToAtom(ctx, op2);
+        if (unlikely(atom == JS_ATOM_NULL))
+            return -1;
+        p = JS_VALUE_GET_OBJ(op1);
+        prs = find_own_property(&pr, p, atom);
+        JS_FreeAtom(ctx, atom);
+        ret = (prs != NULL);
+    }
+    JS_FreeValue(ctx, op1);
+    JS_FreeValue(ctx, op2);
+    sp[-2] = JS_NewBool(ctx, ret);
+    return 0;
+}
+
 static __exception int js_has_unscopable(JSContext *ctx, JSValueConst obj,
                                          JSAtom atom)
 {
@@ -14455,17 +15277,10 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValueConst op1)
 
     tag = JS_VALUE_GET_NORM_TAG(op1);
     switch(tag) {
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
         atom = JS_ATOM_bigint;
         break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        atom = JS_ATOM_bigfloat;
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        atom = JS_ATOM_bigdecimal;
-        break;
-#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         atom = JS_ATOM_number;
@@ -14477,13 +15292,14 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValueConst op1)
         atom = JS_ATOM_boolean;
         break;
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         atom = JS_ATOM_string;
         break;
     case JS_TAG_OBJECT:
         {
             JSObject *p;
             p = JS_VALUE_GET_OBJ(op1);
-            if (unlikely(p->is_HTMLDDA)) 
+            if (unlikely(p->is_HTMLDDA))
                 atom = JS_ATOM_undefined;
             else if (JS_IsFunction(ctx, op1))
                 atom = JS_ATOM_function;
@@ -14526,21 +15342,15 @@ static __exception int js_operator_delete(JSContext *ctx, JSValue *sp)
     return 0;
 }
 
-static JSValue js_throw_type_error(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv)
-{
-    return JS_ThrowTypeError(ctx, "invalid property access");
-}
-
 /* XXX: not 100% compatible, but mozilla seems to use a similar
    implementation to ensure that caller in non strict mode does not
    throw (ES5 compatibility) */
-static JSValue js_function_proto_caller(JSContext *ctx, JSValueConst this_val,
-                                        int argc, JSValueConst *argv)
+static JSValue js_throw_type_error(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
 {
     JSFunctionBytecode *b = JS_GetFunctionBytecode(this_val);
-    if (!b || (b->js_mode & JS_MODE_STRICT) || !b->has_prototype) {
-        return js_throw_type_error(ctx, this_val, 0, NULL);
+    if (!b || (b->js_mode & JS_MODE_STRICT) || !b->has_prototype || argc >= 1) {
+        return JS_ThrowTypeError(ctx, "invalid property access");
     }
     return JS_UNDEFINED;
 }
@@ -14556,11 +15366,16 @@ static JSValue js_function_proto_fileName(JSContext *ctx,
 }
 
 static JSValue js_function_proto_lineNumber(JSContext *ctx,
-                                            JSValueConst this_val)
+                                            JSValueConst this_val, int is_col)
 {
     JSFunctionBytecode *b = JS_GetFunctionBytecode(this_val);
     if (b && b->has_debug) {
-        return JS_NewInt32(ctx, b->debug.line_num);
+        int line_num, col_num;
+        line_num = find_line_num(ctx, b, -1, &col_num);
+        if (is_col)
+            return JS_NewInt32(ctx, col_num);
+        else
+            return JS_NewInt32(ctx, line_num);
     }
     return JS_UNDEFINED;
 }
@@ -14604,16 +15419,16 @@ static JSValue js_build_arguments(JSContext *ctx, int argc, JSValueConst *argv)
     /* add the length field (cannot fail) */
     pr = add_property(ctx, p, JS_ATOM_length,
                       JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    if (unlikely(!pr))
+        goto fail;
     pr->u.value = JS_NewInt32(ctx, argc);
 
     /* initialize the fast array part */
     tab = NULL;
     if (argc > 0) {
         tab = js_malloc(ctx, sizeof(tab[0]) * argc);
-        if (!tab) {
-            JS_FreeValue(ctx, val);
-            return JS_EXCEPTION;
-        }
+        if (!tab)
+            goto fail;
         for(i = 0; i < argc; i++) {
             tab[i] = JS_DupValue(ctx, argv[i]);
         }
@@ -14629,6 +15444,9 @@ static JSValue js_build_arguments(JSContext *ctx, int argc, JSValueConst *argv)
                       ctx->throw_type_error, ctx->throw_type_error,
                       JS_PROP_HAS_GET | JS_PROP_HAS_SET);
     return val;
+ fail:
+    JS_FreeValue(ctx, val);
+    return JS_EXCEPTION;
 }
 
 #define GLOBAL_VAR_OFFSET 0x40000000
@@ -14653,6 +15471,8 @@ static JSValue js_build_mapped_arguments(JSContext *ctx, int argc,
     /* add the length field (cannot fail) */
     pr = add_property(ctx, p, JS_ATOM_length,
                       JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    if (unlikely(!pr))
+        goto fail;
     pr->u.value = JS_NewInt32(ctx, argc);
 
     for(i = 0; i < arg_count; i++) {
@@ -14712,10 +15532,10 @@ static JSValue js_build_rest(JSContext *ctx, int first, int argc, JSValueConst *
 
 static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
 {
-    JSObject *p;
+    JSObject *p, *p1;
     JSPropertyEnum *tab_atom;
     int i;
-    JSValue enum_obj, obj1;
+    JSValue enum_obj;
     JSForInIterator *it;
     uint32_t tag, tab_atom_count;
 
@@ -14738,40 +15558,16 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
     it->is_array = FALSE;
     it->obj = obj;
     it->idx = 0;
-    p = JS_VALUE_GET_OBJ(enum_obj);
-    p->u.for_in_iterator = it;
+    it->tab_atom = NULL;
+    it->atom_count = 0;
+    it->in_prototype_chain = FALSE;
+    p1 = JS_VALUE_GET_OBJ(enum_obj);
+    p1->u.for_in_iterator = it;
 
     if (tag == JS_TAG_NULL || tag == JS_TAG_UNDEFINED)
         return enum_obj;
 
-    /* fast path: assume no enumerable properties in the prototype chain */
-    obj1 = JS_DupValue(ctx, obj);
-    for(;;) {
-        obj1 = JS_GetPrototypeFree(ctx, obj1);
-        if (JS_IsNull(obj1))
-            break;
-        if (JS_IsException(obj1))
-            goto fail;
-        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
-                                           JS_VALUE_GET_OBJ(obj1),
-                                           JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY)) {
-            JS_FreeValue(ctx, obj1);
-            goto fail;
-        }
-        js_free_prop_enum(ctx, tab_atom, tab_atom_count);
-        if (tab_atom_count != 0) {
-            JS_FreeValue(ctx, obj1);
-            goto slow_path;
-        }
-        /* must check for timeout to avoid infinite loop */
-        if (js_poll_interrupts(ctx)) {
-            JS_FreeValue(ctx, obj1);
-            goto fail;
-        }
-    }
-
     p = JS_VALUE_GET_OBJ(obj);
-
     if (p->fast_array) {
         JSShape *sh;
         JSShapeProperty *prs;
@@ -14783,61 +15579,90 @@ static JSValue build_for_in_iterator(JSContext *ctx, JSValue obj)
         }
         /* for fast arrays, we only store the number of elements */
         it->is_array = TRUE;
-        it->array_length = p->u.array.count;
+        it->atom_count = p->u.array.count;
     } else {
     normal_case:
         if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
-                                   JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY))
-            goto fail;
-        for(i = 0; i < tab_atom_count; i++) {
-            JS_SetPropertyInternal(ctx, enum_obj, tab_atom[i].atom, JS_NULL, enum_obj, 0);
+                                           JS_GPN_STRING_MASK | JS_GPN_SET_ENUM)) {
+            JS_FreeValue(ctx, enum_obj);
+            return JS_EXCEPTION;
         }
-        js_free_prop_enum(ctx, tab_atom, tab_atom_count);
+        it->tab_atom = tab_atom;
+        it->atom_count = tab_atom_count;
     }
     return enum_obj;
+}
 
- slow_path:
-    /* non enumerable properties hide the enumerables ones in the
-       prototype chain */
-    obj1 = JS_DupValue(ctx, obj);
+/* obj -> enum_obj */
+static __exception int js_for_in_start(JSContext *ctx, JSValue *sp)
+{
+    sp[-1] = build_for_in_iterator(ctx, sp[-1]);
+    if (JS_IsException(sp[-1]))
+        return -1;
+    return 0;
+}
+
+/* return -1 if exception, 0 if slow case, 1 if the enumeration is finished */
+static __exception int js_for_in_prepare_prototype_chain_enum(JSContext *ctx,
+                                                              JSValueConst enum_obj)
+{
+    JSObject *p;
+    JSForInIterator *it;
+    JSPropertyEnum *tab_atom;
+    uint32_t tab_atom_count, i;
+    JSValue obj1;
+
+    p = JS_VALUE_GET_OBJ(enum_obj);
+    it = p->u.for_in_iterator;
+
+    /* check if there are enumerable properties in the prototype chain (fast path) */
+    obj1 = JS_DupValue(ctx, it->obj);
     for(;;) {
+        obj1 = JS_GetPrototypeFree(ctx, obj1);
+        if (JS_IsNull(obj1))
+            break;
+        if (JS_IsException(obj1))
+            goto fail;
         if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
                                            JS_VALUE_GET_OBJ(obj1),
-                                           JS_GPN_STRING_MASK | JS_GPN_SET_ENUM)) {
+                                           JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY)) {
             JS_FreeValue(ctx, obj1);
             goto fail;
         }
-        for(i = 0; i < tab_atom_count; i++) {
-            JS_DefinePropertyValue(ctx, enum_obj, tab_atom[i].atom, JS_NULL,
-                                   (tab_atom[i].is_enumerable ?
-                                    JS_PROP_ENUMERABLE : 0));
+        JS_FreePropertyEnum(ctx, tab_atom, tab_atom_count);
+        if (tab_atom_count != 0) {
+            JS_FreeValue(ctx, obj1);
+            goto slow_path;
         }
-        js_free_prop_enum(ctx, tab_atom, tab_atom_count);
-        obj1 = JS_GetPrototypeFree(ctx, obj1);
-        if (JS_IsNull(obj1))
-            break;
-        if (JS_IsException(obj1))
-            goto fail;
         /* must check for timeout to avoid infinite loop */
         if (js_poll_interrupts(ctx)) {
             JS_FreeValue(ctx, obj1);
             goto fail;
         }
     }
-    return enum_obj;
+    JS_FreeValue(ctx, obj1);
+    return 1;
 
- fail:
-    JS_FreeValue(ctx, enum_obj);
-    return JS_EXCEPTION;
-}
+ slow_path:
+    /* add the visited properties, even if they are not enumerable */
+    if (it->is_array) {
+        if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
+                                           JS_VALUE_GET_OBJ(it->obj),
+                                           JS_GPN_STRING_MASK | JS_GPN_SET_ENUM)) {
+            goto fail;
+        }
+        it->is_array = FALSE;
+        it->tab_atom = tab_atom;
+        it->atom_count = tab_atom_count;
+    }
 
-/* obj -> enum_obj */
-static __exception int js_for_in_start(JSContext *ctx, JSValue *sp)
-{
-    sp[-1] = build_for_in_iterator(ctx, sp[-1]);
-    if (JS_IsException(sp[-1]))
-        return -1;
+    for(i = 0; i < it->atom_count; i++) {
+        if (JS_DefinePropertyValue(ctx, enum_obj, it->tab_atom[i].atom, JS_NULL, JS_PROP_ENUMERABLE) < 0)
+            goto fail;
+    }
     return 0;
+ fail:
+    return -1;
 }
 
 /* enum_obj -> enum_obj value done */
@@ -14847,6 +15672,8 @@ static __exception int js_for_in_next(JSContext *ctx, JSValue *sp)
     JSObject *p;
     JSAtom prop;
     JSForInIterator *it;
+    JSPropertyEnum *tab_atom;
+    uint32_t tab_atom_count;
     int ret;
 
     enum_obj = sp[-1];
@@ -14859,28 +15686,68 @@ static __exception int js_for_in_next(JSContext *ctx, JSValue *sp)
     it = p->u.for_in_iterator;
 
     for(;;) {
-        if (it->is_array) {
-            if (it->idx >= it->array_length)
-                goto done;
-            prop = __JS_AtomFromUInt32(it->idx);
-            it->idx++;
+        if (it->idx >= it->atom_count) {
+            if (JS_IsNull(it->obj) || JS_IsUndefined(it->obj))
+                goto done; /* not an object */
+            /* no more property in the current object: look in the prototype */
+            if (!it->in_prototype_chain) {
+                ret = js_for_in_prepare_prototype_chain_enum(ctx, enum_obj);
+                if (ret < 0)
+                    return -1;
+                if (ret)
+                    goto done;
+                it->in_prototype_chain = TRUE;
+            }
+            it->obj = JS_GetPrototypeFree(ctx, it->obj);
+            if (JS_IsException(it->obj))
+                return -1;
+            if (JS_IsNull(it->obj))
+                goto done; /* no more prototype */
+
+            /* must check for timeout to avoid infinite loop */
+            if (js_poll_interrupts(ctx))
+                return -1;
+
+            if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count,
+                                               JS_VALUE_GET_OBJ(it->obj),
+                                               JS_GPN_STRING_MASK | JS_GPN_SET_ENUM)) {
+                return -1;
+            }
+            JS_FreePropertyEnum(ctx, it->tab_atom, it->atom_count);
+            it->tab_atom = tab_atom;
+            it->atom_count = tab_atom_count;
+            it->idx = 0;
         } else {
-            JSShape *sh = p->shape;
-            JSShapeProperty *prs;
-            if (it->idx >= sh->prop_count)
-                goto done;
-            prs = get_shape_prop(sh) + it->idx;
-            prop = prs->atom;
-            it->idx++;
-            if (prop == JS_ATOM_NULL || !(prs->flags & JS_PROP_ENUMERABLE))
-                continue;
+            if (it->is_array) {
+                prop = __JS_AtomFromUInt32(it->idx);
+                it->idx++;
+            } else {
+                BOOL is_enumerable;
+                prop = it->tab_atom[it->idx].atom;
+                is_enumerable = it->tab_atom[it->idx].is_enumerable;
+                it->idx++;
+                if (it->in_prototype_chain) {
+                    /* slow case: we are in the prototype chain */
+                    ret = JS_GetOwnPropertyInternal(ctx, NULL, JS_VALUE_GET_OBJ(enum_obj), prop);
+                    if (ret < 0)
+                        return ret;
+                    if (ret)
+                        continue; /* already visited */
+                    /* add to the visited property list */
+                    if (JS_DefinePropertyValue(ctx, enum_obj, prop, JS_NULL,
+                                               JS_PROP_ENUMERABLE) < 0)
+                        return -1;
+                }
+                if (!is_enumerable)
+                    continue;
+            }
+            /* check if the property was deleted */
+            ret = JS_GetOwnPropertyInternal(ctx, NULL, JS_VALUE_GET_OBJ(it->obj), prop);
+            if (ret < 0)
+                return ret;
+            if (ret)
+                break;
         }
-        /* check if the property was deleted */
-        ret = JS_HasProperty(ctx, it->obj, prop);
-        if (ret < 0)
-            return ret;
-        if (ret)
-            break;
     }
     /* return the property */
     sp[0] = JS_AtomToValue(ctx, prop);
@@ -14983,6 +15850,7 @@ static JSValue JS_IteratorNext2(JSContext *ctx, JSValueConst enum_obj,
     return JS_EXCEPTION;
 }
 
+/* Note: always return JS_UNDEFINED when *pdone = TRUE. */
 static JSValue JS_IteratorNext(JSContext *ctx, JSValueConst enum_obj,
                                JSValueConst method,
                                int argc, JSValueConst *argv, BOOL *pdone)
@@ -14993,9 +15861,13 @@ static JSValue JS_IteratorNext(JSContext *ctx, JSValueConst enum_obj,
     obj = JS_IteratorNext2(ctx, enum_obj, method, argc, argv, &done);
     if (JS_IsException(obj))
         goto fail;
-    if (done != 2) {
-        *pdone = done;
+    if (likely(done == 0)) {
+        *pdone = FALSE;
         return obj;
+    } else if (done != 2) {
+        JS_FreeValue(ctx, obj);
+        *pdone = TRUE;
+        return JS_UNDEFINED;
     } else {
         done_val = JS_GetProperty(ctx, obj, JS_ATOM_done);
         if (JS_IsException(done_val))
@@ -15023,7 +15895,7 @@ static int JS_IteratorClose(JSContext *ctx, JSValueConst enum_obj,
 
     if (is_exception_pending) {
         ex_obj = ctx->rt->current_exception;
-        ctx->rt->current_exception = JS_NULL;
+        ctx->rt->current_exception = JS_UNINITIALIZED;
         res = -1;
     } else {
         ex_obj = JS_UNDEFINED;
@@ -15103,6 +15975,21 @@ static __exception int js_for_of_next(JSContext *ctx, JSValue *sp, int offset)
     return 0;
 }
 
+static __exception int js_for_await_of_next(JSContext *ctx, JSValue *sp)
+{
+    JSValue obj, iter, next;
+
+    sp[-1] = JS_UNDEFINED; /* disable the catch offset so that
+                              exceptions do not close the iterator */
+    iter = sp[-3];
+    next = sp[-2];
+    obj = JS_Call(ctx, next, iter, 0, NULL);
+    if (JS_IsException(obj))
+        return -1;
+    sp[0] = obj;
+    return 0;
+}
+
 static JSValue JS_IteratorGetCompleteValue(JSContext *ctx, JSValueConst obj,
                                            BOOL *pdone)
 {
@@ -15135,6 +16022,9 @@ static __exception int js_iterator_get_value_done(JSContext *ctx, JSValue *sp)
     if (JS_IsException(value))
         return -1;
     JS_FreeValue(ctx, obj);
+    /* put again the catch offset so that exceptions close the
+       iterator */
+    sp[-2] = JS_NewCatchOffset(ctx, 0); 
     sp[-1] = value;
     sp[0] = JS_NewBool(ctx, done);
     return 0;
@@ -15204,7 +16094,7 @@ static __exception int js_append_enumerate(JSContext *ctx, JSValue *sp)
     int is_array_iterator;
     JSValue *arrp;
     uint32_t i, count32, pos;
-    
+
     if (JS_VALUE_GET_TAG(sp[-2]) != JS_TAG_INT) {
         JS_ThrowInternalError(ctx, "invalid index for append");
         return -1;
@@ -15292,7 +16182,7 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
     int ret, gpn_flags;
     JSPropertyDescriptor desc;
     BOOL is_enumerable;
-    
+
     if (JS_VALUE_GET_TAG(source) != JS_TAG_OBJECT)
         return 0;
 
@@ -15313,7 +16203,7 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
     if (JS_GetOwnPropertyNamesInternal(ctx, &tab_atom, &tab_atom_count, p,
                                        gpn_flags))
         return -1;
-    
+
     for (i = 0; i < tab_atom_count; i++) {
         if (pexcl) {
             ret = JS_GetOwnPropertyInternal(ctx, NULL, pexcl, tab_atom[i].atom);
@@ -15346,10 +16236,10 @@ static __exception int JS_CopyDataProperties(JSContext *ctx,
         if (ret < 0)
             goto exception;
     }
-    js_free_prop_enum(ctx, tab_atom, tab_atom_count);
+    JS_FreePropertyEnum(ctx, tab_atom, tab_atom_count);
     return 0;
  exception:
-    js_free_prop_enum(ctx, tab_atom, tab_atom_count);
+    JS_FreePropertyEnum(ctx, tab_atom, tab_atom_count);
     return -1;
 }
 
@@ -15364,10 +16254,16 @@ static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf,
 {
     JSVarRef *var_ref;
     struct list_head *el;
+    JSValue *pvalue;
+
+    if (is_arg)
+        pvalue = &sf->arg_buf[var_idx];
+    else
+        pvalue = &sf->var_buf[var_idx];
 
     list_for_each(el, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, header.link);
-        if (var_ref->var_idx == var_idx && var_ref->is_arg == is_arg) {
+        var_ref = list_entry(el, JSVarRef, var_ref_link);
+        if (var_ref->pvalue == pvalue) {
             var_ref->header.ref_count++;
             return var_ref;
         }
@@ -15377,15 +16273,24 @@ static JSVarRef *get_var_ref(JSContext *ctx, JSStackFrame *sf,
     if (!var_ref)
         return NULL;
     var_ref->header.ref_count = 1;
+    add_gc_object(ctx->rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
     var_ref->is_detached = FALSE;
-    var_ref->is_arg = is_arg;
-    var_ref->var_idx = var_idx;
-    list_add_tail(&var_ref->header.link, &sf->var_ref_list);
-    if (is_arg)
-        var_ref->pvalue = &sf->arg_buf[var_idx];
-    else
-        var_ref->pvalue = &sf->var_buf[var_idx];
-    var_ref->value = JS_UNDEFINED;
+    list_add_tail(&var_ref->var_ref_link, &sf->var_ref_list);
+    if (sf->js_mode & JS_MODE_ASYNC) {
+        /* The stack frame is detached and may be destroyed at any
+           time so its reference count must be increased. Calling
+           close_var_refs() when destroying the stack frame is not
+           possible because it would change the graph between the GC
+           objects. Another solution could be to temporarily detach
+           the JSVarRef of async functions during the GC. It would
+           have the advantage of allowing the release of unused stack
+           frames in a cycle. */
+        var_ref->async_func = container_of(sf, JSAsyncFunctionState, frame);
+        var_ref->async_func->header.ref_count++;
+    } else {
+        var_ref->async_func = NULL;
+    }
+    var_ref->pvalue = pvalue;
     return var_ref;
 }
 
@@ -15613,37 +16518,36 @@ static void close_var_refs(JSRuntime *rt, JSStackFrame *sf)
 {
     struct list_head *el, *el1;
     JSVarRef *var_ref;
-    int var_idx;
 
     list_for_each_safe(el, el1, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, header.link);
-        var_idx = var_ref->var_idx;
-        if (var_ref->is_arg)
-            var_ref->value = JS_DupValueRT(rt, sf->arg_buf[var_idx]);
-        else
-            var_ref->value = JS_DupValueRT(rt, sf->var_buf[var_idx]);
+        var_ref = list_entry(el, JSVarRef, var_ref_link);
+        /* no need to unlink var_ref->var_ref_link as the list is never used afterwards */
+        if (var_ref->async_func)
+            async_func_free(rt, var_ref->async_func);
+        var_ref->value = JS_DupValueRT(rt, *var_ref->pvalue);
         var_ref->pvalue = &var_ref->value;
         /* the reference is no longer to a local variable */
         var_ref->is_detached = TRUE;
-        add_gc_object(rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
     }
 }
 
-static void close_lexical_var(JSContext *ctx, JSStackFrame *sf, int idx, int is_arg)
+static void close_lexical_var(JSContext *ctx, JSStackFrame *sf, int var_idx)
 {
+    JSValue *pvalue;
     struct list_head *el, *el1;
     JSVarRef *var_ref;
-    int var_idx = idx;
 
+    pvalue = &sf->var_buf[var_idx];
     list_for_each_safe(el, el1, &sf->var_ref_list) {
-        var_ref = list_entry(el, JSVarRef, header.link);
-        if (var_idx == var_ref->var_idx && var_ref->is_arg == is_arg) {
-            var_ref->value = JS_DupValue(ctx, sf->var_buf[var_idx]);
+        var_ref = list_entry(el, JSVarRef, var_ref_link);
+        if (var_ref->pvalue == pvalue) {
+            list_del(&var_ref->var_ref_link);
+            if (var_ref->async_func)
+                async_func_free(ctx->rt, var_ref->async_func);
+            var_ref->value = JS_DupValue(ctx, *var_ref->pvalue);
             var_ref->pvalue = &var_ref->value;
-            list_del(&var_ref->header.link);
             /* the reference is no longer to a local variable */
             var_ref->is_detached = TRUE;
-            add_gc_object(ctx->rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
         }
     }
 }
@@ -15676,17 +16580,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     sf->prev_frame = prev_sf;
     rt->current_stack_frame = sf;
     ctx = p->u.cfunc.realm; /* change the current realm */
-    
-#ifdef CONFIG_BIGNUM
-    /* we only propagate the bignum mode as some runtime functions
-       test it */
-    if (prev_sf)
-        sf->js_mode = prev_sf->js_mode & JS_MODE_MATH;
-    else
-        sf->js_mode = 0;
-#else
     sf->js_mode = 0;
-#endif
     sf->cur_func = (JSValue)func_obj;
     sf->arg_count = argc;
     arg_buf = argv;
@@ -15834,9 +16728,10 @@ typedef enum {
     OP_SPECIAL_OBJECT_IMPORT_META,
 } OPSpecialObjectEnum;
 
-#define FUNC_RET_AWAIT      0
-#define FUNC_RET_YIELD      1
-#define FUNC_RET_YIELD_STAR 2
+#define FUNC_RET_AWAIT         0
+#define FUNC_RET_YIELD         1
+#define FUNC_RET_YIELD_STAR    2
+#define FUNC_RET_INITIAL_YIELD 3
 
 /* argv[] is modified if (flags & JS_CALL_FLAG_COPY_ARGV) = 0. */
 static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
@@ -15864,7 +16759,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 #define DEF(id, size, n_pop, n_push, f) && case_OP_ ## id,
 #if SHORT_OPCODES
 #define def(id, size, n_pop, n_push, f)
-#else                                                     
+#else
 #define def(id, size, n_pop, n_push, f) && case_default,
 #endif
 #include "quickjs-opcode.h"
@@ -15958,7 +16853,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
     sf->prev_frame = rt->current_stack_frame;
     rt->current_stack_frame = sf;
     ctx = b->realm; /* set the current realm */
-    
+
  restart:
     for(;;) {
         int call_argc;
@@ -15969,6 +16864,10 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             *sp++ = JS_NewInt32(ctx, get_u32(pc));
             pc += 4;
             BREAK;
+        CASE(OP_push_bigint_i32):
+            *sp++ = __JS_NewShortBigInt(ctx, (int)get_u32(pc));
+            pc += 4;
+            BREAK;
         CASE(OP_push_const):
             *sp++ = JS_DupValue(ctx, b->cpool[get_u32(pc)]);
             pc += 4;
@@ -16008,6 +16907,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSValue val;
 
+                sf->cur_pc = pc;
                 val = JS_GetProperty(ctx, sp[-1], JS_ATOM_length);
                 if (unlikely(JS_IsException(val)))
                     goto exception;
@@ -16360,6 +17260,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 int magic;
                 magic = get_u16(pc);
                 pc += 2;
+                sf->cur_pc = pc;
 
                 ret_val = js_function_apply(ctx, sp[-3], 2, (JSValueConst *)&sp[-2], magic);
                 if (unlikely(JS_IsException(ret_val)))
@@ -16393,13 +17294,37 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_check_ctor):
             if (JS_IsUndefined(new_target)) {
+            non_ctor_call:
                 JS_ThrowTypeError(ctx, "class constructors must be invoked with 'new'");
                 goto exception;
             }
             BREAK;
+        CASE(OP_init_ctor):
+            {
+                JSValue super, ret;
+                sf->cur_pc = pc;
+                if (JS_IsUndefined(new_target))
+                    goto non_ctor_call;
+                super = JS_GetPrototype(ctx, func_obj);
+                if (JS_IsException(super))
+                    goto exception;
+                ret = JS_CallConstructor2(ctx, super, new_target, argc, (JSValueConst *)argv);
+                JS_FreeValue(ctx, super);
+                if (JS_IsException(ret))
+                    goto exception;
+                *sp++ = ret;
+            }
+            BREAK;
         CASE(OP_check_brand):
-            if (JS_CheckBrand(ctx, sp[-2], sp[-1]) < 0)
-                goto exception;
+            {
+                int ret = JS_CheckBrand(ctx, sp[-2], sp[-1]);
+                if (ret < 0)
+                    goto exception;
+                if (!ret) {
+                    JS_ThrowTypeError(ctx, "invalid brand on object");
+                    goto exception;
+                }
+            }
             BREAK;
         CASE(OP_add_brand):
             if (JS_AddBrand(ctx, sp[-2], sp[-1]) < 0)
@@ -16408,7 +17333,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             JS_FreeValue(ctx, sp[-1]);
             sp -= 2;
             BREAK;
-            
+
         CASE(OP_throw):
             JS_Throw(ctx, *--sp);
             goto exception;
@@ -16449,7 +17374,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSValueConst obj;
                 int scope_idx;
                 call_argc = get_u16(pc);
-                scope_idx = get_u16(pc + 2) - 1;
+                scope_idx = get_u16(pc + 2) + ARG_SCOPE_END;
                 pc += 4;
                 call_argv = sp - call_argc;
                 sf->cur_pc = pc;
@@ -16480,8 +17405,9 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSValue *tab;
                 JSValueConst obj;
 
-                scope_idx = get_u16(pc) - 1;
+                scope_idx = get_u16(pc) + ARG_SCOPE_END;
                 pc += 2;
+                sf->cur_pc = pc;
                 tab = build_arg_list(ctx, &len, sp[-1]);
                 if (!tab)
                     goto exception;
@@ -16517,6 +17443,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
         CASE(OP_get_super):
             {
                 JSValue proto;
+                sf->cur_pc = pc;
                 proto = JS_GetPrototype(ctx, sp[-1]);
                 if (JS_IsException(proto))
                     goto exception;
@@ -16528,10 +17455,13 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
         CASE(OP_import):
             {
                 JSValue val;
-                val = js_dynamic_import(ctx, sp[-1]);
+                sf->cur_pc = pc;
+                val = js_dynamic_import(ctx, sp[-2], sp[-1]);
                 if (JS_IsException(val))
                     goto exception;
+                JS_FreeValue(ctx, sp[-2]);
                 JS_FreeValue(ctx, sp[-1]);
+                sp--;
                 sp[-1] = val;
             }
             BREAK;
@@ -16542,6 +17472,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 ret = JS_CheckGlobalVar(ctx, atom);
                 if (ret < 0)
@@ -16557,6 +17488,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 val = JS_GetGlobalVar(ctx, atom, opcode - OP_get_var_undef);
                 if (unlikely(JS_IsException(val)))
@@ -16572,6 +17504,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 ret = JS_SetGlobalVar(ctx, atom, sp[-1], opcode - OP_put_var);
                 sp--;
@@ -16586,6 +17519,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 /* sp[-2] is JS_TRUE or JS_FALSE */
                 if (unlikely(!JS_VALUE_GET_INT(sp[-2]))) {
@@ -16606,6 +17540,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 flags = pc[4];
                 pc += 5;
+                sf->cur_pc = pc;
                 if (JS_CheckDefineGlobalVar(ctx, atom, flags))
                     goto exception;
             }
@@ -16617,6 +17552,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 flags = pc[4];
                 pc += 5;
+                sf->cur_pc = pc;
                 if (JS_DefineGlobalVar(ctx, atom, flags))
                     goto exception;
             }
@@ -16628,6 +17564,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 flags = pc[4];
                 pc += 5;
+                sf->cur_pc = pc;
                 if (JS_DefineGlobalFunction(ctx, atom, sp[-1], flags))
                     goto exception;
                 JS_FreeValue(ctx, sp[-1]);
@@ -16821,6 +17758,19 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 sp++;
             }
             BREAK;
+        CASE(OP_get_loc_checkthis):
+            {
+                int idx;
+                idx = get_u16(pc);
+                pc += 2;
+                if (unlikely(JS_IsUninitialized(var_buf[idx]))) {
+                    JS_ThrowReferenceErrorUninitialized2(caller_ctx, b, idx, FALSE);
+                    goto exception;
+                }
+                sp[0] = JS_DupValue(ctx, var_buf[idx]);
+                sp++;
+            }
+            BREAK;
         CASE(OP_put_loc_check):
             {
                 int idx;
@@ -16852,7 +17802,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 int idx;
                 idx = get_u16(pc);
                 pc += 2;
-                close_lexical_var(ctx, sf, idx, FALSE);
+                close_lexical_var(ctx, sf, idx);
             }
             BREAK;
 
@@ -16893,6 +17843,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 if (JS_GetGlobalVarRef(ctx, atom, sp))
                     goto exception;
@@ -16944,6 +17895,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
                 op1 = sp[-1];
                 pc += 4;
+                /* quick and dirty test for JS_TAG_INT, JS_TAG_BOOL, JS_TAG_NULL and JS_TAG_UNDEFINED */
                 if ((uint32_t)JS_VALUE_GET_TAG(op1) <= JS_TAG_UNDEFINED) {
                     res = JS_VALUE_GET_INT(op1);
                 } else {
@@ -17037,15 +17989,18 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
 
         CASE(OP_for_in_start):
+            sf->cur_pc = pc;
             if (js_for_in_start(ctx, sp))
                 goto exception;
             BREAK;
         CASE(OP_for_in_next):
+            sf->cur_pc = pc;
             if (js_for_in_next(ctx, sp))
                 goto exception;
             sp += 2;
             BREAK;
         CASE(OP_for_of_start):
+            sf->cur_pc = pc;
             if (js_for_of_start(ctx, sp, FALSE))
                 goto exception;
             sp += 1;
@@ -17055,18 +18010,27 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 int offset = -3 - pc[0];
                 pc += 1;
+                sf->cur_pc = pc;
                 if (js_for_of_next(ctx, sp, offset))
                     goto exception;
                 sp += 2;
             }
             BREAK;
+        CASE(OP_for_await_of_next):
+            sf->cur_pc = pc;
+            if (js_for_await_of_next(ctx, sp))
+                goto exception;
+            sp++;
+            BREAK;
         CASE(OP_for_await_of_start):
+            sf->cur_pc = pc;
             if (js_for_of_start(ctx, sp, TRUE))
                 goto exception;
             sp += 1;
             *sp++ = JS_NewCatchOffset(ctx, 0);
             BREAK;
         CASE(OP_iterator_get_value_done):
+            sf->cur_pc = pc;
             if (js_iterator_get_value_done(ctx, sp))
                 goto exception;
             sp += 1;
@@ -17084,32 +18048,28 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             JS_FreeValue(ctx, sp[-1]); /* drop the next method */
             sp--;
             if (!JS_IsUndefined(sp[-1])) {
+                sf->cur_pc = pc;
                 if (JS_IteratorClose(ctx, sp[-1], FALSE))
                     goto exception;
                 JS_FreeValue(ctx, sp[-1]);
             }
             sp--;
             BREAK;
-        CASE(OP_iterator_close_return):
+        CASE(OP_nip_catch):
             {
                 JSValue ret_val;
-                /* iter_obj next catch_offset ... ret_val ->
-                   ret_eval iter_obj next catch_offset */
+                /* catch_offset ... ret_val -> ret_eval */
                 ret_val = *--sp;
                 while (sp > stack_buf &&
                        JS_VALUE_GET_TAG(sp[-1]) != JS_TAG_CATCH_OFFSET) {
                     JS_FreeValue(ctx, *--sp);
                 }
-                if (unlikely(sp < stack_buf + 3)) {
-                    JS_ThrowInternalError(ctx, "iterator_close_return");
+                if (unlikely(sp == stack_buf)) {
+                    JS_ThrowInternalError(ctx, "nip_catch");
                     JS_FreeValue(ctx, ret_val);
                     goto exception;
                 }
-                sp[0] = sp[-1];
-                sp[-1] = sp[-2];
-                sp[-2] = sp[-3];
-                sp[-3] = ret_val;
-                sp++;
+                sp[-1] = ret_val;
             }
             BREAK;
 
@@ -17117,6 +18077,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             /* stack: iter_obj next catch_offset val */
             {
                 JSValue ret;
+                sf->cur_pc = pc;
                 ret = JS_Call(ctx, sp[-3], sp[-4],
                               1, (JSValueConst *)(sp - 1));
                 if (JS_IsException(ret))
@@ -17133,6 +18094,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 BOOL ret_flag;
                 int flags;
                 flags = *pc++;
+                sf->cur_pc = pc;
                 method = JS_GetProperty(ctx, sp[-4], (flags & 1) ?
                                         JS_ATOM_throw : JS_ATOM_return);
                 if (JS_IsException(method))
@@ -17181,6 +18143,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 pc += 4;
 
+                sf->cur_pc = pc;
                 val = JS_GetProperty(ctx, sp[-1], atom);
                 if (unlikely(JS_IsException(val)))
                     goto exception;
@@ -17196,6 +18159,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 atom = get_u32(pc);
                 pc += 4;
 
+                sf->cur_pc = pc;
                 val = JS_GetProperty(ctx, sp[-1], atom);
                 if (unlikely(JS_IsException(val)))
                     goto exception;
@@ -17209,6 +18173,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 JSAtom atom;
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
                 ret = JS_SetPropertyInternal(ctx, sp[-2], atom, sp[-1], sp[-2],
                                              JS_PROP_THROW_STRICT);
@@ -17223,7 +18188,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSAtom atom;
                 JSValue val;
-                
+
                 atom = get_u32(pc);
                 pc += 4;
                 val = JS_NewSymbolFromAtom(ctx, atom, JS_ATOM_TYPE_PRIVATE);
@@ -17232,7 +18197,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 *sp++ = val;
             }
             BREAK;
-            
+
         CASE(OP_get_private_field):
             {
                 JSValue val;
@@ -17308,6 +18273,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
         CASE(OP_set_proto):
             {
                 JSValue proto;
+                sf->cur_pc = pc;
                 proto = sp[-1];
                 if (JS_IsObject(proto) || JS_IsNull(proto)) {
                     if (JS_SetPrototypeInternal(ctx, sp[-2], proto, TRUE) < 0)
@@ -17385,7 +18351,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 int class_flags;
                 JSAtom atom;
-                
+
                 atom = get_u32(pc);
                 class_flags = pc[4];
                 pc += 5;
@@ -17400,6 +18366,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSValue val;
 
+                sf->cur_pc = pc;
                 val = JS_GetPropertyValue(ctx, sp[-2], sp[-1]);
                 JS_FreeValue(ctx, sp[-2]);
                 sp[-2] = val;
@@ -17413,6 +18380,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSValue val;
 
+                sf->cur_pc = pc;
                 val = JS_GetPropertyValue(ctx, sp[-2], sp[-1]);
                 sp[-1] = val;
                 if (unlikely(JS_IsException(val)))
@@ -17420,19 +18388,69 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
 
+        CASE(OP_get_array_el3):
+            {
+                JSValue val;
+
+                switch (JS_VALUE_GET_TAG(sp[-2])) {
+                case JS_TAG_INT:
+                case JS_TAG_STRING:
+                case JS_TAG_SYMBOL:
+                    /* undefined and null are tested in JS_GetPropertyValue() */
+                    break;
+                default:
+                    /* must be tested nefore JS_ToPropertyKey */
+                    if (unlikely(JS_IsUndefined(sp[-2]) || JS_IsNull(sp[-2]))) {
+                        JS_ThrowTypeError(ctx, "value has no property");
+                        goto exception;
+                    }
+                    sf->cur_pc = pc;
+                    ret_val = JS_ToPropertyKey(ctx, sp[-1]);
+                    if (JS_IsException(ret_val))
+                        goto exception;
+                    JS_FreeValue(ctx, sp[-1]);
+                    sp[-1] = ret_val;
+                    break;
+                }
+                sf->cur_pc = pc;
+                val = JS_GetPropertyValue(ctx, sp[-2], JS_DupValue(ctx, sp[-1]));
+                *sp++ = val;
+                if (unlikely(JS_IsException(val)))
+                    goto exception;
+            }
+            BREAK;
+            
         CASE(OP_get_ref_value):
             {
                 JSValue val;
+                JSAtom atom;
+                int ret;
+                
+                sf->cur_pc = pc;
+                atom = JS_ValueToAtom(ctx, sp[-1]);
+                if (atom == JS_ATOM_NULL)
+                    goto exception;
                 if (unlikely(JS_IsUndefined(sp[-2]))) {
-                    JSAtom atom = JS_ValueToAtom(ctx, sp[-1]);
-                    if (atom != JS_ATOM_NULL) {
-                        JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                    JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                    JS_FreeAtom(ctx, atom);
+                    goto exception;
+                }
+                ret = JS_HasProperty(ctx, sp[-2], atom);
+                if (unlikely(ret <= 0)) {
+                    if (ret < 0) {
                         JS_FreeAtom(ctx, atom);
+                        goto exception;
                     }
-                    goto exception;
+                    if (is_strict_mode(ctx)) {
+                        JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                        JS_FreeAtom(ctx, atom);
+                        goto exception;
+                    } 
+                    val = JS_UNDEFINED;
+                } else {
+                    val = JS_GetProperty(ctx, sp[-2], atom);
                 }
-                val = JS_GetPropertyValue(ctx, sp[-2],
-                                          JS_DupValue(ctx, sp[-1]));
+                JS_FreeAtom(ctx, atom);
                 if (unlikely(JS_IsException(val)))
                     goto exception;
                 sp[0] = val;
@@ -17444,6 +18462,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSValue val;
                 JSAtom atom;
+                sf->cur_pc = pc;
                 atom = JS_ValueToAtom(ctx, sp[-1]);
                 if (unlikely(atom == JS_ATOM_NULL))
                     goto exception;
@@ -17463,6 +18482,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 int ret;
 
+                sf->cur_pc = pc;
                 ret = JS_SetPropertyValue(ctx, sp[-3], sp[-2], sp[-1], JS_PROP_THROW_STRICT);
                 JS_FreeValue(ctx, sp[-3]);
                 sp -= 3;
@@ -17473,24 +18493,36 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
         CASE(OP_put_ref_value):
             {
-                int ret, flags;
-                flags = JS_PROP_THROW_STRICT;
+                int ret;
+                JSAtom atom;
+                sf->cur_pc = pc;
+                atom = JS_ValueToAtom(ctx, sp[-2]);
+                if (unlikely(atom == JS_ATOM_NULL))
+                    goto exception;
                 if (unlikely(JS_IsUndefined(sp[-3]))) {
                     if (is_strict_mode(ctx)) {
-                        JSAtom atom = JS_ValueToAtom(ctx, sp[-2]);
-                        if (atom != JS_ATOM_NULL) {
-                            JS_ThrowReferenceErrorNotDefined(ctx, atom);
-                            JS_FreeAtom(ctx, atom);
-                        }
+                        JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                        JS_FreeAtom(ctx, atom);
                         goto exception;
                     } else {
                         sp[-3] = JS_DupValue(ctx, ctx->global_obj);
                     }
-                } else {
-                    if (is_strict_mode(ctx))
-                        flags |= JS_PROP_NO_ADD;
                 }
-                ret = JS_SetPropertyValue(ctx, sp[-3], sp[-2], sp[-1], flags);
+                ret = JS_HasProperty(ctx, sp[-3], atom);
+                if (unlikely(ret <= 0)) {
+                    if (unlikely(ret < 0)) {
+                        JS_FreeAtom(ctx, atom);
+                        goto exception;
+                    }
+                    if (is_strict_mode(ctx)) {
+                        JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                        JS_FreeAtom(ctx, atom);
+                        goto exception;
+                    }
+                }
+                ret = JS_SetPropertyInternal(ctx, sp[-3], atom, sp[-1], sp[-3], JS_PROP_THROW_STRICT);
+                JS_FreeAtom(ctx, atom);
+                JS_FreeValue(ctx, sp[-2]);
                 JS_FreeValue(ctx, sp[-3]);
                 sp -= 3;
                 if (unlikely(ret < 0))
@@ -17502,6 +18534,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 int ret;
                 JSAtom atom;
+                sf->cur_pc = pc;
                 if (JS_VALUE_GET_TAG(sp[-3]) != JS_TAG_OBJECT) {
                     JS_ThrowTypeErrorNotAnObject(ctx);
                     goto exception;
@@ -17534,6 +18567,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
         CASE(OP_append):    /* array pos enumobj -- array pos */
             {
+                sf->cur_pc = pc;
                 if (js_append_enumerate(ctx, sp))
                     goto exception;
                 JS_FreeValue(ctx, *--sp);
@@ -17549,6 +18583,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 int mask;
 
                 mask = *pc++;
+                sf->cur_pc = pc;
                 if (JS_CopyDataProperties(ctx, sp[-1 - (mask & 3)],
                                           sp[-1 - ((mask >> 2) & 7)],
                                           sp[-1 - ((mask >> 5) & 7)], 0))
@@ -17572,8 +18607,14 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     sp[-2] = __JS_NewFloat64(ctx, JS_VALUE_GET_FLOAT64(op1) +
                                              JS_VALUE_GET_FLOAT64(op2));
                     sp--;
+                } else if (JS_IsString(op1) && JS_IsString(op2)) {
+                    sp[-2] = JS_ConcatString(ctx, op1, op2);
+                    sp--;
+                    if (JS_IsException(sp[-1]))
+                        goto exception;
                 } else {
                 add_slow:
+                    sf->cur_pc = pc;
                     if (js_add_slow(ctx, sp))
                         goto exception;
                     sp--;
@@ -17582,38 +18623,47 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_add_loc):
             {
+                JSValue op2;
                 JSValue *pv;
                 int idx;
                 idx = *pc;
                 pc += 1;
 
+                op2 = sp[-1];
                 pv = &var_buf[idx];
-                if (likely(JS_VALUE_IS_BOTH_INT(*pv, sp[-1]))) {
+                if (likely(JS_VALUE_IS_BOTH_INT(*pv, op2))) {
                     int64_t r;
-                    r = (int64_t)JS_VALUE_GET_INT(*pv) +
-                        JS_VALUE_GET_INT(sp[-1]);
+                    r = (int64_t)JS_VALUE_GET_INT(*pv) + JS_VALUE_GET_INT(op2);
                     if (unlikely((int)r != r))
                         goto add_loc_slow;
                     *pv = JS_NewInt32(ctx, r);
                     sp--;
+                } else if (JS_VALUE_IS_BOTH_FLOAT(*pv, op2)) {
+                    *pv = __JS_NewFloat64(ctx, JS_VALUE_GET_FLOAT64(*pv) +
+                                               JS_VALUE_GET_FLOAT64(op2));
+                    sp--;
                 } else if (JS_VALUE_GET_TAG(*pv) == JS_TAG_STRING) {
-                    JSValue op1;
-                    op1 = sp[-1];
                     sp--;
-                    op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
-                    if (JS_IsException(op1))
-                        goto exception;
-                    op1 = JS_ConcatString(ctx, JS_DupValue(ctx, *pv), op1);
-                    if (JS_IsException(op1))
+                    sf->cur_pc = pc;
+                    op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
+                    if (JS_IsException(op2))
                         goto exception;
-                    set_value(ctx, pv, op1);
+                    if (JS_ConcatStringInPlace(ctx, JS_VALUE_GET_STRING(*pv), op2)) {
+                        JS_FreeValue(ctx, op2);
+                    } else {
+                        op2 = JS_ConcatString(ctx, JS_DupValue(ctx, *pv), op2);
+                        if (JS_IsException(op2))
+                            goto exception;
+                        set_value(ctx, pv, op2);
+                    }
                 } else {
                     JSValue ops[2];
                 add_loc_slow:
                     /* In case of exception, js_add_slow frees ops[0]
                        and ops[1], so we must duplicate *pv */
+                    sf->cur_pc = pc;
                     ops[0] = JS_DupValue(ctx, *pv);
-                    ops[1] = sp[-1];
+                    ops[1] = op2;
                     sp--;
                     if (js_add_slow(ctx, ops + 2))
                         goto exception;
@@ -17655,11 +18705,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     v2 = JS_VALUE_GET_INT(op2);
                     r = (int64_t)v1 * v2;
                     if (unlikely((int)r != r)) {
-#ifdef CONFIG_BIGNUM
-                        if (unlikely(sf->js_mode & JS_MODE_MATH) &&
-                            (r < -MAX_SAFE_INTEGER || r > MAX_SAFE_INTEGER))
-                            goto binary_arith_slow;
-#endif
                         d = (double)r;
                         goto mul_fp_res;
                     }
@@ -17671,10 +18716,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     sp[-2] = JS_NewInt32(ctx, r);
                     sp--;
                 } else if (JS_VALUE_IS_BOTH_FLOAT(op1, op2)) {
-#ifdef CONFIG_BIGNUM
-                    if (unlikely(sf->js_mode & JS_MODE_MATH))
-                        goto binary_arith_slow;
-#endif
                     d = JS_VALUE_GET_FLOAT64(op1) * JS_VALUE_GET_FLOAT64(op2);
                 mul_fp_res:
                     sp[-2] = __JS_NewFloat64(ctx, d);
@@ -17691,8 +18732,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 op2 = sp[-1];
                 if (likely(JS_VALUE_IS_BOTH_INT(op1, op2))) {
                     int v1, v2;
-                    if (unlikely(sf->js_mode & JS_MODE_MATH))
-                        goto binary_arith_slow;
                     v1 = JS_VALUE_GET_INT(op1);
                     v2 = JS_VALUE_GET_INT(op2);
                     sp[-2] = JS_NewFloat64(ctx, (double)v1 / (double)v2);
@@ -17703,9 +18742,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
         CASE(OP_mod):
-#ifdef CONFIG_BIGNUM
-        CASE(OP_math_mod):
-#endif
             {
                 JSValue op1, op2;
                 op1 = sp[-2];
@@ -17728,6 +18764,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_pow):
         binary_arith_slow:
+            sf->cur_pc = pc;
             if (js_binary_arith_slow(ctx, sp, opcode))
                 goto exception;
             sp--;
@@ -17741,6 +18778,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 tag = JS_VALUE_GET_TAG(op1);
                 if (tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag)) {
                 } else {
+                    sf->cur_pc = pc;
                     if (js_unary_arith_slow(ctx, sp, opcode))
                         goto exception;
                 }
@@ -17771,6 +18809,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 neg_fp_res:
                     sp[-1] = __JS_NewFloat64(ctx, d);
                 } else {
+                    sf->cur_pc = pc;
                     if (js_unary_arith_slow(ctx, sp, opcode))
                         goto exception;
                 }
@@ -17788,6 +18827,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     sp[-1] = JS_NewInt32(ctx, val + 1);
                 } else {
                 inc_slow:
+                    sf->cur_pc = pc;
                     if (js_unary_arith_slow(ctx, sp, opcode))
                         goto exception;
                 }
@@ -17805,6 +18845,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     sp[-1] = JS_NewInt32(ctx, val - 1);
                 } else {
                 dec_slow:
+                    sf->cur_pc = pc;
                     if (js_unary_arith_slow(ctx, sp, opcode))
                         goto exception;
                 }
@@ -17812,6 +18853,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             BREAK;
         CASE(OP_post_inc):
         CASE(OP_post_dec):
+            sf->cur_pc = pc;
             if (js_post_inc_slow(ctx, sp, opcode))
                 goto exception;
             sp++;
@@ -17832,6 +18874,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     var_buf[idx] = JS_NewInt32(ctx, val + 1);
                 } else {
                 inc_loc_slow:
+                    sf->cur_pc = pc;
                     /* must duplicate otherwise the variable value may
                        be destroyed before JS code accesses it */
                     op1 = JS_DupValue(ctx, op1);
@@ -17857,6 +18900,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     var_buf[idx] = JS_NewInt32(ctx, val - 1);
                 } else {
                 dec_loc_slow:
+                    sf->cur_pc = pc;
                     /* must duplicate otherwise the variable value may
                        be destroyed before JS code accesses it */
                     op1 = JS_DupValue(ctx, op1);
@@ -17873,6 +18917,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 if (JS_VALUE_GET_TAG(op1) == JS_TAG_INT) {
                     sp[-1] = JS_NewInt32(ctx, ~JS_VALUE_GET_INT(op1));
                 } else {
+                    sf->cur_pc = pc;
                     if (js_not_slow(ctx, sp))
                         goto exception;
                 }
@@ -17888,28 +18933,11 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     uint32_t v1, v2;
                     v1 = JS_VALUE_GET_INT(op1);
                     v2 = JS_VALUE_GET_INT(op2);
-#ifdef CONFIG_BIGNUM
-                    {
-                        int64_t r;
-                        if (unlikely(sf->js_mode & JS_MODE_MATH)) {
-                            if (v2 > 0x1f)
-                                goto shl_slow;
-                            r = (int64_t)v1 << v2;
-                            if ((int)r != r)
-                                goto shl_slow;
-                        } else {
-                            v2 &= 0x1f;
-                        }
-                    }
-#else
                     v2 &= 0x1f;
-#endif
                     sp[-2] = JS_NewInt32(ctx, v1 << v2);
                     sp--;
                 } else {
-#ifdef CONFIG_BIGNUM
-                shl_slow:
-#endif
+                    sf->cur_pc = pc;
                     if (js_binary_logic_slow(ctx, sp, opcode))
                         goto exception;
                     sp--;
@@ -17924,13 +18952,13 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 if (likely(JS_VALUE_IS_BOTH_INT(op1, op2))) {
                     uint32_t v2;
                     v2 = JS_VALUE_GET_INT(op2);
-                    /* v1 >>> v2 retains its JS semantics if CONFIG_BIGNUM */
                     v2 &= 0x1f;
                     sp[-2] = JS_NewUint32(ctx,
                                           (uint32_t)JS_VALUE_GET_INT(op1) >>
                                           v2);
                     sp--;
                 } else {
+                    sf->cur_pc = pc;
                     if (js_shr_slow(ctx, sp))
                         goto exception;
                     sp--;
@@ -17945,23 +18973,12 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 if (likely(JS_VALUE_IS_BOTH_INT(op1, op2))) {
                     uint32_t v2;
                     v2 = JS_VALUE_GET_INT(op2);
-#ifdef CONFIG_BIGNUM
-                    if (unlikely(v2 > 0x1f)) {
-                        if (unlikely(sf->js_mode & JS_MODE_MATH))
-                            goto sar_slow;
-                        else
-                            v2 &= 0x1f;
-                    }
-#else
                     v2 &= 0x1f;
-#endif
                     sp[-2] = JS_NewInt32(ctx,
                                           (int)JS_VALUE_GET_INT(op1) >> v2);
                     sp--;
                 } else {
-#ifdef CONFIG_BIGNUM
-                sar_slow:
-#endif
+                    sf->cur_pc = pc;
                     if (js_binary_logic_slow(ctx, sp, opcode))
                         goto exception;
                     sp--;
@@ -17979,6 +18996,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                                          JS_VALUE_GET_INT(op2));
                     sp--;
                 } else {
+                    sf->cur_pc = pc;
                     if (js_binary_logic_slow(ctx, sp, opcode))
                         goto exception;
                     sp--;
@@ -17996,6 +19014,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                                          JS_VALUE_GET_INT(op2));
                     sp--;
                 } else {
+                    sf->cur_pc = pc;
                     if (js_binary_logic_slow(ctx, sp, opcode))
                         goto exception;
                     sp--;
@@ -18013,6 +19032,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                                          JS_VALUE_GET_INT(op2));
                     sp--;
                 } else {
+                    sf->cur_pc = pc;
                     if (js_binary_logic_slow(ctx, sp, opcode))
                         goto exception;
                     sp--;
@@ -18031,6 +19051,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     sp[-2] = JS_NewBool(ctx, JS_VALUE_GET_INT(op1) binary_op JS_VALUE_GET_INT(op2)); \
                     sp--;                                               \
                 } else {                                                \
+                    sf->cur_pc = pc;                                    \
                     if (slow_call)                                      \
                         goto exception;                                 \
                     sp--;                                               \
@@ -18047,19 +19068,20 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             OP_CMP(OP_strict_eq, ==, js_strict_eq_slow(ctx, sp, 0));
             OP_CMP(OP_strict_neq, !=, js_strict_eq_slow(ctx, sp, 1));
 
-#ifdef CONFIG_BIGNUM
-        CASE(OP_mul_pow10):
-            if (rt->bigfloat_ops.mul_pow10(ctx, sp))
+        CASE(OP_in):
+            sf->cur_pc = pc;
+            if (js_operator_in(ctx, sp))
                 goto exception;
             sp--;
             BREAK;
-#endif
-        CASE(OP_in):
-            if (js_operator_in(ctx, sp))
+        CASE(OP_private_in):
+            sf->cur_pc = pc;
+            if (js_operator_private_in(ctx, sp))
                 goto exception;
             sp--;
             BREAK;
         CASE(OP_instanceof):
+            sf->cur_pc = pc;
             if (js_operator_instanceof(ctx, sp))
                 goto exception;
             sp--;
@@ -18076,6 +19098,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
         CASE(OP_delete):
+            sf->cur_pc = pc;
             if (js_operator_delete(ctx, sp))
                 goto exception;
             sp--;
@@ -18087,8 +19110,9 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
                 atom = get_u32(pc);
                 pc += 4;
+                sf->cur_pc = pc;
 
-                ret = JS_DeleteProperty(ctx, ctx->global_obj, atom, 0);
+                ret = JS_DeleteGlobalVar(ctx, atom);
                 if (unlikely(ret < 0))
                     goto exception;
                 *sp++ = JS_NewBool(ctx, ret);
@@ -18097,6 +19121,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 
         CASE(OP_to_object):
             if (JS_VALUE_GET_TAG(sp[-1]) != JS_TAG_OBJECT) {
+                sf->cur_pc = pc;
                 ret_val = JS_ToObject(ctx, sp[-1]);
                 if (JS_IsException(ret_val))
                     goto exception;
@@ -18112,6 +19137,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             case JS_TAG_SYMBOL:
                 break;
             default:
+                sf->cur_pc = pc;
                 ret_val = JS_ToPropertyKey(ctx, sp[-1]);
                 if (JS_IsException(ret_val))
                     goto exception;
@@ -18121,26 +19147,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             }
             BREAK;
 
-        CASE(OP_to_propkey2):
-            /* must be tested first */
-            if (unlikely(JS_IsUndefined(sp[-2]) || JS_IsNull(sp[-2]))) {
-                JS_ThrowTypeError(ctx, "value has no property");
-                goto exception;
-            }
-            switch (JS_VALUE_GET_TAG(sp[-1])) {
-            case JS_TAG_INT:
-            case JS_TAG_STRING:
-            case JS_TAG_SYMBOL:
-                break;
-            default:
-                ret_val = JS_ToPropertyKey(ctx, sp[-1]);
-                if (JS_IsException(ret_val))
-                    goto exception;
-                JS_FreeValue(ctx, sp[-1]);
-                sp[-1] = ret_val;
-                break;
-            }
-            BREAK;
 #if 0
         CASE(OP_to_string):
             if (JS_VALUE_GET_TAG(sp[-1]) != JS_TAG_STRING) {
@@ -18157,7 +19163,6 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
         CASE(OP_with_delete_var):
         CASE(OP_with_make_ref):
         CASE(OP_with_get_ref):
-        CASE(OP_with_get_ref_undef):
             {
                 JSAtom atom;
                 int32_t diff;
@@ -18167,6 +19172,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 diff = get_u32(pc + 4);
                 is_with = pc[8];
                 pc += 9;
+                sf->cur_pc = pc;
 
                 obj = sp[-1];
                 ret = JS_HasProperty(ctx, obj, atom);
@@ -18182,13 +19188,34 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     }
                     switch (opcode) {
                     case OP_with_get_var:
-                        val = JS_GetProperty(ctx, obj, atom);
-                        if (unlikely(JS_IsException(val)))
-                            goto exception;
+                        /* in Object Environment Records, GetBindingValue() calls HasProperty() */
+                        ret = JS_HasProperty(ctx, obj, atom);
+                        if (unlikely(ret <= 0)) {
+                            if (ret < 0)
+                                goto exception;
+                            if (is_strict_mode(ctx)) {
+                                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                goto exception;
+                            } 
+                            val = JS_UNDEFINED;
+                        } else {
+                            val = JS_GetProperty(ctx, obj, atom);
+                            if (unlikely(JS_IsException(val)))
+                                goto exception;
+                        }
                         set_value(ctx, &sp[-1], val);
                         break;
-                    case OP_with_put_var:
-                        /* XXX: check if strict mode */
+                    case OP_with_put_var: /* used e.g. in for in/of */
+                        /* in Object Environment Records, SetMutableBinding() calls HasProperty() */
+                        ret = JS_HasProperty(ctx, obj, atom);
+                        if (unlikely(ret <= 0)) {
+                            if (ret < 0)
+                                goto exception;
+                            if (is_strict_mode(ctx)) {
+                                JS_ThrowReferenceErrorNotDefined(ctx, atom);
+                                goto exception;
+                            } 
+                        }
                         ret = JS_SetPropertyInternal(ctx, obj, atom, sp[-2], obj,
                                                      JS_PROP_THROW_STRICT);
                         JS_FreeValue(ctx, sp[-1]);
@@ -18209,18 +19236,17 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                         break;
                     case OP_with_get_ref:
                         /* produce a pair object/method on the stack */
-                        val = JS_GetProperty(ctx, obj, atom);
-                        if (unlikely(JS_IsException(val)))
-                            goto exception;
-                        *sp++ = val;
-                        break;
-                    case OP_with_get_ref_undef:
-                        /* produce a pair undefined/function on the stack */
-                        val = JS_GetProperty(ctx, obj, atom);
-                        if (unlikely(JS_IsException(val)))
+                        /* in Object Environment Records, GetBindingValue() calls HasProperty() */
+                        ret = JS_HasProperty(ctx, obj, atom);
+                        if (unlikely(ret < 0))
                             goto exception;
-                        JS_FreeValue(ctx, sp[-1]);
-                        sp[-1] = JS_UNDEFINED;
+                        if (!ret) {
+                            val = JS_UNDEFINED;
+                        } else {
+                            val = JS_GetProperty(ctx, obj, atom);
+                            if (unlikely(JS_IsException(val)))
+                                goto exception;
+                        }
                         *sp++ = val;
                         break;
                     }
@@ -18245,9 +19271,11 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             ret_val = JS_NewInt32(ctx, FUNC_RET_YIELD_STAR);
             goto done_generator;
         CASE(OP_return_async):
-        CASE(OP_initial_yield):
             ret_val = JS_UNDEFINED;
             goto done_generator;
+        CASE(OP_initial_yield):
+            ret_val = JS_NewInt32(ctx, FUNC_RET_INITIAL_YIELD);
+            goto done_generator;
 
         CASE(OP_nop):
             BREAK;
@@ -18308,9 +19336,9 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
            before if the exception happens in a bytecode
            operation */
         sf->cur_pc = pc;
-        build_backtrace(ctx, rt->current_exception, NULL, 0, 0);
+        build_backtrace(ctx, rt->current_exception, NULL, 0, 0, 0);
     }
-    if (!JS_IsUncatchableError(ctx, rt->current_exception)) {
+    if (!rt->current_exception_is_uncatchable) {
         while (sp > stack_buf) {
             JSValue val = *--sp;
             JS_FreeValue(ctx, val);
@@ -18323,7 +19351,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                     JS_IteratorClose(ctx, sp[-1], TRUE);
                 } else {
                     *sp++ = rt->current_exception;
-                    rt->current_exception = JS_NULL;
+                    rt->current_exception = JS_UNINITIALIZED;
                     pc = b->byte_code_buf + pos;
                     goto restart;
                 }
@@ -18375,7 +19403,7 @@ static JSContext *JS_GetFunctionRealm(JSContext *ctx, JSValueConst func_obj)
 {
     JSObject *p;
     JSContext *realm;
-    
+
     if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
         return ctx;
     p = JS_VALUE_GET_OBJ(func_obj);
@@ -18424,7 +19452,7 @@ static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
 {
     JSValue proto, obj;
     JSContext *realm;
-    
+
     if (JS_IsUndefined(ctor)) {
         proto = JS_DupValue(ctx, ctx->class_proto[class_id]);
     } else {
@@ -18529,26 +19557,35 @@ static JSValue JS_InvokeFree(JSContext *ctx, JSValue this_val, JSAtom atom,
 }
 
 /* JSAsyncFunctionState (used by generator and async functions) */
-static __exception int async_func_init(JSContext *ctx, JSAsyncFunctionState *s,
-                                       JSValueConst func_obj, JSValueConst this_obj,
-                                       int argc, JSValueConst *argv)
+static JSAsyncFunctionState *async_func_init(JSContext *ctx,
+                                             JSValueConst func_obj, JSValueConst this_obj,
+                                             int argc, JSValueConst *argv)
 {
+    JSAsyncFunctionState *s;
     JSObject *p;
     JSFunctionBytecode *b;
     JSStackFrame *sf;
     int local_count, i, arg_buf_len, n;
 
+    s = js_mallocz(ctx, sizeof(*s));
+    if (!s)
+        return NULL;
+    s->header.ref_count = 1;
+    add_gc_object(ctx->rt, &s->header, JS_GC_OBJ_TYPE_ASYNC_FUNCTION);
+
     sf = &s->frame;
     init_list_head(&sf->var_ref_list);
     p = JS_VALUE_GET_OBJ(func_obj);
     b = p->u.func.function_bytecode;
-    sf->js_mode = b->js_mode;
+    sf->js_mode = b->js_mode | JS_MODE_ASYNC;
     sf->cur_pc = b->byte_code_buf;
     arg_buf_len = max_int(b->arg_count, argc);
     local_count = arg_buf_len + b->var_count + b->stack_size;
     sf->arg_buf = js_malloc(ctx, sizeof(JSValue) * max_int(local_count, 1));
-    if (!sf->arg_buf)
-        return -1;
+    if (!sf->arg_buf) {
+        js_free(ctx, s);
+        return NULL;
+    }
     sf->cur_func = JS_DupValue(ctx, func_obj);
     s->this_val = JS_DupValue(ctx, this_obj);
     s->argc = argc;
@@ -18560,38 +19597,17 @@ static __exception int async_func_init(JSContext *ctx, JSAsyncFunctionState *s,
     n = arg_buf_len + b->var_count;
     for(i = argc; i < n; i++)
         sf->arg_buf[i] = JS_UNDEFINED;
-    return 0;
-}
-
-static void async_func_mark(JSRuntime *rt, JSAsyncFunctionState *s,
-                            JS_MarkFunc *mark_func)
-{
-    JSStackFrame *sf;
-    JSValue *sp;
-
-    sf = &s->frame;
-    JS_MarkValue(rt, sf->cur_func, mark_func);
-    JS_MarkValue(rt, s->this_val, mark_func);
-    if (sf->cur_sp) {
-        /* if the function is running, cur_sp is not known so we
-           cannot mark the stack. Marking the variables is not needed
-           because a running function cannot be part of a removable
-           cycle */
-        for(sp = sf->arg_buf; sp < sf->cur_sp; sp++)
-            JS_MarkValue(rt, *sp, mark_func);
-    }
+    s->resolving_funcs[0] = JS_UNDEFINED;
+    s->resolving_funcs[1] = JS_UNDEFINED;
+    s->is_completed = FALSE;
+    return s;
 }
 
-static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
+static void async_func_free_frame(JSRuntime *rt, JSAsyncFunctionState *s)
 {
-    JSStackFrame *sf;
+    JSStackFrame *sf = &s->frame;
     JSValue *sp;
 
-    sf = &s->frame;
-
-    /* close the closure variables. */
-    close_var_refs(rt, sf);
-    
     if (sf->arg_buf) {
         /* cannot free the function if it is running */
         assert(sf->cur_sp != NULL);
@@ -18599,6 +19615,7 @@ static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
             JS_FreeValueRT(rt, *sp);
         }
         js_free_rt(rt, sf->arg_buf);
+        sf->arg_buf = NULL;
     }
     JS_FreeValueRT(rt, sf->cur_func);
     JS_FreeValueRT(rt, s->this_val);
@@ -18606,17 +19623,66 @@ static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
 
 static JSValue async_func_resume(JSContext *ctx, JSAsyncFunctionState *s)
 {
-    JSValue func_obj;
+    JSRuntime *rt = ctx->rt;
+    JSStackFrame *sf = &s->frame;
+    JSValue func_obj, ret;
 
-    if (js_check_stack_overflow(ctx->rt, 0))
-        return JS_ThrowStackOverflow(ctx);
+    assert(!s->is_completed);
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        ret = JS_ThrowStackOverflow(ctx);
+    } else {
+        /* the tag does not matter provided it is not an object */
+        func_obj = JS_MKPTR(JS_TAG_INT, s);
+        ret = JS_CallInternal(ctx, func_obj, s->this_val, JS_UNDEFINED,
+                              s->argc, sf->arg_buf, JS_CALL_FLAG_GENERATOR);
+    }
+    if (JS_IsException(ret) || JS_IsUndefined(ret)) {
+        if (JS_IsUndefined(ret)) {
+            ret = sf->cur_sp[-1];
+            sf->cur_sp[-1] = JS_UNDEFINED;
+        }
+        /* end of execution */
+        s->is_completed = TRUE;
+
+        /* close the closure variables. */
+        close_var_refs(rt, sf);
+
+        async_func_free_frame(rt, s);
+    }
+    return ret;
+}
+
+static void __async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
+{
+    /* cannot close the closure variables here because it would
+       potentially modify the object graph */
+    if (!s->is_completed) {
+        async_func_free_frame(rt, s);
+    }
+
+    JS_FreeValueRT(rt, s->resolving_funcs[0]);
+    JS_FreeValueRT(rt, s->resolving_funcs[1]);
 
-    /* the tag does not matter provided it is not an object */
-    func_obj = JS_MKPTR(JS_TAG_INT, s);
-    return JS_CallInternal(ctx, func_obj, s->this_val, JS_UNDEFINED,
-                           s->argc, s->frame.arg_buf, JS_CALL_FLAG_GENERATOR);
+    remove_gc_object(&s->header);
+    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES && s->header.ref_count != 0) {
+        list_add_tail(&s->header.link, &rt->gc_zero_ref_count_list);
+    } else {
+        js_free_rt(rt, s);
+    }
 }
 
+static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
+{
+    if (--s->header.ref_count == 0) {
+        if (rt->gc_phase != JS_GC_PHASE_REMOVE_CYCLES) {
+            list_del(&s->header.link);
+            list_add(&s->header.link, &rt->gc_zero_ref_count_list);
+            if (rt->gc_phase == JS_GC_PHASE_NONE) {
+                free_zero_refcount(rt);
+            }
+        }
+    }
+}
 
 /* Generators */
 
@@ -18630,14 +19696,17 @@ typedef enum JSGeneratorStateEnum {
 
 typedef struct JSGeneratorData {
     JSGeneratorStateEnum state;
-    JSAsyncFunctionState func_state;
+    JSAsyncFunctionState *func_state;
 } JSGeneratorData;
 
 static void free_generator_stack_rt(JSRuntime *rt, JSGeneratorData *s)
 {
     if (s->state == JS_GENERATOR_STATE_COMPLETED)
         return;
-    async_func_free(rt, &s->func_state);
+    if (s->func_state) {
+        async_func_free(rt, s->func_state);
+        s->func_state = NULL;
+    }
     s->state = JS_GENERATOR_STATE_COMPLETED;
 }
 
@@ -18662,9 +19731,9 @@ static void js_generator_mark(JSRuntime *rt, JSValueConst val,
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSGeneratorData *s = p->u.generator_data;
 
-    if (!s || s->state == JS_GENERATOR_STATE_COMPLETED)
+    if (!s || !s->func_state)
         return;
-    async_func_mark(rt, &s->func_state, mark_func);
+    mark_func(rt, &s->func_state->header);
 }
 
 /* XXX: use enum */
@@ -18683,10 +19752,10 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
     *pdone = TRUE;
     if (!s)
         return JS_ThrowTypeError(ctx, "not a generator");
-    sf = &s->func_state.frame;
     switch(s->state) {
     default:
     case JS_GENERATOR_STATE_SUSPENDED_START:
+        sf = &s->func_state->frame;
         if (magic == GEN_MAGIC_NEXT) {
             goto exec_no_arg;
         } else {
@@ -18696,28 +19765,29 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
         break;
     case JS_GENERATOR_STATE_SUSPENDED_YIELD_STAR:
     case JS_GENERATOR_STATE_SUSPENDED_YIELD:
+        sf = &s->func_state->frame;
         /* cur_sp[-1] was set to JS_UNDEFINED in the previous call */
         ret = JS_DupValue(ctx, argv[0]);
         if (magic == GEN_MAGIC_THROW &&
             s->state == JS_GENERATOR_STATE_SUSPENDED_YIELD) {
             JS_Throw(ctx, ret);
-            s->func_state.throw_flag = TRUE;
+            s->func_state->throw_flag = TRUE;
         } else {
             sf->cur_sp[-1] = ret;
             sf->cur_sp[0] = JS_NewInt32(ctx, magic);
             sf->cur_sp++;
         exec_no_arg:
-            s->func_state.throw_flag = FALSE;
+            s->func_state->throw_flag = FALSE;
         }
         s->state = JS_GENERATOR_STATE_EXECUTING;
-        func_ret = async_func_resume(ctx, &s->func_state);
+        func_ret = async_func_resume(ctx, s->func_state);
         s->state = JS_GENERATOR_STATE_SUSPENDED_YIELD;
-        if (JS_IsException(func_ret)) {
-            /* finalize the execution in case of exception */
+        if (s->func_state->is_completed) {
+            /* finalize the execution in case of exception or normal return */
             free_generator_stack(ctx, s);
             return func_ret;
-        }
-        if (JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT) {
+        } else {
+            assert(JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT);
             /* get the returned yield value at the top of the stack */
             ret = sf->cur_sp[-1];
             sf->cur_sp[-1] = JS_UNDEFINED;
@@ -18728,12 +19798,6 @@ static JSValue js_generator_next(JSContext *ctx, JSValueConst this_val,
             } else {
                 *pdone = FALSE;
             }
-        } else {
-            /* end of iterator */
-            ret = sf->cur_sp[-1];
-            sf->cur_sp[-1] = JS_UNDEFINED;
-            JS_FreeValue(ctx, func_ret);
-            free_generator_stack(ctx, s);
         }
         break;
     case JS_GENERATOR_STATE_COMPLETED:
@@ -18771,13 +19835,14 @@ static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
     if (!s)
         return JS_EXCEPTION;
     s->state = JS_GENERATOR_STATE_SUSPENDED_START;
-    if (async_func_init(ctx, &s->func_state, func_obj, this_obj, argc, argv)) {
+    s->func_state = async_func_init(ctx, func_obj, this_obj, argc, argv);
+    if (!s->func_state) {
         s->state = JS_GENERATOR_STATE_COMPLETED;
         goto fail;
     }
 
     /* execute the function up to 'OP_initial_yield' */
-    func_ret = async_func_resume(ctx, &s->func_state);
+    func_ret = async_func_resume(ctx, s->func_state);
     if (JS_IsException(func_ret))
         goto fail;
     JS_FreeValue(ctx, func_ret);
@@ -18795,36 +19860,12 @@ static JSValue js_generator_function_call(JSContext *ctx, JSValueConst func_obj,
 
 /* AsyncFunction */
 
-static void js_async_function_terminate(JSRuntime *rt, JSAsyncFunctionData *s)
-{
-    if (s->is_active) {
-        async_func_free(rt, &s->func_state);
-        s->is_active = FALSE;
-    }
-}
-
-static void js_async_function_free0(JSRuntime *rt, JSAsyncFunctionData *s)
-{
-    js_async_function_terminate(rt, s);
-    JS_FreeValueRT(rt, s->resolving_funcs[0]);
-    JS_FreeValueRT(rt, s->resolving_funcs[1]);
-    remove_gc_object(&s->header);
-    js_free_rt(rt, s);
-}
-
-static void js_async_function_free(JSRuntime *rt, JSAsyncFunctionData *s)
-{
-    if (--s->header.ref_count == 0) {
-        js_async_function_free0(rt, s);
-    }
-}
-
 static void js_async_function_resolve_finalizer(JSRuntime *rt, JSValue val)
 {
     JSObject *p = JS_VALUE_GET_OBJ(val);
-    JSAsyncFunctionData *s = p->u.async_function_data;
+    JSAsyncFunctionState *s = p->u.async_function_data;
     if (s) {
-        js_async_function_free(rt, s);
+        async_func_free(rt, s);
     }
 }
 
@@ -18832,14 +19873,14 @@ static void js_async_function_resolve_mark(JSRuntime *rt, JSValueConst val,
                                            JS_MarkFunc *mark_func)
 {
     JSObject *p = JS_VALUE_GET_OBJ(val);
-    JSAsyncFunctionData *s = p->u.async_function_data;
+    JSAsyncFunctionState *s = p->u.async_function_data;
     if (s) {
         mark_func(rt, &s->header);
     }
 }
 
 static int js_async_function_resolve_create(JSContext *ctx,
-                                            JSAsyncFunctionData *s,
+                                            JSAsyncFunctionState *s,
                                             JSValue *resolving_funcs)
 {
     int i;
@@ -18861,60 +19902,58 @@ static int js_async_function_resolve_create(JSContext *ctx,
     return 0;
 }
 
-static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionData *s)
+static void js_async_function_resume(JSContext *ctx, JSAsyncFunctionState *s)
 {
     JSValue func_ret, ret2;
 
-    func_ret = async_func_resume(ctx, &s->func_state);
-    if (JS_IsException(func_ret)) {
-        JSValue error;
-    fail:
-        error = JS_GetException(ctx);
-        ret2 = JS_Call(ctx, s->resolving_funcs[1], JS_UNDEFINED,
-                       1, (JSValueConst *)&error);
-        JS_FreeValue(ctx, error);
-        js_async_function_terminate(ctx->rt, s);
-        JS_FreeValue(ctx, ret2); /* XXX: what to do if exception ? */
-    } else {
-        JSValue value;
-        value = s->func_state.frame.cur_sp[-1];
-        s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
-        if (JS_IsUndefined(func_ret)) {
-            /* function returned */
-            ret2 = JS_Call(ctx, s->resolving_funcs[0], JS_UNDEFINED,
-                           1, (JSValueConst *)&value);
+    func_ret = async_func_resume(ctx, s);
+    if (s->is_completed) {
+        if (JS_IsException(func_ret)) {
+            JSValue error;
+        fail:
+            error = JS_GetException(ctx);
+            ret2 = JS_Call(ctx, s->resolving_funcs[1], JS_UNDEFINED,
+                           1, (JSValueConst *)&error);
+            JS_FreeValue(ctx, error);
             JS_FreeValue(ctx, ret2); /* XXX: what to do if exception ? */
-            JS_FreeValue(ctx, value);
-            js_async_function_terminate(ctx->rt, s);
         } else {
-            JSValue promise, resolving_funcs[2], resolving_funcs1[2];
-            int i, res;
+            /* normal return */
+            ret2 = JS_Call(ctx, s->resolving_funcs[0], JS_UNDEFINED,
+                           1, (JSValueConst *)&func_ret);
+            JS_FreeValue(ctx, func_ret);
+            JS_FreeValue(ctx, ret2); /* XXX: what to do if exception ? */
+        }
+    } else {
+        JSValue value, promise, resolving_funcs[2], resolving_funcs1[2];
+        int i, res;
 
-            /* await */
-            JS_FreeValue(ctx, func_ret); /* not used */
-            promise = js_promise_resolve(ctx, ctx->promise_ctor,
-                                         1, (JSValueConst *)&value, 0);
-            JS_FreeValue(ctx, value);
-            if (JS_IsException(promise))
-                goto fail;
-            if (js_async_function_resolve_create(ctx, s, resolving_funcs)) {
-                JS_FreeValue(ctx, promise);
-                goto fail;
-            }
+        value = s->frame.cur_sp[-1];
+        s->frame.cur_sp[-1] = JS_UNDEFINED;
 
-            /* Note: no need to create 'thrownawayCapability' as in
-               the spec */
-            for(i = 0; i < 2; i++)
-                resolving_funcs1[i] = JS_UNDEFINED;
-            res = perform_promise_then(ctx, promise,
-                                       (JSValueConst *)resolving_funcs,
-                                       (JSValueConst *)resolving_funcs1);
+        /* await */
+        JS_FreeValue(ctx, func_ret); /* not used */
+        promise = js_promise_resolve(ctx, ctx->promise_ctor,
+                                     1, (JSValueConst *)&value, 0);
+        JS_FreeValue(ctx, value);
+        if (JS_IsException(promise))
+            goto fail;
+        if (js_async_function_resolve_create(ctx, s, resolving_funcs)) {
             JS_FreeValue(ctx, promise);
-            for(i = 0; i < 2; i++)
-                JS_FreeValue(ctx, resolving_funcs[i]);
-            if (res)
-                goto fail;
+            goto fail;
         }
+
+        /* Note: no need to create 'thrownawayCapability' as in
+           the spec */
+        for(i = 0; i < 2; i++)
+            resolving_funcs1[i] = JS_UNDEFINED;
+        res = perform_promise_then(ctx, promise,
+                                   (JSValueConst *)resolving_funcs,
+                                   (JSValueConst *)resolving_funcs1);
+        JS_FreeValue(ctx, promise);
+        for(i = 0; i < 2; i++)
+            JS_FreeValue(ctx, resolving_funcs[i]);
+        if (res)
+            goto fail;
     }
 }
 
@@ -18925,7 +19964,7 @@ static JSValue js_async_function_resolve_call(JSContext *ctx,
                                               int flags)
 {
     JSObject *p = JS_VALUE_GET_OBJ(func_obj);
-    JSAsyncFunctionData *s = p->u.async_function_data;
+    JSAsyncFunctionState *s = p->u.async_function_data;
     BOOL is_reject = p->class_id - JS_CLASS_ASYNC_FUNCTION_RESOLVE;
     JSValueConst arg;
 
@@ -18933,12 +19972,12 @@ static JSValue js_async_function_resolve_call(JSContext *ctx,
         arg = argv[0];
     else
         arg = JS_UNDEFINED;
-    s->func_state.throw_flag = is_reject;
+    s->throw_flag = is_reject;
     if (is_reject) {
         JS_Throw(ctx, JS_DupValue(ctx, arg));
     } else {
         /* return value of await */
-        s->func_state.frame.cur_sp[-1] = JS_DupValue(ctx, arg);
+        s->frame.cur_sp[-1] = JS_DupValue(ctx, arg);
     }
     js_async_function_resume(ctx, s);
     return JS_UNDEFINED;
@@ -18949,32 +19988,21 @@ static JSValue js_async_function_call(JSContext *ctx, JSValueConst func_obj,
                                       int argc, JSValueConst *argv, int flags)
 {
     JSValue promise;
-    JSAsyncFunctionData *s;
+    JSAsyncFunctionState *s;
 
-    s = js_mallocz(ctx, sizeof(*s));
+    s = async_func_init(ctx, func_obj, this_obj, argc, argv);
     if (!s)
         return JS_EXCEPTION;
-    s->header.ref_count = 1;
-    add_gc_object(ctx->rt, &s->header, JS_GC_OBJ_TYPE_ASYNC_FUNCTION);
-    s->is_active = FALSE;
-    s->resolving_funcs[0] = JS_UNDEFINED;
-    s->resolving_funcs[1] = JS_UNDEFINED;
 
     promise = JS_NewPromiseCapability(ctx, s->resolving_funcs);
-    if (JS_IsException(promise))
-        goto fail;
-
-    if (async_func_init(ctx, &s->func_state, func_obj, this_obj, argc, argv)) {
-    fail:
-        JS_FreeValue(ctx, promise);
-        js_async_function_free(ctx->rt, s);
+    if (JS_IsException(promise)) {
+        async_func_free(ctx->rt, s);
         return JS_EXCEPTION;
     }
-    s->is_active = TRUE;
 
     js_async_function_resume(ctx, s);
 
-    js_async_function_free(ctx->rt, s);
+    async_func_free(ctx->rt, s);
 
     return promise;
 }
@@ -19003,7 +20031,8 @@ typedef struct JSAsyncGeneratorRequest {
 typedef struct JSAsyncGeneratorData {
     JSObject *generator; /* back pointer to the object (const) */
     JSAsyncGeneratorStateEnum state;
-    JSAsyncFunctionState func_state;
+    /* func_state is NULL is state AWAITING_RETURN and COMPLETED */
+    JSAsyncFunctionState *func_state;
     struct list_head queue; /* list of JSAsyncGeneratorRequest.link */
 } JSAsyncGeneratorData;
 
@@ -19021,10 +20050,8 @@ static void js_async_generator_free(JSRuntime *rt,
         JS_FreeValueRT(rt, req->resolving_funcs[1]);
         js_free_rt(rt, req);
     }
-    if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED &&
-        s->state != JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN) {
-        async_func_free(rt, &s->func_state);
-    }
+    if (s->func_state)
+        async_func_free(rt, s->func_state);
     js_free_rt(rt, s);
 }
 
@@ -19051,9 +20078,8 @@ static void js_async_generator_mark(JSRuntime *rt, JSValueConst val,
             JS_MarkValue(rt, req->resolving_funcs[0], mark_func);
             JS_MarkValue(rt, req->resolving_funcs[1], mark_func);
         }
-        if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED &&
-            s->state != JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN) {
-            async_func_mark(rt, &s->func_state, mark_func);
+        if (s->func_state) {
+            mark_func(rt, &s->func_state->header);
         }
     }
 }
@@ -19163,7 +20189,8 @@ static void js_async_generator_complete(JSContext *ctx,
 {
     if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED) {
         s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
-        async_func_free(ctx->rt, &s->func_state);
+        async_func_free(ctx->rt, s->func_state);
+        s->func_state = NULL;
     }
 }
 
@@ -19174,10 +20201,19 @@ static int js_async_generator_completed_return(JSContext *ctx,
     JSValue promise, resolving_funcs[2], resolving_funcs1[2];
     int res;
 
-    promise = js_promise_resolve(ctx, ctx->promise_ctor,
-                                 1, (JSValueConst *)&value, 0);
-    if (JS_IsException(promise))
-        return -1;
+    // Can fail looking up JS_ATOM_constructor when is_reject==0.
+    promise = js_promise_resolve(ctx, ctx->promise_ctor, 1, &value,
+                                 /*is_reject*/0);
+    // A poisoned .constructor property is observable and the resulting
+    // exception should be delivered to the catch handler.
+    if (JS_IsException(promise)) {
+        JSValue err = JS_GetException(ctx);
+        promise = js_promise_resolve(ctx, ctx->promise_ctor, 1, (JSValueConst *)&err,
+                                     /*is_reject*/1);
+        JS_FreeValue(ctx, err);
+        if (JS_IsException(promise))
+            return -1;
+    }
     if (js_async_generator_resolve_function_create(ctx,
                                                    JS_MKPTR(JS_TAG_OBJECT, s->generator),
                                                    resolving_funcs1,
@@ -19225,7 +20261,6 @@ static void js_async_generator_resume_next(JSContext *ctx,
             } else if (next->completion_type == GEN_MAGIC_RETURN) {
                 s->state = JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN;
                 js_async_generator_completed_return(ctx, s, next->result);
-                goto done;
             } else {
                 js_async_generator_reject(ctx, s, next->result);
             }
@@ -19236,30 +20271,38 @@ static void js_async_generator_resume_next(JSContext *ctx,
             if (next->completion_type == GEN_MAGIC_THROW &&
                 s->state == JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD) {
                 JS_Throw(ctx, value);
-                s->func_state.throw_flag = TRUE;
+                s->func_state->throw_flag = TRUE;
             } else {
                 /* 'yield' returns a value. 'yield *' also returns a value
                    in case the 'throw' method is called */
-                s->func_state.frame.cur_sp[-1] = value;
-                s->func_state.frame.cur_sp[0] =
+                s->func_state->frame.cur_sp[-1] = value;
+                s->func_state->frame.cur_sp[0] =
                     JS_NewInt32(ctx, next->completion_type);
-                s->func_state.frame.cur_sp++;
+                s->func_state->frame.cur_sp++;
             exec_no_arg:
-                s->func_state.throw_flag = FALSE;
+                s->func_state->throw_flag = FALSE;
             }
             s->state = JS_ASYNC_GENERATOR_STATE_EXECUTING;
         resume_exec:
-            func_ret = async_func_resume(ctx, &s->func_state);
-            if (JS_IsException(func_ret)) {
-                value = JS_GetException(ctx);
-                js_async_generator_complete(ctx, s);
-                js_async_generator_reject(ctx, s, value);
-                JS_FreeValue(ctx, value);
-            } else if (JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT) {
-                int func_ret_code;
-                value = s->func_state.frame.cur_sp[-1];
-                s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
+            func_ret = async_func_resume(ctx, s->func_state);
+            if (s->func_state->is_completed) {
+                if (JS_IsException(func_ret)) {
+                    value = JS_GetException(ctx);
+                    js_async_generator_complete(ctx, s);
+                    js_async_generator_reject(ctx, s, value);
+                    JS_FreeValue(ctx, value);
+                } else {
+                    /* end of function */
+                    js_async_generator_complete(ctx, s);
+                    js_async_generator_resolve(ctx, s, func_ret, TRUE);
+                    JS_FreeValue(ctx, func_ret);
+                }
+            } else {
+                int func_ret_code, ret;
+                assert(JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT);
                 func_ret_code = JS_VALUE_GET_INT(func_ret);
+                value = s->func_state->frame.cur_sp[-1];
+                s->func_state->frame.cur_sp[-1] = JS_UNDEFINED;
                 switch(func_ret_code) {
                 case FUNC_RET_YIELD:
                 case FUNC_RET_YIELD_STAR:
@@ -19271,20 +20314,17 @@ static void js_async_generator_resume_next(JSContext *ctx,
                     JS_FreeValue(ctx, value);
                     break;
                 case FUNC_RET_AWAIT:
-                    js_async_generator_await(ctx, s, value);
+                    ret = js_async_generator_await(ctx, s, value);
                     JS_FreeValue(ctx, value);
+                    if (ret < 0) {
+                        /* exception: throw it */
+                        s->func_state->throw_flag = TRUE;
+                        goto resume_exec;
+                    }
                     goto done;
                 default:
                     abort();
                 }
-            } else {
-                assert(JS_IsUndefined(func_ret));
-                /* end of function */
-                value = s->func_state.frame.cur_sp[-1];
-                s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
-                js_async_generator_complete(ctx, s);
-                js_async_generator_resolve(ctx, s, value, TRUE);
-                JS_FreeValue(ctx, value);
             }
             break;
         default:
@@ -19318,12 +20358,12 @@ static JSValue js_async_generator_resolve_function(JSContext *ctx,
     } else {
         /* restart function execution after await() */
         assert(s->state == JS_ASYNC_GENERATOR_STATE_EXECUTING);
-        s->func_state.throw_flag = is_reject;
+        s->func_state->throw_flag = is_reject;
         if (is_reject) {
             JS_Throw(ctx, JS_DupValue(ctx, arg));
         } else {
             /* return value of await */
-            s->func_state.frame.cur_sp[-1] = JS_DupValue(ctx, arg);
+            s->func_state->frame.cur_sp[-1] = JS_DupValue(ctx, arg);
         }
         js_async_generator_resume_next(ctx, s);
     }
@@ -19387,14 +20427,12 @@ static JSValue js_async_generator_function_call(JSContext *ctx, JSValueConst fun
         return JS_EXCEPTION;
     s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_START;
     init_list_head(&s->queue);
-    if (async_func_init(ctx, &s->func_state, func_obj, this_obj, argc, argv)) {
-        s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
+    s->func_state = async_func_init(ctx, func_obj, this_obj, argc, argv);
+    if (!s->func_state)
         goto fail;
-    }
-
     /* execute the function up to 'OP_initial_yield' (no yield nor
        await are possible) */
-    func_ret = async_func_resume(ctx, &s->func_state);
+    func_ret = async_func_resume(ctx, s->func_state);
     if (JS_IsException(func_ret))
         goto fail;
     JS_FreeValue(ctx, func_ret);
@@ -19430,9 +20468,6 @@ enum {
     TOK_AND_ASSIGN,
     TOK_XOR_ASSIGN,
     TOK_OR_ASSIGN,
-#ifdef CONFIG_BIGNUM
-    TOK_MATH_POW_ASSIGN,
-#endif
     TOK_POW_ASSIGN,
     TOK_LAND_ASSIGN,
     TOK_LOR_ASSIGN,
@@ -19452,9 +20487,6 @@ enum {
     TOK_STRICT_NEQ,
     TOK_LAND,
     TOK_LOR,
-#ifdef CONFIG_BIGNUM
-    TOK_MATH_POW,
-#endif
     TOK_POW,
     TOK_ARROW,
     TOK_ELLIPSIS,
@@ -19533,7 +20565,8 @@ typedef struct BlockEnv {
     int drop_count; /* number of stack elements to drop */
     int label_finally; /* -1 if none */
     int scope_level;
-    int has_iterator;
+    uint8_t has_iterator : 1;
+    uint8_t is_regular_stmt : 1; /* i.e. not a loop statement */
 } BlockEnv;
 
 typedef struct JSGlobalVar {
@@ -19569,9 +20602,17 @@ typedef struct LabelSlot {
 
 typedef struct LineNumberSlot {
     uint32_t pc;
-    int line_num;
+    uint32_t source_pos;
 } LineNumberSlot;
 
+typedef struct {
+    /* last source position */
+    const uint8_t *ptr;
+    int line_num;
+    int col_num;
+    const uint8_t *buf_start;
+} GetLineColCache;
+
 typedef enum JSParseFunctionEnum {
     JS_PARSE_FUNC_STATEMENT,
     JS_PARSE_FUNC_VAR,
@@ -19580,6 +20621,7 @@ typedef enum JSParseFunctionEnum {
     JS_PARSE_FUNC_GETTER,
     JS_PARSE_FUNC_SETTER,
     JS_PARSE_FUNC_METHOD,
+    JS_PARSE_FUNC_CLASS_STATIC_INIT,
     JS_PARSE_FUNC_CLASS_CONSTRUCTOR,
     JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR,
 } JSParseFunctionEnum;
@@ -19621,7 +20663,6 @@ typedef struct JSFunctionDef {
     BOOL arguments_allowed; /* true if the 'arguments' identifier is allowed */
     BOOL is_derived_class_constructor;
     BOOL in_function_body;
-    BOOL backtrace_barrier;
     JSFunctionKindEnum func_kind : 8;
     JSParseFunctionEnum func_type : 8;
     uint8_t js_mode; /* bitmap of JS_MODE_x */
@@ -19637,7 +20678,7 @@ typedef struct JSFunctionDef {
     int var_object_idx; /* -1 if none */
     int arg_var_object_idx; /* -1 if none (var object for the argument scope) */
     int arguments_var_idx; /* -1 if none */
-    int arguments_arg_idx; /* argument variable definition in argument scope, 
+    int arguments_arg_idx; /* argument variable definition in argument scope,
                               -1 if none */
     int func_var_idx; /* variable containing the current function (-1
                          if none, only used if is_func_expr is true) */
@@ -19647,7 +20688,7 @@ typedef struct JSFunctionDef {
     int this_active_func_var_idx; /* variable containg the 'this.active_func' value, -1 if none */
     int home_object_var_idx;
     BOOL need_home_object;
-    
+
     int scope_level;    /* index into fd->scopes if the current lexical scope */
     int scope_first;    /* index into vd->vars of first lexically scoped variable */
     int scope_size;     /* allocated size of fd->scopes array */
@@ -19662,9 +20703,9 @@ typedef struct JSFunctionDef {
 
     DynBuf byte_code;
     int last_opcode_pos; /* -1 if no last opcode */
-    int last_opcode_line_num;
+    const uint8_t *last_opcode_source_ptr;
     BOOL use_short_opcodes; /* true if short opcodes are used in byte_code */
-    
+
     LabelSlot *label_slots;
     int label_size; /* allocated size for label_slots[] */
     int label_count;
@@ -19691,20 +20732,23 @@ typedef struct JSFunctionDef {
     int line_number_last_pc;
 
     /* pc2line table */
+    BOOL strip_debug : 1; /* strip all debug info (implies strip_source = TRUE) */
+    BOOL strip_source : 1; /* strip only source code */
     JSAtom filename;
-    int line_num;
+    uint32_t source_pos; /* pointer in the eval() source */
+    GetLineColCache *get_line_col_cache; /* XXX: could remove to save memory */
     DynBuf pc2line;
 
     char *source;  /* raw source, utf-8 encoded */
     int source_len;
 
     JSModuleDef *module; /* != NULL when parsing a module */
+    BOOL has_await; /* TRUE if await is used (used in module eval) */
 } JSFunctionDef;
 
 typedef struct JSToken {
     int val;
-    int line_num;   /* line number of token start */
-    const uint8_t *ptr;
+    const uint8_t *ptr; /* position in the source */
     union {
         struct {
             JSValue str;
@@ -19712,9 +20756,6 @@ typedef struct JSToken {
         } str;
         struct {
             JSValue val;
-#ifdef CONFIG_BIGNUM
-            slimb_t exponent; /* may be != 0 only if val is a float */
-#endif
         } num;
         struct {
             JSAtom atom;
@@ -19730,12 +20771,11 @@ typedef struct JSToken {
 
 typedef struct JSParseState {
     JSContext *ctx;
-    int last_line_num;  /* line number of last token */
-    int line_num;       /* line number of current offset */
     const char *filename;
     JSToken token;
     BOOL got_lf; /* true if got line feed before the current token */
     const uint8_t *last_ptr;
+    const uint8_t *buf_start;
     const uint8_t *buf_ptr;
     const uint8_t *buf_end;
 
@@ -19744,6 +20784,7 @@ typedef struct JSParseState {
     BOOL is_module; /* parsing a module */
     BOOL allow_html_comments;
     BOOL ext_json; /* true if accepting JSON superset */
+    GetLineColCache get_line_col_cache;
 } JSParseState;
 
 typedef struct JSOpCode {
@@ -19872,21 +20913,95 @@ static void __attribute((unused)) dump_token(JSParseState *s,
     }
 }
 
-int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
+/* return the zero based line and column number in the source. */
+/* Note: we no longer support '\r' as line terminator */
+static int get_line_col(int *pcol_num, const uint8_t *buf, size_t len)
+{
+    int line_num, col_num, c;
+    size_t i;
+    
+    line_num = 0;
+    col_num = 0;
+    for(i = 0; i < len; i++) {
+        c = buf[i];
+        if (c == '\n') {
+            line_num++;
+            col_num = 0;
+        } else if (c < 0x80 || c >= 0xc0) {
+            col_num++;
+        }
+    }
+    *pcol_num = col_num;
+    return line_num;
+}
+
+static int get_line_col_cached(GetLineColCache *s, int *pcol_num, const uint8_t *ptr)
+{
+    int line_num, col_num;
+    if (ptr >= s->ptr) {
+        line_num = get_line_col(&col_num, s->ptr, ptr - s->ptr);
+        if (line_num == 0) {
+            s->col_num += col_num;
+        } else {
+            s->line_num += line_num;
+            s->col_num = col_num;
+        }
+    } else {
+        line_num = get_line_col(&col_num, ptr, s->ptr - ptr);
+        if (line_num == 0) {
+            s->col_num -= col_num;
+        } else {
+            const uint8_t *p;
+            s->line_num -= line_num;
+            /* find the absolute column position */
+            col_num = 0;
+            for(p = ptr - 1; p >= s->buf_start; p--) {
+                if (*p == '\n') {
+                    break;
+                } else if (*p < 0x80 || *p >= 0xc0) {
+                    col_num++;
+                }
+            }
+            s->col_num = col_num;
+        }
+    }
+    s->ptr = ptr;
+    *pcol_num = s->col_num;
+    return s->line_num;
+}
+
+/* 'ptr' is the position of the error in the source */
+static int js_parse_error_v(JSParseState *s, const uint8_t *ptr, const char *fmt, va_list ap)
 {
     JSContext *ctx = s->ctx;
+    int line_num, col_num;
+    line_num = get_line_col(&col_num, s->buf_start, ptr - s->buf_start);
+    JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
+    build_backtrace(ctx, ctx->rt->current_exception, s->filename,
+                    line_num + 1, col_num + 1, 0);
+    return -1;
+}
+
+static __attribute__((format(printf, 3, 4))) int js_parse_error_pos(JSParseState *s, const uint8_t *ptr, const char *fmt, ...)
+{
     va_list ap;
-    int backtrace_flags;
+    int ret;
     
     va_start(ap, fmt);
-    JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
+    ret = js_parse_error_v(s, ptr, fmt, ap);
     va_end(ap);
-    backtrace_flags = 0;
-    if (s->cur_func && s->cur_func->backtrace_barrier)
-        backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
-    build_backtrace(ctx, ctx->rt->current_exception, s->filename, s->line_num,
-                    backtrace_flags);
-    return -1;
+    return ret;
+}
+
+static __attribute__((format(printf, 2, 3))) int js_parse_error(JSParseState *s, const char *fmt, ...)
+{
+    va_list ap;
+    int ret;
+    
+    va_start(ap, fmt);
+    ret = js_parse_error_v(s, s->token.ptr, fmt, ap);
+    va_end(ap);
+    return ret;
 }
 
 static int js_parse_expect(JSParseState *s, int tok)
@@ -19922,6 +21037,7 @@ static __exception int js_parse_template_part(JSParseState *s, const uint8_t *p)
 {
     uint32_t c;
     StringBuffer b_s, *b = &b_s;
+    JSValue str;
 
     /* p points to the first byte of the template part */
     if (string_buffer_init(s->ctx, b, 32))
@@ -19952,13 +21068,11 @@ static __exception int js_parse_template_part(JSParseState *s, const uint8_t *p)
                 p++;
             c = '\n';
         }
-        if (c == '\n') {
-            s->line_num++;
-        } else if (c >= 0x80) {
+        if (c >= 0x80) {
             const uint8_t *p_next;
             c = unicode_from_utf8(p - 1, UTF8_CHAR_LEN_MAX, &p_next);
             if (c > 0x10FFFF) {
-                js_parse_error(s, "invalid UTF-8 sequence");
+                js_parse_error_pos(s, p - 1, "invalid UTF-8 sequence");
                 goto fail;
             }
             p = p_next;
@@ -19966,9 +21080,12 @@ static __exception int js_parse_template_part(JSParseState *s, const uint8_t *p)
         if (string_buffer_putc(b, c))
             goto fail;
     }
+    str = string_buffer_end(b);
+    if (JS_IsException(str))
+        return -1;
     s->token.val = TOK_TEMPLATE;
     s->token.u.str.sep = c;
-    s->token.u.str.str = string_buffer_end(b);
+    s->token.u.str.str = str;
     s->buf_ptr = p;
     return 0;
 
@@ -19986,6 +21103,8 @@ static __exception int js_parse_string(JSParseState *s, int sep,
     int ret;
     uint32_t c;
     StringBuffer b_s, *b = &b_s;
+    const uint8_t *p_escape;
+    JSValue str;
 
     /* string */
     if (string_buffer_init(s->ctx, b, 32))
@@ -19995,11 +21114,6 @@ static __exception int js_parse_string(JSParseState *s, int sep,
             goto invalid_char;
         c = *p;
         if (c < 0x20) {
-            if (!s->cur_func) {
-                if (do_throw)
-                    js_parse_error(s, "invalid character in a JSON string");
-                goto fail;
-            }
             if (sep == '`') {
                 if (c == '\r') {
                     if (p[1] == '\n')
@@ -20019,6 +21133,7 @@ static __exception int js_parse_string(JSParseState *s, int sep,
             break;
         }
         if (c == '\\') {
+            p_escape = p - 1;
             c = *p;
             /* XXX: need a specific JSON case to avoid
                accepting invalid escapes */
@@ -20041,13 +21156,9 @@ static __exception int js_parse_string(JSParseState *s, int sep,
             case '\n':
                 /* ignore escaped newline sequence */
                 p++;
-                if (sep != '`')
-                    s->line_num++;
                 continue;
             default:
                 if (c >= '0' && c <= '9') {
-                    if (!s->cur_func)
-                        goto invalid_escape; /* JSON case */
                     if (!(s->cur_func->js_mode & JS_MODE_STRICT) && sep != '`')
                         goto parse_escape;
                     if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
@@ -20060,7 +21171,7 @@ static __exception int js_parse_string(JSParseState *s, int sep,
                             goto invalid_escape;
                         } else {
                             if (do_throw)
-                                js_parse_error(s, "octal escape sequences are not allowed in strict mode");
+                                js_parse_error_pos(s, p_escape, "octal escape sequences are not allowed in strict mode");
                         }
                         goto fail;
                     }
@@ -20080,7 +21191,7 @@ static __exception int js_parse_string(JSParseState *s, int sep,
                     if (ret == -1) {
                     invalid_escape:
                         if (do_throw)
-                            js_parse_error(s, "malformed escape sequence in string literal");
+                            js_parse_error_pos(s, p_escape, "malformed escape sequence in string literal");
                         goto fail;
                     } else if (ret < 0) {
                         /* ignore the '\' (could output a warning) */
@@ -20101,9 +21212,12 @@ static __exception int js_parse_string(JSParseState *s, int sep,
         if (string_buffer_putc(b, c))
             goto fail;
     }
+    str = string_buffer_end(b);
+    if (JS_IsException(str))
+        return -1;
     token->val = TOK_STRING;
     token->u.str.sep = c;
-    token->u.str.str = string_buffer_end(b);
+    token->u.str.str = str;
     *pp = p;
     return 0;
 
@@ -20131,6 +21245,7 @@ static __exception int js_parse_regexp(JSParseState *s)
     StringBuffer b_s, *b = &b_s;
     StringBuffer b2_s, *b2 = &b2_s;
     uint32_t c;
+    JSValue body_str, flags_str;
 
     p = s->buf_ptr;
     p++;
@@ -20179,16 +21294,16 @@ static __exception int js_parse_regexp(JSParseState *s)
             c = unicode_from_utf8(p - 1, UTF8_CHAR_LEN_MAX, &p_next);
             if (c > 0x10FFFF) {
             invalid_utf8:
-                js_parse_error(s, "invalid UTF-8 sequence");
+                js_parse_error_pos(s, p - 1, "invalid UTF-8 sequence");
                 goto fail;
             }
-            p = p_next;
             /* LS or PS are considered as line terminator */
             if (c == CP_LS || c == CP_PS) {
             eol_error:
-                js_parse_error(s, "unexpected line terminator in regexp");
+                js_parse_error_pos(s, p - 1, "unexpected line terminator in regexp");
                 goto fail;
             }
+            p = p_next;
         }
         if (string_buffer_putc(b, c))
             goto fail;
@@ -20201,6 +21316,7 @@ static __exception int js_parse_regexp(JSParseState *s)
         if (c >= 0x80) {
             c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p_next);
             if (c > 0x10FFFF) {
+                p++;
                 goto invalid_utf8;
             }
         }
@@ -20211,9 +21327,17 @@ static __exception int js_parse_regexp(JSParseState *s)
         p = p_next;
     }
 
+    body_str = string_buffer_end(b);
+    flags_str = string_buffer_end(b2);
+    if (JS_IsException(body_str) ||
+        JS_IsException(flags_str)) {
+        JS_FreeValue(s->ctx, body_str);
+        JS_FreeValue(s->ctx, flags_str);
+        return -1;
+    }
     s->token.val = TOK_REGEXP;
-    s->token.u.regexp.body = string_buffer_end(b);
-    s->token.u.regexp.flags = string_buffer_end(b2);
+    s->token.u.regexp.body = body_str;
+    s->token.u.regexp.flags = flags_str;
     s->buf_ptr = p;
     return 0;
  fail:
@@ -20227,7 +21351,7 @@ static __exception int ident_realloc(JSContext *ctx, char **pbuf, size_t *psize,
 {
     char *buf, *new_buf;
     size_t size, new_size;
-    
+
     buf = *pbuf;
     size = *psize;
     if (size >= (SIZE_MAX / 3) * 2)
@@ -20249,6 +21373,48 @@ static __exception int ident_realloc(JSContext *ctx, char **pbuf, size_t *psize,
     return 0;
 }
 
+/* convert a TOK_IDENT to a keyword when needed */
+static void update_token_ident(JSParseState *s)
+{
+    if (s->token.u.ident.atom <= JS_ATOM_LAST_KEYWORD ||
+        (s->token.u.ident.atom <= JS_ATOM_LAST_STRICT_KEYWORD &&
+         (s->cur_func->js_mode & JS_MODE_STRICT)) ||
+        (s->token.u.ident.atom == JS_ATOM_yield &&
+         ((s->cur_func->func_kind & JS_FUNC_GENERATOR) ||
+          (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
+           !s->cur_func->in_function_body && s->cur_func->parent &&
+           (s->cur_func->parent->func_kind & JS_FUNC_GENERATOR)))) ||
+        (s->token.u.ident.atom == JS_ATOM_await &&
+         (s->is_module ||
+          (s->cur_func->func_kind & JS_FUNC_ASYNC) ||
+          s->cur_func->func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT ||
+          (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
+           !s->cur_func->in_function_body && s->cur_func->parent &&
+           ((s->cur_func->parent->func_kind & JS_FUNC_ASYNC) ||
+            s->cur_func->parent->func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT))))) {
+        if (s->token.u.ident.has_escape) {
+            s->token.u.ident.is_reserved = TRUE;
+            s->token.val = TOK_IDENT;
+        } else {
+            /* The keywords atoms are pre allocated */
+            s->token.val = s->token.u.ident.atom - 1 + TOK_FIRST_KEYWORD;
+        }
+    }
+}
+
+/* if the current token is an identifier or keyword, reparse it
+   according to the current function type */
+static void reparse_ident_token(JSParseState *s)
+{
+    if (s->token.val == TOK_IDENT ||
+        (s->token.val >= TOK_FIRST_KEYWORD &&
+         s->token.val <= TOK_LAST_KEYWORD)) {
+        s->token.val = TOK_IDENT;
+        s->token.u.ident.is_reserved = FALSE;
+        update_token_ident(s);
+    }
+}
+
 /* 'c' is the first character. Return JS_ATOM_NULL in case of error */
 static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
                           BOOL *pident_has_escape, int c, BOOL is_private)
@@ -20257,7 +21423,7 @@ static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
     char ident_buf[128], *buf;
     size_t ident_size, ident_pos;
     JSAtom atom;
-    
+
     p = *pp;
     buf = ident_buf;
     ident_size = sizeof(ident_buf);
@@ -20266,7 +21432,7 @@ static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
         buf[ident_pos++] = '#';
     for(;;) {
         p1 = p;
-        
+
         if (c < 128) {
             buf[ident_pos++] = c;
         } else {
@@ -20304,18 +21470,16 @@ static __exception int next_token(JSParseState *s)
     int c;
     BOOL ident_has_escape;
     JSAtom atom;
-    
+
     if (js_check_stack_overflow(s->ctx->rt, 0)) {
         return js_parse_error(s, "stack overflow");
     }
-    
+
     free_token(s, &s->token);
 
     p = s->last_ptr = s->buf_ptr;
     s->got_lf = FALSE;
-    s->last_line_num = s->token.line_num;
  redo:
-    s->token.line_num = s->line_num;
     s->token.ptr = p;
     c = *p;
     switch(c) {
@@ -20345,7 +21509,6 @@ static __exception int next_token(JSParseState *s)
         p++;
     line_terminator:
         s->got_lf = TRUE;
-        s->line_num++;
         goto redo;
     case '\f':
     case '\v':
@@ -20366,11 +21529,7 @@ static __exception int next_token(JSParseState *s)
                     p += 2;
                     break;
                 }
-                if (*p == '\n') {
-                    s->line_num++;
-                    s->got_lf = TRUE; /* considered as LF for ASI */
-                    p++;
-                } else if (*p == '\r') {
+                if (*p == '\n' || *p == '\r') {
                     s->got_lf = TRUE; /* considered as LF for ASI */
                     p++;
                 } else if (*p >= 0x80) {
@@ -20435,14 +21594,14 @@ static __exception int next_token(JSParseState *s)
     case 'm': case 'n': case 'o': case 'p':
     case 'q': case 'r': case 's': case 't':
     case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z': 
+    case 'y': case 'z':
     case 'A': case 'B': case 'C': case 'D':
     case 'E': case 'F': case 'G': case 'H':
     case 'I': case 'J': case 'K': case 'L':
     case 'M': case 'N': case 'O': case 'P':
     case 'Q': case 'R': case 'S': case 'T':
     case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z': 
+    case 'Y': case 'Z':
     case '_':
     case '$':
         /* identifier */
@@ -20455,30 +21614,8 @@ static __exception int next_token(JSParseState *s)
         s->token.u.ident.atom = atom;
         s->token.u.ident.has_escape = ident_has_escape;
         s->token.u.ident.is_reserved = FALSE;
-        if (s->token.u.ident.atom <= JS_ATOM_LAST_KEYWORD ||
-            (s->token.u.ident.atom <= JS_ATOM_LAST_STRICT_KEYWORD &&
-             (s->cur_func->js_mode & JS_MODE_STRICT)) ||
-            (s->token.u.ident.atom == JS_ATOM_yield &&
-             ((s->cur_func->func_kind & JS_FUNC_GENERATOR) ||
-              (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
-               !s->cur_func->in_function_body && s->cur_func->parent &&
-               (s->cur_func->parent->func_kind & JS_FUNC_GENERATOR)))) ||
-            (s->token.u.ident.atom == JS_ATOM_await &&
-             (s->is_module ||
-              (((s->cur_func->func_kind & JS_FUNC_ASYNC) ||
-                (s->cur_func->func_type == JS_PARSE_FUNC_ARROW &&
-                 !s->cur_func->in_function_body && s->cur_func->parent &&
-                 (s->cur_func->parent->func_kind & JS_FUNC_ASYNC))))))) {
-                  if (ident_has_escape) {
-                      s->token.u.ident.is_reserved = TRUE;
-                      s->token.val = TOK_IDENT;
-                  } else {
-                      /* The keywords atoms are pre allocated */
-                      s->token.val = s->token.u.ident.atom - 1 + TOK_FIRST_KEYWORD;
-                  }
-        } else {
-            s->token.val = TOK_IDENT;
-        }
+        s->token.val = TOK_IDENT;
+        update_token_ident(s);
         break;
     case '#':
         /* private name */
@@ -20526,32 +21663,17 @@ static __exception int next_token(JSParseState *s)
         goto parse_number;
     case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8':
-    case '9': 
+    case '9':
         /* number */
     parse_number:
         {
             JSValue ret;
             const uint8_t *p1;
-            int flags, radix;
+            int flags;
             flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL |
-                ATOD_ACCEPT_UNDERSCORES;
-            flags |= ATOD_ACCEPT_SUFFIX;
-#ifdef CONFIG_BIGNUM
-            if (s->cur_func->js_mode & JS_MODE_MATH) {
-                flags |= ATOD_MODE_BIGINT;
-                if (s->cur_func->js_mode & JS_MODE_MATH)
-                    flags |= ATOD_TYPE_BIG_FLOAT;
-            }
-#endif
-            radix = 0;
-#ifdef CONFIG_BIGNUM
-            s->token.u.num.exponent = 0;
-            ret = js_atof2(s->ctx, (const char *)p, (const char **)&p, radix,
-                           flags, &s->token.u.num.exponent);
-#else
-            ret = js_atof(s->ctx, (const char *)p, (const char **)&p, radix,
+                ATOD_ACCEPT_UNDERSCORES | ATOD_ACCEPT_SUFFIX;
+            ret = js_atof(s->ctx, (const char *)p, (const char **)&p, 0,
                           flags);
-#endif
             if (JS_IsException(ret))
                 goto fail;
             /* reject `10instanceof Number` */
@@ -20605,8 +21727,8 @@ static __exception int next_token(JSParseState *s)
             p += 2;
             s->token.val = TOK_MINUS_ASSIGN;
         } else if (p[1] == '-') {
-            if (s->allow_html_comments &&
-                p[2] == '>' && s->last_line_num != s->line_num) {
+            if (s->allow_html_comments && p[2] == '>' &&
+                (s->got_lf || s->last_ptr == s->buf_start)) {
                 /* Annex B: `-->` at beginning of line is an html comment end.
                    It extends to the end of the line.
                  */
@@ -20707,33 +21829,6 @@ static __exception int next_token(JSParseState *s)
             goto def_token;
         }
         break;
-#ifdef CONFIG_BIGNUM
-        /* in math mode, '^' is the power operator. '^^' is always the
-           xor operator and '**' is always the power operator */
-    case '^':
-        if (p[1] == '=') {
-            p += 2;
-            if (s->cur_func->js_mode & JS_MODE_MATH)
-                s->token.val = TOK_MATH_POW_ASSIGN;
-            else
-                s->token.val = TOK_XOR_ASSIGN;
-        } else if (p[1] == '^') {
-            if (p[2] == '=') {
-                p += 3;
-                s->token.val = TOK_XOR_ASSIGN;
-            } else {
-                p += 2;
-                s->token.val = '^';
-            }
-        } else {
-            p++;
-            if (s->cur_func->js_mode & JS_MODE_MATH)
-                s->token.val = TOK_MATH_POW;
-            else
-                s->token.val = '^';
-        }
-        break;
-#else
     case '^':
         if (p[1] == '=') {
             p += 2;
@@ -20742,7 +21837,6 @@ static __exception int next_token(JSParseState *s)
             goto def_token;
         }
         break;
-#endif
     case '|':
         if (p[1] == '=') {
             p += 2;
@@ -20784,7 +21878,7 @@ static __exception int next_token(JSParseState *s)
             case CP_LS:
                 /* XXX: should avoid incrementing line_number, but
                    needed to handle HTML comments */
-                goto line_terminator; 
+                goto line_terminator;
             default:
                 if (lre_is_space(c)) {
                     goto redo;
@@ -20813,13 +21907,14 @@ static __exception int next_token(JSParseState *s)
 }
 
 /* 'c' is the first character. Return JS_ATOM_NULL in case of error */
+/* XXX: accept unicode identifiers as JSON5 ? */
 static JSAtom json_parse_ident(JSParseState *s, const uint8_t **pp, int c)
 {
     const uint8_t *p;
     char ident_buf[128], *buf;
     size_t ident_size, ident_pos;
     JSAtom atom;
-    
+
     p = *pp;
     buf = ident_buf;
     ident_size = sizeof(ident_buf);
@@ -20827,8 +21922,7 @@ static JSAtom json_parse_ident(JSParseState *s, const uint8_t **pp, int c)
     for(;;) {
         buf[ident_pos++] = c;
         c = *p;
-        if (c >= 128 ||
-            !((lre_id_continue_table_ascii[c >> 5] >> (c & 31)) & 1))
+        if (c >= 128 || !lre_is_id_continue_byte(c))
             break;
         p++;
         if (unlikely(ident_pos >= ident_size - UTF8_CHAR_LEN_MAX)) {
@@ -20846,22 +21940,192 @@ static JSAtom json_parse_ident(JSParseState *s, const uint8_t **pp, int c)
     return atom;
 }
 
+static int json_parse_string(JSParseState *s, const uint8_t **pp, int sep)
+{
+    const uint8_t *p, *p_next;
+    int i;
+    uint32_t c;
+    StringBuffer b_s, *b = &b_s;
+
+    if (string_buffer_init(s->ctx, b, 32))
+        goto fail;
+
+    p = *pp;
+    for(;;) {
+        if (p >= s->buf_end) {
+            goto end_of_input;
+        }
+        c = *p++;
+        if (c == sep)
+            break;
+        if (c < 0x20) {
+            js_parse_error_pos(s, p - 1, "Bad control character in string literal");
+            goto fail;
+        }
+        if (c == '\\') {
+            c = *p++;
+            switch(c) {
+            case 'b':   c = '\b'; break;
+            case 'f':   c = '\f'; break;
+            case 'n':   c = '\n'; break;
+            case 'r':   c = '\r'; break;
+            case 't':   c = '\t'; break;
+            case '\\':  break;
+            case '/':   break; 
+            case 'u':
+                c = 0;
+                for(i = 0; i < 4; i++) {
+                    int h = from_hex(*p++);
+                    if (h < 0) {
+                        js_parse_error_pos(s, p - 1, "Bad Unicode escape");
+                        goto fail;
+                    }
+                    c = (c << 4) | h;
+                }
+                break;
+            case '\n':
+                if (s->ext_json)
+                    continue;
+                goto bad_escape;
+            case 'v':
+                if (s->ext_json) {
+                    c = '\v';
+                    break;
+                }
+                goto bad_escape;
+            default:
+                if (c == sep)
+                    break;
+                if (p > s->buf_end)
+                    goto end_of_input;
+            bad_escape:
+                js_parse_error_pos(s, p - 1, "Bad escaped character");
+                goto fail;
+            }
+        } else
+        if (c >= 0x80) {
+            c = unicode_from_utf8(p - 1, UTF8_CHAR_LEN_MAX, &p_next);
+            if (c > 0x10FFFF) {
+                js_parse_error_pos(s, p - 1, "Bad UTF-8 sequence");
+                goto fail;
+            }
+            p = p_next;
+        }
+        if (string_buffer_putc(b, c))
+            goto fail;
+    }
+    s->token.val = TOK_STRING;
+    s->token.u.str.sep = sep;
+    s->token.u.str.str = string_buffer_end(b);
+    *pp = p;
+    return 0;
+
+ end_of_input:
+    js_parse_error(s, "Unexpected end of JSON input");
+ fail:
+    string_buffer_free(b);
+    return -1;
+}
+
+static int json_parse_number(JSParseState *s, const uint8_t **pp)
+{
+    const uint8_t *p = *pp;
+    const uint8_t *p_start = p;
+    int radix;
+    double d;
+    JSATODTempMem atod_mem;
+    
+    if (*p == '+' || *p == '-')
+        p++;
+
+    if (!is_digit(*p)) {
+        if (s->ext_json) {
+            if (strstart((const char *)p, "Infinity", (const char **)&p)) {
+                d = 1.0 / 0.0;
+                if (*p_start == '-')
+                    d = -d;
+                goto done;
+            } else if (strstart((const char *)p, "NaN", (const char **)&p)) {
+                d = NAN;
+                goto done;
+            } else if (*p != '.') {
+                goto unexpected_token;
+            }
+        } else {
+            goto unexpected_token;
+        }
+    }
+
+    if (p[0] == '0') {
+        if (s->ext_json) {
+            /* also accepts base 16, 8 and 2 prefix for integers */
+            radix = 10;
+            if (p[1] == 'x' || p[1] == 'X') {
+                p += 2;
+                radix = 16;
+            } else if ((p[1] == 'o' || p[1] == 'O')) {
+                p += 2;
+                radix = 8;
+            } else if ((p[1] == 'b' || p[1] == 'B')) {
+                p += 2;
+                radix = 2;
+            }
+            if (radix != 10) {
+                /* prefix is present */
+                if (to_digit(*p) >= radix) {
+                unexpected_token:
+                    return js_parse_error_pos(s, p, "Unexpected token '%c'", *p);
+                }
+                d = js_atod((const char *)p_start, (const char **)&p, 0,
+                            JS_ATOD_INT_ONLY | JS_ATOD_ACCEPT_BIN_OCT, &atod_mem);
+                goto done;
+            }
+        }
+        if (is_digit(p[1]))
+            return js_parse_error_pos(s, p, "Unexpected number");
+    }
+
+    while (is_digit(*p))
+        p++;
+
+    if (*p == '.') {
+        p++;
+        if (!is_digit(*p))
+            return js_parse_error_pos(s, p, "Unterminated fractional number");
+        while (is_digit(*p))
+            p++;
+    }
+    if (*p == 'e' || *p == 'E') {
+        p++;
+        if (*p == '+' || *p == '-')
+            p++;
+        if (!is_digit(*p))
+            return js_parse_error_pos(s, p, "Exponent part is missing a number");
+        while (is_digit(*p))
+            p++;
+    }
+    d = js_atod((const char *)p_start, NULL, 10, 0, &atod_mem);
+ done:
+    s->token.val = TOK_NUMBER;
+    s->token.u.num.val = JS_NewFloat64(s->ctx, d);
+    *pp = p;
+    return 0;
+}
+
 static __exception int json_next_token(JSParseState *s)
 {
     const uint8_t *p;
     int c;
     JSAtom atom;
-    
+
     if (js_check_stack_overflow(s->ctx->rt, 0)) {
         return js_parse_error(s, "stack overflow");
     }
-    
+
     free_token(s, &s->token);
 
     p = s->last_ptr = s->buf_ptr;
-    s->last_line_num = s->token.line_num;
  redo:
-    s->token.line_num = s->line_num;
     s->token.ptr = p;
     c = *p;
     switch(c) {
@@ -20879,7 +22143,8 @@ static __exception int json_next_token(JSParseState *s)
         }
         /* fall through */
     case '\"':
-        if (js_parse_string(s, c, TRUE, p + 1, &s->token, &p))
+        p++;
+        if (json_parse_string(s, &p, c))
             goto fail;
         break;
     case '\r':  /* accept DOS and MAC newline sequences */
@@ -20889,7 +22154,6 @@ static __exception int json_next_token(JSParseState *s)
         /* fall thru */
     case '\n':
         p++;
-        s->line_num++;
         goto redo;
     case '\f':
     case '\v':
@@ -20919,12 +22183,7 @@ static __exception int json_next_token(JSParseState *s)
                     p += 2;
                     break;
                 }
-                if (*p == '\n') {
-                    s->line_num++;
-                    p++;
-                } else if (*p == '\r') {
-                    p++;
-                } else if (*p >= 0x80) {
+                if (*p >= 0x80) {
                     c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
                     if (c == -1) {
                         p++; /* skip invalid UTF-8 */
@@ -20965,17 +22224,16 @@ static __exception int json_next_token(JSParseState *s)
     case 'm': case 'n': case 'o': case 'p':
     case 'q': case 'r': case 's': case 't':
     case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z': 
+    case 'y': case 'z':
     case 'A': case 'B': case 'C': case 'D':
     case 'E': case 'F': case 'G': case 'H':
     case 'I': case 'J': case 'K': case 'L':
     case 'M': case 'N': case 'O': case 'P':
     case 'Q': case 'R': case 'S': case 'T':
     case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z': 
+    case 'Y': case 'Z':
     case '_':
     case '$':
-        /* identifier : only pure ascii characters are accepted */
         p++;
         atom = json_parse_ident(s, &p, c);
         if (atom == JS_ATOM_NULL)
@@ -20986,39 +22244,23 @@ static __exception int json_next_token(JSParseState *s)
         s->token.val = TOK_IDENT;
         break;
     case '+':
-        if (!s->ext_json || !is_digit(p[1]))
+        if (!s->ext_json)
             goto def_token;
         goto parse_number;
-    case '0':
-        if (is_digit(p[1]))
+    case '.':
+        if (s->ext_json && is_digit(p[1]))
+            goto parse_number;
+        else
             goto def_token;
-        goto parse_number;
     case '-':
-        if (!is_digit(p[1]))
-            goto def_token;
-        goto parse_number;
+    case '0':
     case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8':
-    case '9': 
+    case '9':
         /* number */
     parse_number:
-        {
-            JSValue ret;
-            int flags, radix;
-            if (!s->ext_json) {
-                flags = 0;
-                radix = 10;
-            } else {
-                flags = ATOD_ACCEPT_BIN_OCT;
-                radix = 0;
-            }
-            ret = js_atof(s->ctx, (const char *)p, (const char **)&p, radix,
-                          flags);
-            if (JS_IsException(ret))
-                goto fail;
-            s->token.val = TOK_NUMBER;
-            s->token.u.num.val = ret;
-        }
+        if (json_parse_number(s, &p))
+            goto fail;
         break;
     default:
         if (c >= 128) {
@@ -21040,14 +22282,34 @@ static __exception int json_next_token(JSParseState *s)
     return -1;
 }
 
-/* only used for ':' and '=>', 'let' or 'function' look-ahead. *pp is
-   only set if TOK_IMPORT is returned */
-/* XXX: handle all unicode cases */
+static int match_identifier(const uint8_t *p, const char *s) {
+    uint32_t c;
+    while (*s) {
+        if ((uint8_t)*s++ != *p++)
+            return 0;
+    }
+    c = *p;
+    if (c >= 128)
+        c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+    return !lre_js_is_ident_next(c);
+}
+
+/* simple_next_token() is used to check for the next token in simple cases.
+   It is only used for ':' and '=>', 'let' or 'function' look-ahead.
+   (*pp) is only set if TOK_IMPORT is returned for JS_DetectModule()
+   Whitespace and comments are skipped correctly.
+   Then the next token is analyzed, only for specific words.
+   Return values:
+   - '\n' if !no_line_terminator
+   - TOK_ARROW, TOK_IN, TOK_IMPORT, TOK_OF, TOK_EXPORT, TOK_FUNCTION
+   - TOK_IDENT is returned for other identifiers and keywords
+   - otherwise the next character or unicode codepoint is returned.
+ */
 static int simple_next_token(const uint8_t **pp, BOOL no_line_terminator)
 {
     const uint8_t *p;
     uint32_t c;
-    
+
     /* skip spaces and comments */
     p = *pp;
     for (;;) {
@@ -21086,33 +22348,42 @@ static int simple_next_token(const uint8_t **pp, BOOL no_line_terminator)
             if (*p == '>')
                 return TOK_ARROW;
             break;
+        case 'i':
+            if (match_identifier(p, "n"))
+                return TOK_IN;
+            if (match_identifier(p, "mport")) {
+                *pp = p + 5;
+                return TOK_IMPORT;
+            }
+            return TOK_IDENT;
+        case 'o':
+            if (match_identifier(p, "f"))
+                return TOK_OF;
+            return TOK_IDENT;
+        case 'e':
+            if (match_identifier(p, "xport"))
+                return TOK_EXPORT;
+            return TOK_IDENT;
+        case 'f':
+            if (match_identifier(p, "unction"))
+                return TOK_FUNCTION;
+            return TOK_IDENT;
+        case '\\':
+            if (*p == 'u') {
+                if (lre_js_is_ident_first(lre_parse_escape(&p, TRUE)))
+                    return TOK_IDENT;
+            }
+            break;
         default:
-            if (lre_js_is_ident_first(c)) {
-                if (c == 'i') {
-                    if (p[0] == 'n' && !lre_js_is_ident_next(p[1])) {
-                        return TOK_IN;
-                    }
-                    if (p[0] == 'm' && p[1] == 'p' && p[2] == 'o' &&
-                        p[3] == 'r' && p[4] == 't' &&
-                        !lre_js_is_ident_next(p[5])) {
-                        *pp = p + 5;
-                        return TOK_IMPORT;
-                    }
-                } else if (c == 'o' && *p == 'f' && !lre_js_is_ident_next(p[1])) {
-                    return TOK_OF;
-                } else if (c == 'e' &&
-                           p[0] == 'x' && p[1] == 'p' && p[2] == 'o' &&
-                           p[3] == 'r' && p[4] == 't' &&
-                           !lre_js_is_ident_next(p[5])) {
-                    *pp = p + 5;
-                    return TOK_EXPORT;
-                } else if (c == 'f' && p[0] == 'u' && p[1] == 'n' &&
-                         p[2] == 'c' && p[3] == 't' && p[4] == 'i' &&
-                         p[5] == 'o' && p[6] == 'n' && !lre_js_is_ident_next(p[7])) {
-                    return TOK_FUNCTION;
-                }
-                return TOK_IDENT;
+            if (c >= 128) {
+                c = unicode_from_utf8(p - 1, UTF8_CHAR_LEN_MAX, &p);
+                if (no_line_terminator && (c == CP_PS || c == CP_LS))
+                    return '\n';
             }
+            if (lre_is_space(c))
+                continue;
+            if (lre_js_is_ident_first(c))
+                return TOK_IDENT;
             break;
         }
         return c;
@@ -21125,6 +22396,31 @@ static int peek_token(JSParseState *s, BOOL no_line_terminator)
     return simple_next_token(&p, no_line_terminator);
 }
 
+static void skip_shebang(const uint8_t **pp, const uint8_t *buf_end)
+{
+    const uint8_t *p = *pp;
+    int c;
+
+    if (p[0] == '#' && p[1] == '!') {
+        p += 2;
+        while (p < buf_end) {
+            if (*p == '\n' || *p == '\r') {
+                break;
+            } else if (*p >= 0x80) {
+                c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
+                if (c == CP_LS || c == CP_PS) {
+                    break;
+                } else if (c == -1) {
+                    p++; /* skip invalid UTF-8 */
+                }
+            } else {
+                p++;
+            }
+        }
+        *pp = p;
+    }
+}
+
 /* return true if 'input' contains the source of a module
    (heuristic). 'input' must be a zero terminated.
 
@@ -21135,6 +22431,8 @@ BOOL JS_DetectModule(const char *input, size_t input_len)
 {
     const uint8_t *p = (const uint8_t *)input;
     int tok;
+
+    skip_shebang(&p, p + input_len);
     switch(simple_next_token(&p, FALSE)) {
     case TOK_IMPORT:
         tok = simple_next_token(&p, FALSE);
@@ -21147,7 +22445,7 @@ BOOL JS_DetectModule(const char *input, size_t input_len)
 }
 
 static inline int get_prev_opcode(JSFunctionDef *fd) {
-    if (fd->last_opcode_pos < 0)
+    if (fd->last_opcode_pos < 0 || dbuf_error(&fd->byte_code))
         return OP_invalid;
     else
         return fd->byte_code.buf[fd->last_opcode_pos];
@@ -21189,26 +22487,34 @@ static void emit_u32(JSParseState *s, uint32_t val)
     dbuf_put_u32(&s->cur_func->byte_code, val);
 }
 
-static void emit_op(JSParseState *s, uint8_t val)
+static void emit_source_pos(JSParseState *s, const uint8_t *source_ptr)
 {
     JSFunctionDef *fd = s->cur_func;
     DynBuf *bc = &fd->byte_code;
 
-    /* Use the line number of the last token used, not the next token,
-       nor the current offset in the source file.
-     */
-    if (unlikely(fd->last_opcode_line_num != s->last_line_num)) {
+    if (unlikely(fd->last_opcode_source_ptr != source_ptr)) {
         dbuf_putc(bc, OP_line_num);
-        dbuf_put_u32(bc, s->last_line_num);
-        fd->last_opcode_line_num = s->last_line_num;
+        dbuf_put_u32(bc, source_ptr - s->buf_start);
+        fd->last_opcode_source_ptr = source_ptr;
     }
+}
+
+static void emit_op(JSParseState *s, uint8_t val)
+{
+    JSFunctionDef *fd = s->cur_func;
+    DynBuf *bc = &fd->byte_code;
+
     fd->last_opcode_pos = bc->size;
     dbuf_putc(bc, val);
 }
 
 static void emit_atom(JSParseState *s, JSAtom name)
 {
-    emit_u32(s, JS_DupAtom(s->ctx, name));
+    DynBuf *bc = &s->cur_func->byte_code;
+    if (dbuf_realloc(bc, bc->size + 4))
+        return; /* not enough memory : don't duplicate the atom */
+    put_u32(bc->buf + bc->size, JS_DupAtom(s->ctx, name));
+    bc->size += 4;
 }
 
 static int update_label(JSFunctionDef *s, int label, int delta)
@@ -21222,29 +22528,41 @@ static int update_label(JSFunctionDef *s, int label, int delta)
     return ls->ref_count;
 }
 
-static int new_label_fd(JSFunctionDef *fd, int label)
+static int new_label_fd(JSFunctionDef *fd)
 {
+    int label;
     LabelSlot *ls;
 
-    if (label < 0) {
-        if (js_resize_array(fd->ctx, (void *)&fd->label_slots,
-                            sizeof(fd->label_slots[0]),
-                            &fd->label_size, fd->label_count + 1))
-            return -1;
-        label = fd->label_count++;
-        ls = &fd->label_slots[label];
-        ls->ref_count = 0;
-        ls->pos = -1;
-        ls->pos2 = -1;
-        ls->addr = -1;
-        ls->first_reloc = NULL;
-    }
+    if (js_resize_array(fd->ctx, (void *)&fd->label_slots,
+                        sizeof(fd->label_slots[0]),
+                        &fd->label_size, fd->label_count + 1))
+        return -1;
+    label = fd->label_count++;
+    ls = &fd->label_slots[label];
+    ls->ref_count = 0;
+    ls->pos = -1;
+    ls->pos2 = -1;
+    ls->addr = -1;
+    ls->first_reloc = NULL;
     return label;
 }
 
 static int new_label(JSParseState *s)
 {
-    return new_label_fd(s->cur_func, -1);
+    int label;
+    label = new_label_fd(s->cur_func);
+    if (unlikely(label < 0)) {
+        dbuf_set_error(&s->cur_func->byte_code);
+    }
+    return label;
+}
+
+/* don't update the last opcode and don't emit line number info */
+static void emit_label_raw(JSParseState *s, int label)
+{
+    emit_u8(s, OP_label);
+    emit_u32(s, label);
+    s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
 }
 
 /* return the label ID offset */
@@ -21264,8 +22582,11 @@ static int emit_label(JSParseState *s, int label)
 static int emit_goto(JSParseState *s, int opcode, int label)
 {
     if (js_is_live_code(s)) {
-        if (label < 0)
+        if (label < 0) {
             label = new_label(s);
+            if (label < 0)
+                return -1;
+        }
         emit_op(s, opcode);
         emit_u32(s, label);
         s->cur_func->label_slots[label].ref_count++;
@@ -21278,7 +22599,7 @@ static int emit_goto(JSParseState *s, int opcode, int label)
 static int cpool_add(JSParseState *s, JSValue val)
 {
     JSFunctionDef *fd = s->cur_func;
-    
+
     if (js_resize_array(s->ctx, (void *)&fd->cpool, sizeof(fd->cpool[0]),
                         &fd->cpool_size, fd->cpool_count + 1))
         return -1;
@@ -21664,7 +22985,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         if (find_var_in_child_scope(ctx, fd, name, fd->scope_level) >= 0) {
             return js_parse_error(s, "invalid redefinition of a variable");
         }
-        
+
         if (fd->is_global_var) {
             JSGlobalVar *hf;
             hf = find_global_var(fd, name);
@@ -21673,7 +22994,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
                 return js_parse_error(s, "invalid redefinition of global identifier");
             }
         }
-        
+
         if (fd->is_eval &&
             (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
              fd->eval_type == JS_EVAL_TYPE_MODULE) &&
@@ -21765,15 +23086,13 @@ static __exception int js_parse_expr(JSParseState *s);
 static __exception int js_parse_function_decl(JSParseState *s,
                                               JSParseFunctionEnum func_type,
                                               JSFunctionKindEnum func_kind,
-                                              JSAtom func_name, const uint8_t *ptr,
-                                              int start_line);
+                                              JSAtom func_name, const uint8_t *ptr);
 static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s);
 static __exception int js_parse_function_decl2(JSParseState *s,
                                                JSParseFunctionEnum func_type,
                                                JSFunctionKindEnum func_kind,
                                                JSAtom func_name,
                                                const uint8_t *ptr,
-                                               int function_line_num,
                                                JSParseExportEnum export_flag,
                                                JSFunctionDef **pfd);
 static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags);
@@ -21896,7 +23215,6 @@ static __exception int js_parse_template(JSParseState *s, int call, int *argc)
         /* Resume TOK_TEMPLATE parsing (s->token.line_num and
          * s->token.ptr are OK) */
         s->got_lf = FALSE;
-        s->last_line_num = s->token.line_num;
         if (js_parse_template_part(s, s->buf_ptr))
             return -1;
     }
@@ -21945,17 +23263,23 @@ static int __exception js_parse_property_name(JSParseState *s,
     BOOL is_non_reserved_ident;
     JSAtom name;
     int prop_type;
-    
+
     prop_type = PROP_TYPE_IDENT;
     if (allow_method) {
-        if (token_is_pseudo_keyword(s, JS_ATOM_get)
-        ||  token_is_pseudo_keyword(s, JS_ATOM_set)) {
+        /* if allow_private is true (for class field parsing) and
+           get/set is following by ';' (or LF with ASI), then it
+           is a field name */
+        if ((token_is_pseudo_keyword(s, JS_ATOM_get) ||
+             token_is_pseudo_keyword(s, JS_ATOM_set)) &&
+            (!allow_private || peek_token(s, TRUE) != '\n')) {
             /* get x(), set x() */
             name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
             if (next_token(s))
                 goto fail1;
             if (s->token.val == ':' || s->token.val == ',' ||
-                s->token.val == '}' || s->token.val == '(') {
+                s->token.val == '}' || s->token.val == '(' ||
+                s->token.val == '=' ||
+                (s->token.val == ';' && allow_private)) {
                 is_non_reserved_ident = TRUE;
                 goto ident_found;
             }
@@ -21971,7 +23295,8 @@ static int __exception js_parse_property_name(JSParseState *s,
             if (next_token(s))
                 goto fail1;
             if (s->token.val == ':' || s->token.val == ',' ||
-                s->token.val == '}' || s->token.val == '(') {
+                s->token.val == '}' || s->token.val == '(' ||
+                s->token.val == '=') {
                 is_non_reserved_ident = TRUE;
                 goto ident_found;
             }
@@ -22011,21 +23336,7 @@ static int __exception js_parse_property_name(JSParseState *s,
     } else if (s->token.val == TOK_NUMBER) {
         JSValue val;
         val = s->token.u.num.val;
-#ifdef CONFIG_BIGNUM
-        if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            val = s->ctx->rt->bigfloat_ops.
-                mul_pow10_to_float64(s->ctx, &p->num,
-                                     s->token.u.num.exponent);
-            if (JS_IsException(val))
-                goto fail;
-            name = JS_ValueToAtom(s->ctx, val);
-            JS_FreeValue(s->ctx, val);
-        } else
-#endif
-        {
-            name = JS_ValueToAtom(s->ctx, val);
-        }
+        name = JS_ValueToAtom(s->ctx, val);
         if (name == JS_ATOM_NULL)
             goto fail;
         if (next_token(s))
@@ -22063,16 +23374,12 @@ static int __exception js_parse_property_name(JSParseState *s,
 }
 
 typedef struct JSParsePos {
-    int last_line_num;
-    int line_num;
     BOOL got_lf;
     const uint8_t *ptr;
 } JSParsePos;
 
 static int js_parse_get_pos(JSParseState *s, JSParsePos *sp)
 {
-    sp->last_line_num = s->last_line_num;
-    sp->line_num = s->token.line_num;
     sp->ptr = s->token.ptr;
     sp->got_lf = s->got_lf;
     return 0;
@@ -22080,8 +23387,6 @@ static int js_parse_get_pos(JSParseState *s, JSParsePos *sp)
 
 static __exception int js_parse_seek_token(JSParseState *s, const JSParsePos *sp)
 {
-    s->token.line_num = sp->last_line_num;
-    s->line_num = sp->line_num;
     s->buf_ptr = sp->ptr;
     s->got_lf = sp->got_lf;
     return next_token(s);
@@ -22114,6 +23419,17 @@ static BOOL is_regexp_allowed(int tok)
 #define SKIP_HAS_ELLIPSIS   (1 << 1)
 #define SKIP_HAS_ASSIGNMENT (1 << 2)
 
+static BOOL has_lf_in_range(const uint8_t *p1, const uint8_t *p2)
+{
+    const uint8_t *tmp;
+    if (p1 > p2) {
+        tmp = p1;
+        p1 = p2;
+        p2 = tmp;
+    }
+    return (memchr(p1, '\n', p2 - p1) != NULL);
+}
+
 /* XXX: improve speed with early bailout */
 /* XXX: no longer works if regexps are present. Could use previous
    regexp parsing heuristics to handle most cases */
@@ -22124,7 +23440,8 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
     JSParsePos pos;
     int last_tok, tok = TOK_EOF;
     int c, tok_len, bits = 0;
-
+    const uint8_t *last_token_ptr;
+    
     /* protect from underflow */
     state[level++] = 0;
 
@@ -22155,7 +23472,6 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 /* Resume TOK_TEMPLATE parsing (s->token.line_num and
                  * s->token.ptr are OK) */
                 s->got_lf = FALSE;
-                s->last_line_num = s->token.line_num;
                 if (js_parse_template_part(s, s->buf_ptr))
                     goto done;
                 goto handle_template;
@@ -22171,7 +23487,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 if (level >= sizeof(state))
                     goto done;
                 state[level++] = '`';
-            } 
+            }
             break;
         case TOK_EOF:
             goto done;
@@ -22188,7 +23504,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
         case '=':
             bits |= SKIP_HAS_ASSIGNMENT;
             break;
-            
+
         case TOK_DIV_ASSIGN:
             tok_len = 2;
             goto parse_regexp;
@@ -22212,6 +23528,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
         } else {
             last_tok = s->token.val;
         }
+        last_token_ptr = s->token.ptr;
         if (next_token(s)) {
             /* XXX: should clear the exception generated by next_token() */
             break;
@@ -22220,7 +23537,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
             tok = s->token.val;
             if (token_is_pseudo_keyword(s, JS_ATOM_of))
                 tok = TOK_OF;
-            if (no_line_terminator && s->last_line_num != s->token.line_num)
+            if (no_line_terminator && has_lf_in_range(last_token_ptr, s->token.ptr))
                 tok = '\n';
             break;
         }
@@ -22287,7 +23604,7 @@ static __exception int js_parse_object_literal(JSParseState *s)
 {
     JSAtom name = JS_ATOM_NULL;
     const uint8_t *start_ptr;
-    int start_line, prop_type;
+    int prop_type;
     BOOL has_proto;
 
     if (next_token(s))
@@ -22298,7 +23615,6 @@ static __exception int js_parse_object_literal(JSParseState *s)
     while (s->token.val != '}') {
         /* specific case for getter/setter */
         start_ptr = s->token.ptr;
-        start_line = s->token.line_num;
 
         if (s->token.val == TOK_ELLIPSIS) {
             if (next_token(s))
@@ -22344,7 +23660,7 @@ static __exception int js_parse_object_literal(JSParseState *s)
                     func_kind = JS_FUNC_ASYNC_GENERATOR;
             }
             if (js_parse_function_decl(s, func_type, func_kind, JS_ATOM_NULL,
-                                       start_ptr, start_line))
+                                       start_ptr))
                 goto fail;
             if (name == JS_ATOM_NULL) {
                 emit_op(s, OP_define_method_computed);
@@ -22360,6 +23676,10 @@ static __exception int js_parse_object_literal(JSParseState *s)
             }
             emit_u8(s, op_flags | OP_DEFINE_METHOD_ENUMERABLE);
         } else {
+            if (name == JS_ATOM_NULL) {
+                /* must be done before evaluating expr */
+                emit_op(s, OP_to_propkey);
+            }
             if (js_parse_expect(s, ':'))
                 goto fail;
             if (js_parse_assign_expr(s))
@@ -22398,56 +23718,84 @@ static __exception int js_parse_object_literal(JSParseState *s)
 }
 
 /* allow the 'in' binary operator */
-#define PF_IN_ACCEPTED  (1 << 0) 
+#define PF_IN_ACCEPTED  (1 << 0)
 /* allow function calls parsing in js_parse_postfix_expr() */
-#define PF_POSTFIX_CALL (1 << 1) 
-/* allow arrow functions parsing in js_parse_postfix_expr() */
-#define PF_ARROW_FUNC   (1 << 2) 
+#define PF_POSTFIX_CALL (1 << 1)
 /* allow the exponentiation operator in js_parse_unary() */
-#define PF_POW_ALLOWED  (1 << 3) 
+#define PF_POW_ALLOWED  (1 << 2)
 /* forbid the exponentiation operator in js_parse_unary() */
-#define PF_POW_FORBIDDEN (1 << 4) 
+#define PF_POW_FORBIDDEN (1 << 3)
 
 static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags);
+static void emit_class_field_init(JSParseState *s);
+static JSFunctionDef *js_new_function_def(JSContext *ctx,
+                                          JSFunctionDef *parent,
+                                          BOOL is_eval,
+                                          BOOL is_func_expr,
+                                          const char *filename,
+                                          const uint8_t *source_ptr,
+                                          GetLineColCache *get_line_col_cache);
+static void emit_return(JSParseState *s, BOOL hasval);
 
 static __exception int js_parse_left_hand_side_expr(JSParseState *s)
 {
     return js_parse_postfix_expr(s, PF_POSTFIX_CALL);
 }
 
-/* XXX: could generate specific bytecode */
 static __exception int js_parse_class_default_ctor(JSParseState *s,
                                                    BOOL has_super,
                                                    JSFunctionDef **pfd)
 {
-    JSParsePos pos;
-    const char *str;
-    int ret, line_num;
     JSParseFunctionEnum func_type;
-    const uint8_t *saved_buf_end;
-    
-    js_parse_get_pos(s, &pos);
+    JSFunctionDef *fd = s->cur_func;
+    int idx;
+
+    fd = js_new_function_def(s->ctx, fd, FALSE, FALSE, s->filename,
+                             s->token.ptr, &s->get_line_col_cache);
+    if (!fd)
+        return -1;
+
+    s->cur_func = fd;
+    fd->has_home_object = TRUE;
+    fd->super_allowed = TRUE;
+    fd->has_prototype = FALSE;
+    fd->has_this_binding = TRUE;
+    fd->new_target_allowed = TRUE;
+
+    push_scope(s);  /* enter body scope */
+    fd->body_scope = fd->scope_level;
     if (has_super) {
-        /* spec change: no argument evaluation */
-        str = "(){super(...arguments);}";
+        fd->is_derived_class_constructor = TRUE;
+        fd->super_call_allowed = TRUE;
+        fd->arguments_allowed = TRUE;
+        fd->has_arguments_binding = TRUE;
         func_type = JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR;
+        emit_op(s, OP_init_ctor);
+        // TODO(bnoordhuis) roll into OP_init_ctor
+        emit_op(s, OP_scope_put_var_init);
+        emit_atom(s, JS_ATOM_this);
+        emit_u16(s, 0);
+        emit_class_field_init(s);
     } else {
-        str = "(){}";
         func_type = JS_PARSE_FUNC_CLASS_CONSTRUCTOR;
+        /* error if not invoked as a constructor */
+        emit_op(s, OP_check_ctor);
+        emit_class_field_init(s);
     }
-    line_num = s->token.line_num;
-    saved_buf_end = s->buf_end;
-    s->buf_ptr = (uint8_t *)str;
-    s->buf_end = (uint8_t *)(str + strlen(str));
-    ret = next_token(s);
-    if (!ret) {
-        ret = js_parse_function_decl2(s, func_type, JS_FUNC_NORMAL,
-                                      JS_ATOM_NULL, (uint8_t *)str,
-                                      line_num, JS_PARSE_EXPORT_NONE, pfd);
-    }
-    s->buf_end = saved_buf_end;
-    ret |= js_parse_seek_token(s, &pos);
-    return ret;
+
+    fd->func_kind = JS_FUNC_NORMAL;
+    fd->func_type = func_type;
+    emit_return(s, FALSE);
+
+    s->cur_func = fd->parent;
+    if (pfd)
+        *pfd = fd;
+
+    /* the real object will be set at the end of the compilation */
+    idx = cpool_add(s, JS_NULL);
+    fd->parent_cpool_idx = idx;
+
+    return 0;
 }
 
 /* find field in the current scope */
@@ -22472,7 +23820,7 @@ static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
 static void emit_class_field_init(JSParseState *s)
 {
     int label_next;
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_class_fields_init);
     emit_u16(s, s->cur_func->scope_level);
@@ -22480,13 +23828,13 @@ static void emit_class_field_init(JSParseState *s)
     /* no need to call the class field initializer if not defined */
     emit_op(s, OP_dup);
     label_next = emit_goto(s, OP_if_false, -1);
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_this);
     emit_u16(s, 0);
-    
+
     emit_op(s, OP_swap);
-    
+
     emit_op(s, OP_call_method);
     emit_u16(s, 0);
 
@@ -22503,67 +23851,54 @@ static JSAtom get_private_setter_name(JSContext *ctx, JSAtom name)
 typedef struct {
     JSFunctionDef *fields_init_fd;
     int computed_fields_count;
-    BOOL has_brand;
+    BOOL need_brand;
     int brand_push_pos;
+    BOOL is_static;
 } ClassFieldsDef;
 
 static __exception int emit_class_init_start(JSParseState *s,
                                              ClassFieldsDef *cf)
 {
     int label_add_brand;
-    
+
     cf->fields_init_fd = js_parse_function_class_fields_init(s);
     if (!cf->fields_init_fd)
         return -1;
 
     s->cur_func = cf->fields_init_fd;
-    
-    /* XXX: would be better to add the code only if needed, maybe in a
-       later pass */
-    emit_op(s, OP_push_false); /* will be patched later */
-    cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
-    label_add_brand = emit_goto(s, OP_if_false, -1);
-    
-    emit_op(s, OP_scope_get_var);
-    emit_atom(s, JS_ATOM_this);
-    emit_u16(s, 0);
-    
-    emit_op(s, OP_scope_get_var);
-    emit_atom(s, JS_ATOM_home_object);
-    emit_u16(s, 0);
-    
-    emit_op(s, OP_add_brand);
-    
-    emit_label(s, label_add_brand);
 
-    s->cur_func = s->cur_func->parent;
-    return 0;
-}
+    if (!cf->is_static) {
+        /* add the brand to the newly created instance */
+        /* XXX: would be better to add the code only if needed, maybe in a
+           later pass */
+        emit_op(s, OP_push_false); /* will be patched later */
+        cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
+        label_add_brand = emit_goto(s, OP_if_false, -1);
 
-static __exception int add_brand(JSParseState *s, ClassFieldsDef *cf)
-{
-    if (!cf->has_brand) {
-        /* define the brand field in 'this' of the initializer */
-        if (!cf->fields_init_fd) {
-            if (emit_class_init_start(s, cf))
-                return -1;
-        }
-        /* patch the start of the function to enable the OP_add_brand code */
-        cf->fields_init_fd->byte_code.buf[cf->brand_push_pos] = OP_push_true;
-        
-        cf->has_brand = TRUE;
+        emit_op(s, OP_scope_get_var);
+        emit_atom(s, JS_ATOM_this);
+        emit_u16(s, 0);
+
+        emit_op(s, OP_scope_get_var);
+        emit_atom(s, JS_ATOM_home_object);
+        emit_u16(s, 0);
+
+        emit_op(s, OP_add_brand);
+
+        emit_label(s, label_add_brand);
     }
+    s->cur_func = s->cur_func->parent;
     return 0;
 }
 
 static void emit_class_init_end(JSParseState *s, ClassFieldsDef *cf)
 {
     int cpool_idx;
-        
+
     s->cur_func = cf->fields_init_fd;
     emit_op(s, OP_return_undef);
     s->cur_func = s->cur_func->parent;
-    
+
     cpool_idx = cpool_add(s, JS_NULL);
     cf->fields_init_fd->parent_cpool_idx = cpool_idx;
     emit_op(s, OP_fclosure);
@@ -22586,7 +23921,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     const uint8_t *class_start_ptr = s->token.ptr;
     const uint8_t *start_ptr;
     ClassFieldsDef class_fields[2];
-        
+
     /* classes are parsed and executed in strict mode */
     saved_js_mode = fd->js_mode;
     fd->js_mode |= JS_MODE_STRICT;
@@ -22649,7 +23984,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     } else {
         class_name1 = class_name;
     }
-    
+
     emit_op(s, OP_define_class);
     emit_atom(s, class_name1);
     emit_u8(s, class_flags);
@@ -22659,9 +23994,10 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         ClassFieldsDef *cf = &class_fields[i];
         cf->fields_init_fd = NULL;
         cf->computed_fields_count = 0;
-        cf->has_brand = FALSE;
+        cf->need_brand = FALSE;
+        cf->is_static = i;
     }
-    
+
     ctor_fd = NULL;
     while (s->token.val != '}') {
         if (s->token.val == ';') {
@@ -22669,11 +24005,51 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 goto fail;
             continue;
         }
-        is_static = (s->token.val == TOK_STATIC);
+        is_static = FALSE;
+        if (s->token.val == TOK_STATIC) {
+            int next = peek_token(s, TRUE);
+            if (!(next == ';' || next == '}' || next == '(' || next == '='))
+                is_static = TRUE;
+        }
         prop_type = -1;
         if (is_static) {
             if (next_token(s))
                 goto fail;
+            if (s->token.val == '{') {
+                ClassFieldsDef *cf = &class_fields[is_static];
+                JSFunctionDef *init;
+                if (!cf->fields_init_fd) {
+                    if (emit_class_init_start(s, cf))
+                        goto fail;
+                }
+                s->cur_func = cf->fields_init_fd;
+                /* XXX: could try to avoid creating a new function and
+                   reuse 'fields_init_fd' with a specific 'var'
+                   scope */
+                // stack is now: <empty>
+                if (js_parse_function_decl2(s, JS_PARSE_FUNC_CLASS_STATIC_INIT,
+                                            JS_FUNC_NORMAL, JS_ATOM_NULL,
+                                            s->token.ptr,
+                                            JS_PARSE_EXPORT_NONE, &init) < 0) {
+                    goto fail;
+                }
+                // stack is now: fclosure
+                push_scope(s);
+                emit_op(s, OP_scope_get_var);
+                emit_atom(s, JS_ATOM_this);
+                emit_u16(s, 0);
+                // stack is now: fclosure this
+                emit_op(s, OP_swap);
+                // stack is now: this fclosure
+                emit_op(s, OP_call_method);
+                emit_u16(s, 0);
+                // stack is now: returnvalue
+                emit_op(s, OP_drop);
+                // stack is now: <empty>
+                pop_scope(s);
+                s->cur_func = s->cur_func->parent;
+                continue;
+            }
             /* allow "static" field name */
             if (s->token.val == ';' || s->token.val == '=') {
                 is_static = FALSE;
@@ -22691,7 +24067,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         }
         is_private = prop_type & PROP_TYPE_PRIVATE;
         prop_type &= ~PROP_TYPE_PRIVATE;
-        
+
         if ((name == JS_ATOM_constructor && !is_static &&
              prop_type != PROP_TYPE_IDENT) ||
             (name == JS_ATOM_prototype && is_static) ||
@@ -22723,13 +24099,12 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                                                 JS_VAR_PRIVATE_GETTER + is_set, is_static) < 0)
                         goto fail;
                 }
-                if (add_brand(s, &class_fields[is_static]) < 0)
-                    goto fail;
+                class_fields[is_static].need_brand = TRUE;
             }
 
             if (js_parse_function_decl2(s, JS_PARSE_FUNC_GETTER + is_set,
                                         JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                        start_ptr, s->token.line_num,
+                                        start_ptr,
                                         JS_PARSE_EXPORT_NONE, &method_fd))
                 goto fail;
             if (is_private) {
@@ -22740,7 +24115,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 if (is_set) {
                     JSAtom setter_name;
                     int ret;
-                    
+
                     setter_name = get_private_setter_name(ctx, name);
                     if (setter_name == JS_ATOM_NULL)
                         goto fail;
@@ -22766,7 +24141,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         } else if (prop_type == PROP_TYPE_IDENT && s->token.val != '(') {
             ClassFieldsDef *cf = &class_fields[is_static];
             JSAtom field_var_name = JS_ATOM_NULL;
-            
+
             /* class field */
 
             /* XXX: spec: not consistent with method name checks */
@@ -22774,7 +24149,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 js_parse_error(s, "invalid field name");
                 goto fail;
             }
-            
+
             if (is_private) {
                 if (find_private_class_field(ctx, fd, name,
                                              fd->scope_level) >= 0) {
@@ -22824,7 +24199,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 emit_atom(s, name);
                 emit_u16(s, s->cur_func->scope_level);
             }
-            
+
             if (s->token.val == '=') {
                 if (next_token(s))
                     goto fail;
@@ -22851,7 +24226,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         } else {
             JSParseFunctionEnum func_type;
             JSFunctionKindEnum func_kind;
-            
+
             func_type = JS_PARSE_FUNC_METHOD;
             func_kind = JS_FUNC_NORMAL;
             if (prop_type == PROP_TYPE_STAR) {
@@ -22871,10 +24246,9 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                     func_type = JS_PARSE_FUNC_CLASS_CONSTRUCTOR;
             }
             if (is_private) {
-                if (add_brand(s, &class_fields[is_static]) < 0)
-                    goto fail;
+                class_fields[is_static].need_brand = TRUE;
             }
-            if (js_parse_function_decl2(s, func_type, func_kind, JS_ATOM_NULL, start_ptr, s->token.line_num, JS_PARSE_EXPORT_NONE, &method_fd))
+            if (js_parse_function_decl2(s, func_type, func_kind, JS_ATOM_NULL, start_ptr, JS_PARSE_EXPORT_NONE, &method_fd))
                 goto fail;
             if (func_type == JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR ||
                 func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
@@ -22925,7 +24299,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     put_u32(fd->byte_code.buf + ctor_cpool_offset, ctor_fd->parent_cpool_idx);
 
     /* store the class source code in the constructor. */
-    if (!(fd->js_mode & JS_MODE_STRIP)) {
+    if (!fd->strip_source) {
         js_free(ctx, ctor_fd->source);
         ctor_fd->source_len = s->buf_ptr - class_start_ptr;
         ctor_fd->source = js_strndup(ctx, (const char *)class_start_ptr,
@@ -22938,12 +24312,29 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     if (next_token(s))
         goto fail;
 
-    /* store the function to initialize the fields to that it can be
-       referenced by the constructor */
     {
         ClassFieldsDef *cf = &class_fields[0];
         int var_idx;
-        
+
+        if (cf->need_brand) {
+            /* add a private brand to the prototype */
+            emit_op(s, OP_dup);
+            emit_op(s, OP_null);
+            emit_op(s, OP_swap);
+            emit_op(s, OP_add_brand);
+
+            /* define the brand field in 'this' of the initializer */
+            if (!cf->fields_init_fd) {
+                if (emit_class_init_start(s, cf))
+                    goto fail;
+            }
+            /* patch the start of the function to enable the
+               OP_add_brand_instance code */
+            cf->fields_init_fd->byte_code.buf[cf->brand_push_pos] = OP_push_true;
+        }
+
+        /* store the function to initialize the fields to that it can be
+           referenced by the constructor */
         var_idx = define_var(s, fd, JS_ATOM_class_fields_init,
                              JS_VAR_DEF_CONST);
         if (var_idx < 0)
@@ -22961,16 +24352,13 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     /* drop the prototype */
     emit_op(s, OP_drop);
 
-    /* initialize the static fields */
-    if (class_fields[1].fields_init_fd != NULL) {
-        ClassFieldsDef *cf = &class_fields[1];
+    if (class_fields[1].need_brand) {
+        /* add a private brand to the class */
         emit_op(s, OP_dup);
-        emit_class_init_end(s, cf);
-        emit_op(s, OP_call_method);
-        emit_u16(s, 0);
-        emit_op(s, OP_drop);
+        emit_op(s, OP_dup);
+        emit_op(s, OP_add_brand);
     }
-    
+
     if (class_name != JS_ATOM_NULL) {
         /* store the class name in the scoped class name variable (it
            is independent from the class statement variable
@@ -22980,6 +24368,17 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         emit_atom(s, class_name);
         emit_u16(s, fd->scope_level);
     }
+
+    /* initialize the static fields */
+    if (class_fields[1].fields_init_fd != NULL) {
+        ClassFieldsDef *cf = &class_fields[1];
+        emit_op(s, OP_dup);
+        emit_class_init_end(s, cf);
+        emit_op(s, OP_call_method);
+        emit_u16(s, 0);
+        emit_op(s, OP_drop);
+    }
+
     pop_scope(s);
     pop_scope(s);
 
@@ -23228,6 +24627,8 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
         switch(opcode) {
         case OP_scope_get_var:
             label = new_label(s);
+            if (label < 0)
+                return -1;
             emit_op(s, OP_scope_make_ref);
             emit_atom(s, name);
             emit_u32(s, label);
@@ -23246,10 +24647,7 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
             emit_u16(s, scope);
             break;
         case OP_get_array_el:
-            /* XXX: replace by a single opcode ? */
-            emit_op(s, OP_to_propkey2);
-            emit_op(s, OP_dup2);
-            emit_op(s, OP_get_array_el);
+            emit_op(s, OP_get_array_el3);
             break;
         case OP_get_super_value:
             emit_op(s, OP_to_propkey);
@@ -23263,6 +24661,8 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
         switch(opcode) {
         case OP_scope_get_var:
             label = new_label(s);
+            if (label < 0)
+                return -1;
             emit_op(s, OP_scope_make_ref);
             emit_atom(s, name);
             emit_u32(s, label);
@@ -23270,11 +24670,7 @@ static __exception int get_lvalue(JSParseState *s, int *popcode, int *pscope,
             update_label(fd, label, 1);
             opcode = OP_get_ref_value;
             break;
-        case OP_get_array_el:
-            emit_op(s, OP_to_propkey2);
-            break;
-        case OP_get_super_value:
-            emit_op(s, OP_to_propkey);
+        default:
             break;
         }
     }
@@ -23374,7 +24770,7 @@ static void put_lvalue(JSParseState *s, int opcode, int scope,
     default:
         break;
     }
-    
+
     switch(opcode) {
     case OP_scope_get_var:  /* val -- */
         assert(special == PUT_LVALUE_NOKEEP ||
@@ -23428,7 +24824,7 @@ static __exception int js_define_var(JSParseState *s, JSAtom name, int tok)
 {
     JSFunctionDef *fd = s->cur_func;
     JSVarDefEnum var_def_type;
-    
+
     if (name == JS_ATOM_yield && fd->func_kind == JS_FUNC_GENERATOR) {
         return js_parse_error(s, "yield is a reserved identifier");
     }
@@ -23436,7 +24832,7 @@ static __exception int js_define_var(JSParseState *s, JSAtom name, int tok)
     &&  (fd->js_mode & JS_MODE_STRICT)) {
         return js_parse_error(s, "invalid variable name in strict mode");
     }
-    if ((name == JS_ATOM_let || name == JS_ATOM_undefined)
+    if (name == JS_ATOM_let
     &&  (tok == TOK_LET || tok == TOK_CONST)) {
         return js_parse_error(s, "invalid lexical variable name");
     }
@@ -23506,6 +24902,25 @@ static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
     return js_parse_error(s, "duplicate parameter names not allowed in this context");
 }
 
+/* tok = TOK_VAR, TOK_LET or TOK_CONST. Return whether a reference
+   must be taken to the variable for proper 'with' or global variable
+   evaluation */
+/* Note: this function is needed only because variable references are
+   not yet optimized in destructuring */
+static BOOL need_var_reference(JSParseState *s, int tok)
+{
+    JSFunctionDef *fd = s->cur_func;
+    if (tok != TOK_VAR)
+        return FALSE; /* no reference for let/const */
+    if (fd->js_mode & JS_MODE_STRICT) {
+        if (!fd->is_global_var)
+            return FALSE; /* local definitions in strict mode in function or direct eval */
+        if (s->is_module)
+            return FALSE; /* in a module global variables are like closure variables */
+    }
+    return TRUE;
+}
+
 static JSAtom js_parse_destructuring_var(JSParseState *s, int tok, int is_arg)
 {
     JSAtom name;
@@ -23532,14 +24947,14 @@ static JSAtom js_parse_destructuring_var(JSParseState *s, int tok, int is_arg)
    present at the top level. */
 static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                                         int hasval, int has_ellipsis,
-                                        BOOL allow_initializer)
+                                        BOOL allow_initializer, BOOL export_flag)
 {
     int label_parse, label_assign, label_done, label_lvalue, depth_lvalue;
     int start_addr, assign_addr;
     JSAtom prop_name, var_name;
     int opcode, scope, tok1, skip_bits;
     BOOL has_initializer;
-    
+
     if (has_ellipsis < 0) {
         /* pre-parse destructuration target for spread detection */
         js_parse_skip_parens_token(s, &skip_bits, FALSE);
@@ -23587,14 +25002,23 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         return -1;
-                    opcode = OP_scope_get_var;
-                    scope = s->cur_func->scope_level;
-                    label_lvalue = -1;
-                    depth_lvalue = 0;
+                    if (need_var_reference(s, tok)) {
+                        /* Must make a reference for proper `with` semantics */
+                        emit_op(s, OP_scope_get_var);
+                        emit_atom(s, var_name);
+                        emit_u16(s, s->cur_func->scope_level);
+                        JS_FreeAtom(s->ctx, var_name);
+                        goto lvalue0;
+                    } else {
+                        opcode = OP_scope_get_var;
+                        scope = s->cur_func->scope_level;
+                        label_lvalue = -1;
+                        depth_lvalue = 0;
+                    }
                 } else {
                     if (js_parse_left_hand_side_expr(s))
                         return -1;
-
+                lvalue0:
                     if (get_lvalue(s, &opcode, &scope, &var_name,
                                    &label_lvalue, &depth_lvalue, FALSE, '{'))
                         return -1;
@@ -23612,10 +25036,6 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
             if (prop_type < 0)
                 return -1;
             var_name = JS_ATOM_NULL;
-            opcode = OP_scope_get_var;
-            scope = s->cur_func->scope_level;
-            label_lvalue = -1;
-            depth_lvalue = 0;
             if (prop_type == PROP_TYPE_IDENT) {
                 if (next_token(s))
                     goto prop_error;
@@ -23648,7 +25068,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                         emit_op(s, OP_get_field2);
                         emit_u32(s, prop_name);
                     }
-                    if (js_parse_destructuring_element(s, tok, is_arg, TRUE, -1, TRUE) < 0)
+                    if (js_parse_destructuring_element(s, tok, is_arg, TRUE, -1, TRUE, export_flag) < 0)
                         return -1;
                     if (s->token.val == '}')
                         break;
@@ -23658,7 +25078,7 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     continue;
                 }
                 if (prop_name == JS_ATOM_NULL) {
-                    emit_op(s, OP_to_propkey2);
+                    emit_op(s, OP_to_propkey);
                     if (has_ellipsis) {
                         /* define the property in excludeList */
                         emit_op(s, OP_perm3);
@@ -23684,10 +25104,24 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         goto prop_error;
+                    if (need_var_reference(s, tok)) {
+                        /* Must make a reference for proper `with` semantics */
+                        emit_op(s, OP_scope_get_var);
+                        emit_atom(s, var_name);
+                        emit_u16(s, s->cur_func->scope_level);
+                        JS_FreeAtom(s->ctx, var_name);
+                        goto lvalue1;
+                    } else {
+                        /* no need to make a reference for let/const */
+                        opcode = OP_scope_get_var;
+                        scope = s->cur_func->scope_level;
+                        label_lvalue = -1;
+                        depth_lvalue = 0;
+                    }
                 } else {
                     if (js_parse_left_hand_side_expr(s))
                         goto prop_error;
-                lvalue:
+                lvalue1:
                     if (get_lvalue(s, &opcode, &scope, &var_name,
                                    &label_lvalue, &depth_lvalue, FALSE, '{'))
                         goto prop_error;
@@ -23754,25 +25188,37 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     emit_atom(s, prop_name);
                     emit_op(s, OP_swap);
                 }
-                if (!tok || tok == TOK_VAR) {
+                if (!tok || need_var_reference(s, tok)) {
                     /* generate reference */
                     /* source -- source source */
                     emit_op(s, OP_dup);
                     emit_op(s, OP_scope_get_var);
                     emit_atom(s, prop_name);
                     emit_u16(s, s->cur_func->scope_level);
-                    goto lvalue;
+                    goto lvalue1;
+                } else {
+                    /* no need to make a reference for let/const */
+                    var_name = JS_DupAtom(s->ctx, prop_name);
+                    opcode = OP_scope_get_var;
+                    scope = s->cur_func->scope_level;
+                    label_lvalue = -1;
+                    depth_lvalue = 0;
+                    
+                    /* source -- source val */
+                    emit_op(s, OP_get_field2);
+                    emit_u32(s, prop_name);
                 }
-                var_name = JS_DupAtom(s->ctx, prop_name);
-                /* source -- source val */
-                emit_op(s, OP_get_field2);
-                emit_u32(s, prop_name);
             }
         set_val:
             if (tok) {
                 if (js_define_var(s, var_name, tok))
                     goto var_error;
-                scope = s->cur_func->scope_level;
+                if (export_flag) {
+                    if (!add_export_entry(s, s->cur_func->module, var_name, var_name,
+                                          JS_EXPORT_TYPE_LOCAL))
+                        goto var_error;
+                }
+                scope = s->cur_func->scope_level; /* XXX: check */
             }
             if (s->token.val == '=') {  /* handle optional default value */
                 int label_hasval;
@@ -23847,22 +25293,34 @@ static int js_parse_destructuring_element(JSParseState *s, int tok, int is_arg,
                     emit_u8(s, 0);
                     emit_op(s, OP_drop);
                 }
-                if (js_parse_destructuring_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
+                if (js_parse_destructuring_element(s, tok, is_arg, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE, export_flag) < 0)
                     return -1;
             } else {
                 var_name = JS_ATOM_NULL;
-                enum_depth = 0;
                 if (tok) {
                     var_name = js_parse_destructuring_var(s, tok, is_arg);
                     if (var_name == JS_ATOM_NULL)
                         goto var_error;
                     if (js_define_var(s, var_name, tok))
                         goto var_error;
-                    opcode = OP_scope_get_var;
-                    scope = s->cur_func->scope_level;
+                    if (need_var_reference(s, tok)) {
+                        /* Must make a reference for proper `with` semantics */
+                        emit_op(s, OP_scope_get_var);
+                        emit_atom(s, var_name);
+                        emit_u16(s, s->cur_func->scope_level);
+                        JS_FreeAtom(s->ctx, var_name);
+                        goto lvalue2;
+                    } else {
+                        /* no need to make a reference for let/const */
+                        opcode = OP_scope_get_var;
+                        scope = s->cur_func->scope_level;
+                        label_lvalue = -1;
+                        enum_depth = 0;
+                    }
                 } else {
                     if (js_parse_left_hand_side_expr(s))
                         return -1;
+                lvalue2:
                     if (get_lvalue(s, &opcode, &scope, &var_name,
                                    &label_lvalue, &enum_depth, FALSE, '[')) {
                         return -1;
@@ -23972,12 +25430,13 @@ static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
     emit_label(s, label_next);
 }
 
-/* allowed parse_flags: PF_POSTFIX_CALL, PF_ARROW_FUNC */
+/* allowed parse_flags: PF_POSTFIX_CALL */
 static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
 {
     FuncCallType call_type;
     int optional_chaining_label;
     BOOL accept_lparen = (parse_flags & PF_POSTFIX_CALL) != 0;
+    const uint8_t *op_token_ptr;
     
     call_type = FUNC_CALL_NORMAL;
     switch(s->token.val) {
@@ -23989,34 +25448,17 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
             if (JS_VALUE_GET_TAG(val) == JS_TAG_INT) {
                 emit_op(s, OP_push_i32);
                 emit_u32(s, JS_VALUE_GET_INT(val));
-            } else
-#ifdef CONFIG_BIGNUM
-            if (JS_VALUE_GET_TAG(val) == JS_TAG_BIG_FLOAT) {
-                slimb_t e;
-                int ret;
-
-                /* need a runtime conversion */
-                /* XXX: could add a cache and/or do it once at
-                   the start of the function */
-                if (emit_push_const(s, val, 0) < 0)
-                    return -1;
-                e = s->token.u.num.exponent;
-                if (e == (int32_t)e) {
-                    emit_op(s, OP_push_i32);
-                    emit_u32(s, e);
+            } else if (JS_VALUE_GET_TAG(val) == JS_TAG_SHORT_BIG_INT) {
+                int64_t v;
+                v = JS_VALUE_GET_SHORT_BIG_INT(val);
+                if (v >= INT32_MIN && v <= INT32_MAX) {
+                    emit_op(s, OP_push_bigint_i32);
+                    emit_u32(s, v);
                 } else {
-                    val = JS_NewBigInt64_1(s->ctx, e);
-                    if (JS_IsException(val))
-                        return -1;
-                    ret = emit_push_const(s, val, 0);
-                    JS_FreeValue(s->ctx, val);
-                    if (ret < 0)
-                        return -1;
+                    goto large_number;
                 }
-                emit_op(s, OP_mul_pow10);
-            } else
-#endif
-            {
+            } else {
+            large_number:
                 if (emit_push_const(s, val, 0) < 0)
                     return -1;
             }
@@ -24034,7 +25476,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
         if (next_token(s))
             return -1;
         break;
-        
+
     case TOK_DIV_ASSIGN:
         s->buf_ptr -= 2;
         goto parse_regexp;
@@ -24043,7 +25485,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
     parse_regexp:
         {
             JSValue str;
-            int ret, backtrace_flags;
+            int ret;
             if (!s->ctx->compile_regexp)
                 return js_parse_error(s, "RegExp are not supported");
             /* the previous token is '/' or '/=', so no need to free */
@@ -24054,12 +25496,10 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                                          s->token.u.regexp.flags);
             if (JS_IsException(str)) {
                 /* add the line number info */
-                backtrace_flags = 0;
-                if (s->cur_func && s->cur_func->backtrace_barrier)
-                    backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
+                int line_num, col_num;
+                line_num = get_line_col(&col_num, s->buf_start, s->token.ptr - s->buf_start);
                 build_backtrace(s->ctx, s->ctx->rt->current_exception,
-                                s->filename, s->token.line_num,
-                                backtrace_flags);
+                                s->filename, line_num + 1, col_num + 1, 0);
                 return -1;
             }
             ret = emit_push_const(s, str, 0);
@@ -24075,21 +25515,13 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
         }
         break;
     case '(':
-        if ((parse_flags & PF_ARROW_FUNC) &&
-            js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) {
-            if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
-                                       JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                       s->token.ptr, s->token.line_num))
-                return -1;
-        } else {
-            if (js_parse_expr_paren(s))
-                return -1;
-        }
+        if (js_parse_expr_paren(s))
+            return -1;
         break;
     case TOK_FUNCTION:
         if (js_parse_function_decl(s, JS_PARSE_FUNC_EXPR,
                                    JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                   s->token.ptr, s->token.line_num))
+                                   s->token.ptr))
             return -1;
         break;
     case TOK_CLASS:
@@ -24121,37 +25553,19 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
     case TOK_IDENT:
         {
             JSAtom name;
+            const uint8_t *source_ptr;
             if (s->token.u.ident.is_reserved) {
                 return js_parse_error_reserved_identifier(s);
             }
-            if ((parse_flags & PF_ARROW_FUNC) &&
-                peek_token(s, TRUE) == TOK_ARROW) {
-                if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
-                                           JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                           s->token.ptr, s->token.line_num))
-                    return -1;
-            } else if (token_is_pseudo_keyword(s, JS_ATOM_async) &&
-                       peek_token(s, TRUE) != '\n') {
-                const uint8_t *source_ptr;
-                int source_line_num;
-
-                source_ptr = s->token.ptr;
-                source_line_num = s->token.line_num;
+            source_ptr = s->token.ptr;
+            if (token_is_pseudo_keyword(s, JS_ATOM_async) &&
+                peek_token(s, TRUE) != '\n') {
                 if (next_token(s))
                     return -1;
                 if (s->token.val == TOK_FUNCTION) {
                     if (js_parse_function_decl(s, JS_PARSE_FUNC_EXPR,
                                                JS_FUNC_ASYNC, JS_ATOM_NULL,
-                                               source_ptr, source_line_num))
-                        return -1;
-                } else if ((parse_flags & PF_ARROW_FUNC) &&
-                           ((s->token.val == '(' &&
-                             js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) ||
-                            (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved &&
-                             peek_token(s, TRUE) == TOK_ARROW))) {
-                    if (js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
-                                               JS_FUNC_ASYNC, JS_ATOM_NULL,
-                                               source_ptr, source_line_num))
+                                               source_ptr))
                         return -1;
                 } else {
                     name = JS_DupAtom(s->ctx, JS_ATOM_async);
@@ -24164,9 +25578,12 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                     return -1;
                 }
                 name = JS_DupAtom(s->ctx, s->token.u.ident.atom);
-                if (next_token(s))  /* update line number before emitting code */
+                if (next_token(s)) {
+                    JS_FreeAtom(s->ctx, name);
                     return -1;
+                }
             do_get_var:
+                emit_source_pos(s, source_ptr);
                 emit_op(s, OP_scope_get_var);
                 emit_u32(s, name);
                 emit_u16(s, s->cur_func->scope_level);
@@ -24175,20 +25592,12 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
         break;
     case '{':
     case '[':
-        {
-            int skip_bits;
-            if (js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
-                if (js_parse_destructuring_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
-                    return -1;
-            } else {
-                if (s->token.val == '{') {
-                    if (js_parse_object_literal(s))
-                        return -1;
-                } else {
-                    if (js_parse_array_literal(s))
-                        return -1;
-                }
-            }
+        if (s->token.val == '{') {
+            if (js_parse_object_literal(s))
+                return -1;
+        } else {
+            if (js_parse_array_literal(s))
+                return -1;
         }
         break;
     case TOK_NEW:
@@ -24212,6 +25621,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
             accept_lparen = TRUE;
             if (s->token.val != '(') {
                 /* new operator on an object */
+                emit_source_pos(s, s->token.ptr);
                 emit_op(s, OP_dup);
                 emit_op(s, OP_call_constructor);
                 emit_u16(s, 0);
@@ -24262,6 +25672,23 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 return js_parse_error(s, "invalid use of 'import()'");
             if (js_parse_assign_expr(s))
                 return -1;
+            if (s->token.val == ',') {
+                if (next_token(s))
+                    return -1;
+                if (s->token.val != ')') {
+                    if (js_parse_assign_expr(s))
+                        return -1;
+                    /* accept a trailing comma */
+                    if (s->token.val == ',') {
+                        if (next_token(s))
+                            return -1;
+                    }
+                } else {
+                    emit_op(s, OP_undefined);
+                }
+            } else {
+                emit_op(s, OP_undefined);
+            }
             if (js_parse_expect(s, ')'))
                 return -1;
             emit_op(s, OP_import);
@@ -24276,8 +25703,11 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
     for(;;) {
         JSFunctionDef *fd = s->cur_func;
         BOOL has_optional_chain = FALSE;
-        
+
         if (s->token.val == TOK_QUESTION_MARK_DOT) {
+            if ((parse_flags & PF_POSTFIX_CALL) == 0)
+                return js_parse_error(s, "new keyword cannot be used with an optional chain");
+            op_token_ptr = s->token.ptr;
             /* optional chaining */
             if (next_token(s))
                 return -1;
@@ -24295,12 +25725,14 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 return js_parse_error(s, "template literal cannot appear in an optional chain");
             }
             call_type = FUNC_CALL_TEMPLATE;
+            op_token_ptr = s->token.ptr; /* XXX: check if right position */
             goto parse_func_call2;
         } else if (s->token.val == '(' && accept_lparen) {
             int opcode, arg_count, drop_count;
 
             /* function call */
         parse_func_call:
+            op_token_ptr = s->token.ptr;
             if (next_token(s))
                 return -1;
 
@@ -24312,6 +25744,25 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
                     drop_count = 2;
                     break;
+                case OP_get_field_opt_chain:
+                    {
+                        int opt_chain_label, next_label;
+                        opt_chain_label = get_u32(fd->byte_code.buf +
+                                                  fd->last_opcode_pos + 1 + 4 + 1);
+                        /* keep the object on the stack */
+                        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
+                        fd->byte_code.size = fd->last_opcode_pos + 1 + 4;
+                        next_label = emit_goto(s, OP_goto, -1);
+                        emit_label(s, opt_chain_label);
+                        /* need an additional undefined value for the
+                           case where the optional field does not
+                           exists */
+                        emit_op(s, OP_undefined);
+                        emit_label(s, next_label);
+                        drop_count = 2;
+                        opcode = OP_get_field;
+                    }
+                    break;
                 case OP_scope_get_private_field:
                     /* keep the object on the stack */
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_scope_get_private_field2;
@@ -24322,6 +25773,25 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                     fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
                     drop_count = 2;
                     break;
+                case OP_get_array_el_opt_chain:
+                    {
+                        int opt_chain_label, next_label;
+                        opt_chain_label = get_u32(fd->byte_code.buf +
+                                                  fd->last_opcode_pos + 1 + 1);
+                        /* keep the object on the stack */
+                        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
+                        fd->byte_code.size = fd->last_opcode_pos + 1;
+                        next_label = emit_goto(s, OP_goto, -1);
+                        emit_label(s, opt_chain_label);
+                        /* need an additional undefined value for the
+                           case where the optional field does not
+                           exists */
+                        emit_op(s, OP_undefined);
+                        emit_label(s, next_label);
+                        drop_count = 2;
+                        opcode = OP_get_array_el;
+                    }
+                    break;
                 case OP_scope_get_var:
                     {
                         JSAtom name;
@@ -24461,6 +25931,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 /* drop the index */
                 emit_op(s, OP_drop);
 
+                emit_source_pos(s, op_token_ptr);
                 /* apply function call */
                 switch(opcode) {
                 case OP_get_field:
@@ -24506,6 +25977,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 if (next_token(s))
                     return -1;
             emit_func_call:
+                emit_source_pos(s, op_token_ptr);
                 switch(opcode) {
                 case OP_get_field:
                 case OP_scope_get_private_field:
@@ -24544,9 +26016,11 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
             }
             call_type = FUNC_CALL_NORMAL;
         } else if (s->token.val == '.') {
+            op_token_ptr = s->token.ptr;
             if (next_token(s))
                 return -1;
         parse_property:
+            emit_source_pos(s, op_token_ptr);
             if (s->token.val == TOK_PRIVATE_NAME) {
                 /* private class field */
                 if (get_prev_opcode(fd) == OP_get_super) {
@@ -24583,7 +26057,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 return -1;
         } else if (s->token.val == '[') {
             int prev_op;
-
+            op_token_ptr = s->token.ptr;
         parse_array_access:
             prev_op = get_prev_opcode(fd);
             if (has_optional_chain) {
@@ -24595,6 +26069,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
                 return -1;
             if (js_parse_expect(s, ']'))
                 return -1;
+            emit_source_pos(s, op_token_ptr);
             if (prev_op == OP_get_super) {
                 emit_op(s, OP_get_super_value);
             } else {
@@ -24604,8 +26079,23 @@ static __exception int js_parse_postfix_expr(JSParseState *s, int parse_flags)
             break;
         }
     }
-    if (optional_chaining_label >= 0)
-        emit_label(s, optional_chaining_label);
+    if (optional_chaining_label >= 0) {
+        JSFunctionDef *fd = s->cur_func;
+        int opcode;
+        emit_label_raw(s, optional_chaining_label);
+        /* modify the last opcode so that it is an indicator of an
+           optional chain */
+        opcode = get_prev_opcode(fd);
+        if (opcode == OP_get_field || opcode == OP_get_array_el) {
+            if (opcode == OP_get_field)
+                opcode = OP_get_field_opt_chain;
+            else
+                opcode = OP_get_array_el_opt_chain;
+            fd->byte_code.buf[fd->last_opcode_pos] = opcode;
+        } else {
+            fd->last_opcode_pos = -1;
+        }
+    }
     return 0;
 }
 
@@ -24621,27 +26111,57 @@ static __exception int js_parse_delete(JSParseState *s)
         return -1;
     switch(opcode = get_prev_opcode(fd)) {
     case OP_get_field:
+    case OP_get_field_opt_chain:
         {
             JSValue val;
-            int ret;
-
+            int ret, opt_chain_label, next_label;
+            if (opcode == OP_get_field_opt_chain) {
+                opt_chain_label = get_u32(fd->byte_code.buf +
+                                          fd->last_opcode_pos + 1 + 4 + 1);
+            } else {
+                opt_chain_label = -1;
+            }
             name = get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
             fd->byte_code.size = fd->last_opcode_pos;
-            fd->last_opcode_pos = -1;
             val = JS_AtomToValue(s->ctx, name);
             ret = emit_push_const(s, val, 1);
             JS_FreeValue(s->ctx, val);
             JS_FreeAtom(s->ctx, name);
             if (ret)
                 return ret;
+            emit_op(s, OP_delete);
+            if (opt_chain_label >= 0) {
+                next_label = emit_goto(s, OP_goto, -1);
+                emit_label(s, opt_chain_label);
+                /* if the optional chain is not taken, return 'true' */
+                emit_op(s, OP_drop);
+                emit_op(s, OP_push_true);
+                emit_label(s, next_label);
+            }
+            fd->last_opcode_pos = -1;
         }
-        goto do_delete;
+        break;
     case OP_get_array_el:
         fd->byte_code.size = fd->last_opcode_pos;
         fd->last_opcode_pos = -1;
-    do_delete:
         emit_op(s, OP_delete);
         break;
+    case OP_get_array_el_opt_chain:
+        {
+            int opt_chain_label, next_label;
+            opt_chain_label = get_u32(fd->byte_code.buf +
+                                      fd->last_opcode_pos + 1 + 1);
+            fd->byte_code.size = fd->last_opcode_pos;
+            emit_op(s, OP_delete);
+            next_label = emit_goto(s, OP_goto, -1);
+            emit_label(s, opt_chain_label);
+            /* if the optional chain is not taken, return 'true' */
+            emit_op(s, OP_drop);
+            emit_op(s, OP_push_true);
+            emit_label(s, next_label);
+            fd->last_opcode_pos = -1;
+        }
+        break;
     case OP_scope_get_var:
         /* 'delete this': this is not a reference */
         name = get_u32(fd->byte_code.buf + fd->last_opcode_pos + 1);
@@ -24671,10 +26191,11 @@ static __exception int js_parse_delete(JSParseState *s)
     return 0;
 }
 
-/* allowed parse_flags: PF_ARROW_FUNC, PF_POW_ALLOWED, PF_POW_FORBIDDEN */
+/* allowed parse_flags: PF_POW_ALLOWED, PF_POW_FORBIDDEN */
 static __exception int js_parse_unary(JSParseState *s, int parse_flags)
 {
     int op;
+    const uint8_t *op_token_ptr;
 
     switch(s->token.val) {
     case '+':
@@ -24682,6 +26203,7 @@ static __exception int js_parse_unary(JSParseState *s, int parse_flags)
     case '!':
     case '~':
     case TOK_VOID:
+        op_token_ptr = s->token.ptr;
         op = s->token.val;
         if (next_token(s))
             return -1;
@@ -24689,15 +26211,18 @@ static __exception int js_parse_unary(JSParseState *s, int parse_flags)
             return -1;
         switch(op) {
         case '-':
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_neg);
             break;
         case '+':
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_plus);
             break;
         case '!':
             emit_op(s, OP_lnot);
             break;
         case '~':
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_not);
             break;
         case TOK_VOID:
@@ -24715,12 +26240,14 @@ static __exception int js_parse_unary(JSParseState *s, int parse_flags)
             int opcode, op, scope, label;
             JSAtom name;
             op = s->token.val;
+            op_token_ptr = s->token.ptr;
             if (next_token(s))
                 return -1;
             if (js_parse_unary(s, 0))
                 return -1;
             if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
                 return -1;
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_dec + op - TOK_DEC);
             put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP,
                        FALSE);
@@ -24757,47 +26284,31 @@ static __exception int js_parse_unary(JSParseState *s, int parse_flags)
             return -1;
         if (js_parse_unary(s, PF_POW_FORBIDDEN))
             return -1;
+        s->cur_func->has_await = TRUE;
         emit_op(s, OP_await);
         parse_flags = 0;
         break;
     default:
-        if (js_parse_postfix_expr(s, (parse_flags & PF_ARROW_FUNC) |
-                                  PF_POSTFIX_CALL))
+        if (js_parse_postfix_expr(s, PF_POSTFIX_CALL))
             return -1;
         if (!s->got_lf &&
             (s->token.val == TOK_DEC || s->token.val == TOK_INC)) {
             int opcode, op, scope, label;
             JSAtom name;
             op = s->token.val;
+            op_token_ptr = s->token.ptr;
             if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, TRUE, op))
                 return -1;
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_post_dec + op - TOK_DEC);
             put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_SECOND,
                        FALSE);
             if (next_token(s))
-                return -1;        
+                return -1;
         }
         break;
     }
     if (parse_flags & (PF_POW_ALLOWED | PF_POW_FORBIDDEN)) {
-#ifdef CONFIG_BIGNUM
-        if (s->token.val == TOK_POW || s->token.val == TOK_MATH_POW) {
-            /* Extended exponentiation syntax rules: we extend the ES7
-               grammar in order to have more intuitive semantics:
-               -2**2 evaluates to -4. */
-            if (!(s->cur_func->js_mode & JS_MODE_MATH)) {
-                if (parse_flags & PF_POW_FORBIDDEN) {
-                    JS_ThrowSyntaxError(s->ctx, "unparenthesized unary expression can't appear on the left-hand side of '**'");
-                    return -1;
-                }
-            }
-            if (next_token(s))
-                return -1;
-            if (js_parse_unary(s, PF_POW_ALLOWED))
-                return -1;
-            emit_op(s, OP_pow);
-        }
-#else
         if (s->token.val == TOK_POW) {
             /* Strict ES7 exponentiation syntax rules: To solve
                conficting semantics between different implementations
@@ -24808,31 +26319,56 @@ static __exception int js_parse_unary(JSParseState *s, int parse_flags)
                 JS_ThrowSyntaxError(s->ctx, "unparenthesized unary expression can't appear on the left-hand side of '**'");
                 return -1;
             }
+            op_token_ptr = s->token.ptr;
             if (next_token(s))
                 return -1;
             if (js_parse_unary(s, PF_POW_ALLOWED))
                 return -1;
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, OP_pow);
         }
-#endif
     }
     return 0;
 }
 
-/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
+/* allowed parse_flags: PF_IN_ACCEPTED */
 static __exception int js_parse_expr_binary(JSParseState *s, int level,
                                             int parse_flags)
 {
     int op, opcode;
-
+    const uint8_t *op_token_ptr;
+    
     if (level == 0) {
-        return js_parse_unary(s, (parse_flags & PF_ARROW_FUNC) |
-                              PF_POW_ALLOWED);
+        return js_parse_unary(s, PF_POW_ALLOWED);
+    } else if (s->token.val == TOK_PRIVATE_NAME &&
+               (parse_flags & PF_IN_ACCEPTED) && level == 4 &&
+               peek_token(s, FALSE) == TOK_IN) {
+        JSAtom atom;
+
+        atom = JS_DupAtom(s->ctx, s->token.u.ident.atom);
+        if (next_token(s))
+            goto fail_private_in;
+        if (s->token.val != TOK_IN)
+            goto fail_private_in;
+        if (next_token(s))
+            goto fail_private_in;
+        if (js_parse_expr_binary(s, level - 1, parse_flags)) {
+        fail_private_in:
+            JS_FreeAtom(s->ctx, atom);
+            return -1;
+        }
+        emit_op(s, OP_scope_in_private_field);
+        emit_atom(s, atom);
+        emit_u16(s, s->cur_func->scope_level);
+        JS_FreeAtom(s->ctx, atom);
+        return 0;
+    } else {
+        if (js_parse_expr_binary(s, level - 1, parse_flags))
+            return -1;
     }
-    if (js_parse_expr_binary(s, level - 1, parse_flags))
-        return -1;
     for(;;) {
         op = s->token.val;
+        op_token_ptr = s->token.ptr;
         switch(level) {
         case 1:
             switch(op) {
@@ -24843,12 +26379,7 @@ static __exception int js_parse_expr_binary(JSParseState *s, int level,
                 opcode = OP_div;
                 break;
             case '%':
-#ifdef CONFIG_BIGNUM
-                if (s->cur_func->js_mode & JS_MODE_MATH)
-                    opcode = OP_math_mod;
-                else
-#endif
-                    opcode = OP_mod;
+                opcode = OP_mod;
                 break;
             default:
                 return 0;
@@ -24959,14 +26490,15 @@ static __exception int js_parse_expr_binary(JSParseState *s, int level,
         }
         if (next_token(s))
             return -1;
-        if (js_parse_expr_binary(s, level - 1, parse_flags & ~PF_ARROW_FUNC))
+        if (js_parse_expr_binary(s, level - 1, parse_flags))
             return -1;
+        emit_source_pos(s, op_token_ptr);
         emit_op(s, opcode);
     }
     return 0;
 }
 
-/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
+/* allowed parse_flags: PF_IN_ACCEPTED */
 static __exception int js_parse_logical_and_or(JSParseState *s, int op,
                                                int parse_flags)
 {
@@ -24990,11 +26522,11 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
             emit_op(s, OP_drop);
 
             if (op == TOK_LAND) {
-                if (js_parse_expr_binary(s, 8, parse_flags & ~PF_ARROW_FUNC))
+                if (js_parse_expr_binary(s, 8, parse_flags))
                     return -1;
             } else {
                 if (js_parse_logical_and_or(s, TOK_LAND,
-                                            parse_flags & ~PF_ARROW_FUNC))
+                                            parse_flags))
                     return -1;
             }
             if (s->token.val != op) {
@@ -25012,7 +26544,7 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
 static __exception int js_parse_coalesce_expr(JSParseState *s, int parse_flags)
 {
     int label1;
-    
+
     if (js_parse_logical_and_or(s, TOK_LOR, parse_flags))
         return -1;
     if (s->token.val == TOK_DOUBLE_QUESTION_MARK) {
@@ -25020,13 +26552,13 @@ static __exception int js_parse_coalesce_expr(JSParseState *s, int parse_flags)
         for(;;) {
             if (next_token(s))
                 return -1;
-            
+
             emit_op(s, OP_dup);
             emit_op(s, OP_is_undefined_or_null);
             emit_goto(s, OP_if_false, label1);
             emit_op(s, OP_drop);
-            
-            if (js_parse_expr_binary(s, 8, parse_flags & ~PF_ARROW_FUNC))
+
+            if (js_parse_expr_binary(s, 8, parse_flags))
                 return -1;
             if (s->token.val != TOK_DOUBLE_QUESTION_MARK)
                 break;
@@ -25036,7 +26568,7 @@ static __exception int js_parse_coalesce_expr(JSParseState *s, int parse_flags)
     return 0;
 }
 
-/* allowed parse_flags: PF_ARROW_FUNC, PF_IN_ACCEPTED */
+/* allowed parse_flags: PF_IN_ACCEPTED */
 static __exception int js_parse_cond_expr(JSParseState *s, int parse_flags)
 {
     int label1, label2;
@@ -25065,18 +26597,16 @@ static __exception int js_parse_cond_expr(JSParseState *s, int parse_flags)
     return 0;
 }
 
-static void emit_return(JSParseState *s, BOOL hasval);
-
 /* allowed parse_flags: PF_IN_ACCEPTED */
 static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
 {
-    int opcode, op, scope;
+    int opcode, op, scope, skip_bits;
     JSAtom name0 = JS_ATOM_NULL;
     JSAtom name;
 
     if (s->token.val == TOK_YIELD) {
         BOOL is_star = FALSE, is_async;
-        
+
         if (!(s->cur_func->func_kind & JS_FUNC_GENERATOR))
             return js_parse_error(s, "unexpected 'yield' keyword");
         if (!s->cur_func->in_function_body)
@@ -25114,9 +26644,9 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
                undefined) */
             emit_op(s, OP_drop);
             emit_op(s, OP_undefined);
-            
+
             emit_op(s, OP_undefined); /* initial value */
-            
+
             emit_label(s, label_loop);
             emit_op(s, OP_iterator_next);
             if (is_async)
@@ -25130,7 +26660,6 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
                 /* OP_async_yield_star takes the value as parameter */
                 emit_op(s, OP_get_field);
                 emit_atom(s, JS_ATOM_value);
-                emit_op(s, OP_await);
                 emit_op(s, OP_async_yield_star);
             } else {
                 /* OP_yield_star takes (value, done) as parameter */
@@ -25140,13 +26669,13 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
             label_return = emit_goto(s, OP_if_true, -1);
             emit_op(s, OP_drop);
             emit_goto(s, OP_goto, label_loop);
-            
+
             emit_label(s, label_return);
             emit_op(s, OP_push_i32);
             emit_u32(s, 2);
             emit_op(s, OP_strict_eq);
             label_throw = emit_goto(s, OP_if_true, -1);
-            
+
             /* return handling */
             if (is_async)
                 emit_op(s, OP_await);
@@ -25162,13 +26691,13 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
 
             emit_op(s, OP_get_field);
             emit_atom(s, JS_ATOM_value);
-            
+
             emit_label(s, label_return1);
             emit_op(s, OP_nip);
             emit_op(s, OP_nip);
             emit_op(s, OP_nip);
             emit_return(s, TRUE);
-            
+
             /* throw handling */
             emit_label(s, label_throw);
             emit_op(s, OP_iterator_call);
@@ -25193,7 +26722,7 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
             emit_op(s, OP_throw_error);
             emit_atom(s, JS_ATOM_NULL);
             emit_u8(s, JS_THROW_ERROR_ITERATOR_THROW);
-            
+
             emit_label(s, label_next);
             emit_op(s, OP_get_field);
             emit_atom(s, JS_ATOM_value);
@@ -25203,7 +26732,7 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
             emit_op(s, OP_nip);
         } else {
             int label_next;
-            
+
             if (is_async)
                 emit_op(s, OP_await);
             emit_op(s, OP_yield);
@@ -25212,17 +26741,61 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
             emit_label(s, label_next);
         }
         return 0;
+    } else if (s->token.val == '(' &&
+               js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) {
+        return js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
+                                      JS_FUNC_NORMAL, JS_ATOM_NULL,
+                                      s->token.ptr);
+    } else if (token_is_pseudo_keyword(s, JS_ATOM_async)) {
+        const uint8_t *source_ptr;
+        int tok;
+        JSParsePos pos;
+
+        /* fast test */
+        tok = peek_token(s, TRUE);
+        if (tok == TOK_FUNCTION || tok == '\n')
+            goto next;
+
+        source_ptr = s->token.ptr;
+        js_parse_get_pos(s, &pos);
+        if (next_token(s))
+            return -1;
+        if ((s->token.val == '(' &&
+             js_parse_skip_parens_token(s, NULL, TRUE) == TOK_ARROW) ||
+            (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved &&
+             peek_token(s, TRUE) == TOK_ARROW)) {
+            return js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
+                                          JS_FUNC_ASYNC, JS_ATOM_NULL,
+                                          source_ptr);
+        } else {
+            /* undo the token parsing */
+            if (js_parse_seek_token(s, &pos))
+                return -1;
+        }
+    } else if (s->token.val == TOK_IDENT &&
+               peek_token(s, TRUE) == TOK_ARROW) {
+        return js_parse_function_decl(s, JS_PARSE_FUNC_ARROW,
+                                      JS_FUNC_NORMAL, JS_ATOM_NULL,
+                                      s->token.ptr);
+    } else if ((s->token.val == '{' || s->token.val == '[') &&
+               js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
+        if (js_parse_destructuring_element(s, 0, 0, FALSE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE, FALSE) < 0)
+            return -1;
+        return 0;
     }
+ next:
     if (s->token.val == TOK_IDENT) {
         /* name0 is used to check for OP_set_name pattern, not duplicated */
         name0 = s->token.u.ident.atom;
     }
-    if (js_parse_cond_expr(s, parse_flags | PF_ARROW_FUNC))
+    if (js_parse_cond_expr(s, parse_flags))
         return -1;
 
     op = s->token.val;
     if (op == '=' || (op >= TOK_MUL_ASSIGN && op <= TOK_POW_ASSIGN)) {
         int label;
+        const uint8_t *op_token_ptr;
+        op_token_ptr = s->token.ptr;
         if (next_token(s))
             return -1;
         if (get_lvalue(s, &opcode, &scope, &name, &label, NULL, (op != '='), op) < 0)
@@ -25241,24 +26814,16 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
             static const uint8_t assign_opcodes[] = {
                 OP_mul, OP_div, OP_mod, OP_add, OP_sub,
                 OP_shl, OP_sar, OP_shr, OP_and, OP_xor, OP_or,
-#ifdef CONFIG_BIGNUM
-                OP_pow,
-#endif
                 OP_pow,
             };
             op = assign_opcodes[op - TOK_MUL_ASSIGN];
-#ifdef CONFIG_BIGNUM
-            if (s->cur_func->js_mode & JS_MODE_MATH) {
-                if (op == OP_mod)
-                    op = OP_math_mod;
-            }
-#endif
+            emit_source_pos(s, op_token_ptr);
             emit_op(s, op);
         }
         put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
     } else if (op >= TOK_LAND_ASSIGN && op <= TOK_DOUBLE_QUESTION_MARK_ASSIGN) {
         int label, label1, depth_lvalue, label2;
-        
+
         if (next_token(s))
             return -1;
         if (get_lvalue(s, &opcode, &scope, &name, &label,
@@ -25271,7 +26836,7 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
         label1 = emit_goto(s, op == TOK_LOR_ASSIGN ? OP_if_true : OP_if_false,
                            -1);
         emit_op(s, OP_drop);
-        
+
         if (js_parse_assign_expr2(s, parse_flags)) {
             JS_FreeAtom(s->ctx, name);
             return -1;
@@ -25280,7 +26845,7 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
         if (opcode == OP_get_ref_value && name == name0) {
             set_object_name(s, name);
         }
-        
+
         switch(depth_lvalue) {
         case 1:
             emit_op(s, OP_insert2);
@@ -25300,7 +26865,7 @@ static __exception int js_parse_assign_expr2(JSParseState *s, int parse_flags)
         put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_NOKEEP_DEPTH,
                    FALSE);
         label2 = emit_goto(s, OP_goto, -1);
-        
+
         emit_label(s, label1);
 
         /* remove the lvalue stack entries */
@@ -25363,6 +26928,7 @@ static void push_break_entry(JSFunctionDef *fd, BlockEnv *be,
     be->label_finally = -1;
     be->scope_level = fd->scope_level;
     be->has_iterator = FALSE;
+    be->is_regular_stmt = FALSE;
 }
 
 static void pop_break_entry(JSFunctionDef *fd)
@@ -25391,7 +26957,8 @@ static __exception int emit_break(JSParseState *s, JSAtom name, int is_cont)
         }
         if (!is_cont &&
             top->label_break != -1 &&
-            (name == JS_ATOM_NULL || top->label_name == name)) {
+            ((name == JS_ATOM_NULL && !top->is_regular_stmt) ||
+             top->label_name == name)) {
             emit_goto(s, OP_goto, top->label_break);
             return 0;
         }
@@ -25424,61 +26991,61 @@ static __exception int emit_break(JSParseState *s, JSAtom name, int is_cont)
 static void emit_return(JSParseState *s, BOOL hasval)
 {
     BlockEnv *top;
-    int drop_count;
 
-    drop_count = 0;
+    if (s->cur_func->func_kind != JS_FUNC_NORMAL) {
+        if (!hasval) {
+            /* no value: direct return in case of async generator */
+            emit_op(s, OP_undefined);
+            hasval = TRUE;
+        } else if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
+            /* the await must be done before handling the "finally" in
+               case it raises an exception */
+            emit_op(s, OP_await);
+        }
+    }
+
     top = s->cur_func->top_break;
     while (top != NULL) {
-        /* XXX: emit the appropriate OP_leave_scope opcodes? Probably not
-           required as all local variables will be closed upon returning
-           from JS_CallInternal, but not in the same order. */
-        if (top->has_iterator) {
-            /* with 'yield', the exact number of OP_drop to emit is
-               unknown, so we use a specific operation to look for
-               the catch offset */
+        if (top->has_iterator || top->label_finally != -1) {
             if (!hasval) {
                 emit_op(s, OP_undefined);
                 hasval = TRUE;
             }
-            emit_op(s, OP_iterator_close_return);
-            if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
-                int label_next, label_next2;
-
-                emit_op(s, OP_drop); /* catch offset */
-                emit_op(s, OP_drop); /* next */
-                emit_op(s, OP_get_field2);
-                emit_atom(s, JS_ATOM_return);
-                /* stack: iter_obj return_func */
-                emit_op(s, OP_dup);
-                emit_op(s, OP_is_undefined_or_null);
-                label_next = emit_goto(s, OP_if_true, -1);
-                emit_op(s, OP_call_method);
-                emit_u16(s, 0);
-                emit_op(s, OP_iterator_check_object);
-                emit_op(s, OP_await);
-                label_next2 = emit_goto(s, OP_goto, -1);
-                emit_label(s, label_next);
-                emit_op(s, OP_drop);
-                emit_label(s, label_next2);
-                emit_op(s, OP_drop);
+            /* Remove the stack elements up to and including the catch
+               offset. When 'yield' is used in an expression we have
+               no easy way to count them, so we use this specific
+               instruction instead. */
+            emit_op(s, OP_nip_catch);
+            /* stack: iter_obj next ret_val */
+            if (top->has_iterator) {
+                if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
+                    int label_next, label_next2;
+                    emit_op(s, OP_nip); /* next */
+                    emit_op(s, OP_swap);
+                    emit_op(s, OP_get_field2);
+                    emit_atom(s, JS_ATOM_return);
+                    /* stack: iter_obj return_func */
+                    emit_op(s, OP_dup);
+                    emit_op(s, OP_is_undefined_or_null);
+                    label_next = emit_goto(s, OP_if_true, -1);
+                    emit_op(s, OP_call_method);
+                    emit_u16(s, 0);
+                    emit_op(s, OP_iterator_check_object);
+                    emit_op(s, OP_await);
+                    label_next2 = emit_goto(s, OP_goto, -1);
+                    emit_label(s, label_next);
+                    emit_op(s, OP_drop);
+                    emit_label(s, label_next2);
+                    emit_op(s, OP_drop);
+                } else {
+                    emit_op(s, OP_rot3r);
+                    emit_op(s, OP_undefined); /* dummy catch offset */
+                    emit_op(s, OP_iterator_close);
+                }
             } else {
-                emit_op(s, OP_iterator_close);
-            }
-            drop_count = -3;
-        }
-        drop_count += top->drop_count;
-        if (top->label_finally != -1) {
-            while(drop_count) {
-                /* must keep the stack top if hasval */
-                emit_op(s, hasval ? OP_nip : OP_drop);
-                drop_count--;
-            }
-            if (!hasval) {
-                /* must push return value to keep same stack size */
-                emit_op(s, OP_undefined);
-                hasval = TRUE;
+                /* execute the "finally" block */
+                emit_goto(s, OP_gosub, top->label_finally);
             }
-            emit_goto(s, OP_gosub, top->label_finally);
         }
         top = top->prev;
     }
@@ -25495,20 +27062,15 @@ static void emit_return(JSParseState *s, BOOL hasval)
             label_return = -1;
         }
 
-        /* XXX: if this is not initialized, should throw the
-           ReferenceError in the caller realm */
-        emit_op(s, OP_scope_get_var);
+        /* The error should be raised in the caller context, so we use
+           a specific opcode */
+        emit_op(s, OP_scope_get_var_checkthis);
         emit_atom(s, JS_ATOM_this);
         emit_u16(s, 0);
 
         emit_label(s, label_return);
         emit_op(s, OP_return);
     } else if (s->cur_func->func_kind != JS_FUNC_NORMAL) {
-        if (!hasval) {
-            emit_op(s, OP_undefined);
-        } else if (s->cur_func->func_kind == JS_FUNC_ASYNC_GENERATOR) {
-            emit_op(s, OP_await);
-        }
         emit_op(s, OP_return_async);
     } else {
         emit_op(s, hasval ? OP_return : OP_return_undef);
@@ -25579,7 +27141,7 @@ static __exception int js_parse_var(JSParseState *s, int parse_flags, int tok,
             if (s->token.val == '=') {
                 if (next_token(s))
                     goto var_error;
-                if (tok == TOK_VAR) {
+                if (need_var_reference(s, tok)) {
                     /* Must make a reference for proper `with` semantics */
                     int opcode, scope, label;
                     JSAtom name1;
@@ -25624,7 +27186,7 @@ static __exception int js_parse_var(JSParseState *s, int parse_flags, int tok,
             if ((s->token.val == '[' || s->token.val == '{')
             &&  js_parse_skip_parens_token(s, &skip_bits, FALSE) == '=') {
                 emit_op(s, OP_undefined);
-                if (js_parse_destructuring_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE, export_flag) < 0)
                     return -1;
             } else {
                 return js_parse_error(s, "variable name expected");
@@ -25653,12 +27215,13 @@ static BOOL is_label(JSParseState *s)
 static int is_let(JSParseState *s, int decl_mask)
 {
     int res = FALSE;
-
+    const uint8_t *last_token_ptr;
+    
     if (token_is_pseudo_keyword(s, JS_ATOM_let)) {
-#if 1
         JSParsePos pos;
         js_parse_get_pos(s, &pos);
         for (;;) {
+            last_token_ptr = s->token.ptr;
             if (next_token(s)) {
                 res = -1;
                 break;
@@ -25677,7 +27240,8 @@ static int is_let(JSParseState *s, int decl_mask)
                 /* Check for possible ASI if not scanning for Declaration */
                 /* XXX: should also check that `{` introduces a BindingPattern,
                    but Firefox does not and rejects eval("let=1;let\n{if(1)2;}") */
-                if (s->last_line_num == s->token.line_num || (decl_mask & DECL_MASK_OTHER)) {
+                if (!has_lf_in_range(last_token_ptr, s->token.ptr) ||
+                    (decl_mask & DECL_MASK_OTHER)) {
                     res = TRUE;
                     break;
                 }
@@ -25688,12 +27252,6 @@ static int is_let(JSParseState *s, int decl_mask)
         if (js_parse_seek_token(s, &pos)) {
             res = -1;
         }
-#else
-        int tok = peek_token(s, TRUE);
-        if (tok == '{' || tok == TOK_IDENT || peek_token(s, FALSE) == '[') {
-            res = TRUE;
-        }
-#endif
     }
     return res;
 }
@@ -25753,7 +27311,7 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
 
         if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
             if (s->token.val == '[' || s->token.val == '{') {
-                if (js_parse_destructuring_element(s, tok, 0, TRUE, -1, FALSE) < 0)
+                if (js_parse_destructuring_element(s, tok, 0, TRUE, -1, FALSE, FALSE) < 0)
                     return -1;
                 has_destructuring = TRUE;
             } else {
@@ -25775,11 +27333,14 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
             emit_atom(s, var_name);
             emit_u16(s, fd->scope_level);
         }
+    } else if (!is_async && token_is_pseudo_keyword(s, JS_ATOM_async) &&
+               peek_token(s, FALSE) == TOK_OF) {
+        return js_parse_error(s, "'for of' expression cannot start with 'async'");
     } else {
         int skip_bits;
         if ((s->token.val == '[' || s->token.val == '{')
         &&  ((tok1 = js_parse_skip_parens_token(s, &skip_bits, FALSE)) == TOK_IN || tok1 == TOK_OF)) {
-            if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE) < 0)
+            if (js_parse_destructuring_element(s, 0, 0, TRUE, skip_bits & SKIP_HAS_ELLIPSIS, TRUE, FALSE) < 0)
                 return -1;
         } else {
             int lvalue_label;
@@ -25888,12 +27449,9 @@ static __exception int js_parse_for_in_of(JSParseState *s, int label_name,
     emit_label(s, label_cont);
     if (is_for_of) {
         if (is_async) {
-            /* call the next method */
             /* stack: iter_obj next catch_offset */
-            emit_op(s, OP_dup3);
-            emit_op(s, OP_drop);
-            emit_op(s, OP_call_method);
-            emit_u16(s, 0);
+            /* call the next method */
+            emit_op(s, OP_for_await_of_next); 
             /* get the result of the promise */
             emit_op(s, OP_await);
             /* unwrap the value and done values */
@@ -25967,6 +27525,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
             label_break = new_label(s);
             push_break_entry(s->cur_func, &break_entry,
                              label_name, label_break, -1, 0);
+            break_entry.is_regular_stmt = TRUE;
             if (!(s->cur_func->js_mode & JS_MODE_STRICT) &&
                 (decl_mask & DECL_MASK_FUNC_WITH_LABEL)) {
                 mask = DECL_MASK_FUNC | DECL_MASK_FUNC_WITH_LABEL;
@@ -25987,34 +27546,49 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
             goto fail;
         break;
     case TOK_RETURN:
-        if (s->cur_func->is_eval) {
-            js_parse_error(s, "return not in a function");
-            goto fail;
-        }
-        if (next_token(s))
-            goto fail;
-        if (s->token.val != ';' && s->token.val != '}' && !s->got_lf) {
-            if (js_parse_expr(s))
+        {
+            const uint8_t *op_token_ptr;
+            if (s->cur_func->is_eval) {
+                js_parse_error(s, "return not in a function");
+                goto fail;
+            }
+            if (s->cur_func->func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT) {
+                js_parse_error(s, "return in a static initializer block");
+                goto fail;
+            }
+            op_token_ptr = s->token.ptr;
+            if (next_token(s))
+                goto fail;
+            if (s->token.val != ';' && s->token.val != '}' && !s->got_lf) {
+                if (js_parse_expr(s))
+                    goto fail;
+                emit_source_pos(s, op_token_ptr);
+                emit_return(s, TRUE);
+            } else {
+                emit_source_pos(s, op_token_ptr);
+                emit_return(s, FALSE);
+            }
+            if (js_parse_expect_semi(s))
                 goto fail;
-            emit_return(s, TRUE);
-        } else {
-            emit_return(s, FALSE);
         }
-        if (js_parse_expect_semi(s))
-            goto fail;
         break;
     case TOK_THROW:
-        if (next_token(s))
-            goto fail;
-        if (s->got_lf) {
-            js_parse_error(s, "line terminator not allowed after throw");
-            goto fail;
+        {
+            const uint8_t *op_token_ptr;
+            op_token_ptr = s->token.ptr;
+            if (next_token(s))
+                goto fail;
+            if (s->got_lf) {
+                js_parse_error(s, "line terminator not allowed after throw");
+                goto fail;
+            }
+            if (js_parse_expr(s))
+                goto fail;
+            emit_source_pos(s, op_token_ptr);
+            emit_op(s, OP_throw);
+            if (js_parse_expect_semi(s))
+                goto fail;
         }
-        if (js_parse_expr(s))
-            goto fail;
-        emit_op(s, OP_throw);
-        if (js_parse_expect_semi(s))
-            goto fail;
         break;
     case TOK_LET:
     case TOK_CONST:
@@ -26159,6 +27733,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                 is_async = TRUE;
                 if (next_token(s))
                     goto fail;
+                s->cur_func->has_await = TRUE;
             }
             if (js_parse_expect(s, '('))
                 goto fail;
@@ -26451,7 +28026,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                     if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)) {
                         if (s->token.val == '[' || s->token.val == '{') {
                             /* XXX: TOK_LET is not completely correct */
-                            if (js_parse_destructuring_element(s, TOK_LET, 0, TRUE, -1, TRUE) < 0)
+                            if (js_parse_destructuring_element(s, TOK_LET, 0, TRUE, -1, TRUE, FALSE) < 0)
                                 goto fail;
                         } else {
                             js_parse_error(s, "identifier expected");
@@ -26518,7 +28093,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
             emit_label(s, label_finally);
             if (s->token.val == TOK_FINALLY) {
                 int saved_eval_ret_idx = 0; /* avoid warning */
-                
+
                 if (next_token(s))
                     goto fail;
                 /* on the stack: ret_value gosub_ret_value */
@@ -26538,7 +28113,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
                     emit_u16(s, saved_eval_ret_idx);
                     set_eval_ret_undefined(s);
                 }
-                
+
                 if (js_parse_block(s))
                     goto fail;
 
@@ -26621,7 +28196,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
         parse_func_var:
             if (js_parse_function_decl(s, JS_PARSE_FUNC_VAR,
                                        JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                       s->token.ptr, s->token.line_num))
+                                       s->token.ptr))
                 goto fail;
             break;
         }
@@ -26643,7 +28218,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
         if (js_parse_expect_semi(s))
             goto fail;
         break;
-        
+
     case TOK_ENUM:
     case TOK_EXPORT:
     case TOK_EXTENDS:
@@ -26652,6 +28227,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
 
     default:
     hasexpr:
+        emit_source_pos(s, s->token.ptr);
         if (js_parse_expr(s))
             goto fail;
         if (s->cur_func->eval_ret_idx >= 0) {
@@ -26674,7 +28250,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
     return -1;
 }
 
-/* 'name' is freed */
+/* 'name' is freed. The module is referenced by 'ctx->loaded_modules' */
 static JSModuleDef *js_new_module_def(JSContext *ctx, JSAtom name)
 {
     JSModuleDef *m;
@@ -26684,11 +28260,16 @@ static JSModuleDef *js_new_module_def(JSContext *ctx, JSAtom name)
         return NULL;
     }
     m->header.ref_count = 1;
+    add_gc_object(ctx->rt, &m->header, JS_GC_OBJ_TYPE_MODULE);
     m->module_name = name;
     m->module_ns = JS_UNDEFINED;
     m->func_obj = JS_UNDEFINED;
     m->eval_exception = JS_UNDEFINED;
     m->meta_obj = JS_UNDEFINED;
+    m->promise = JS_UNDEFINED;
+    m->resolving_funcs[0] = JS_UNDEFINED;
+    m->resolving_funcs[1] = JS_UNDEFINED;
+    m->private_value = JS_UNDEFINED;
     list_add_tail(&m->link, &ctx->loaded_modules);
     return m;
 }
@@ -26698,6 +28279,11 @@ static void js_mark_module_def(JSRuntime *rt, JSModuleDef *m,
 {
     int i;
 
+    for(i = 0; i < m->req_module_entries_count; i++) {
+        JSReqModuleEntry *rme = &m->req_module_entries[i];
+        JS_MarkValue(rt, rme->attributes, mark_func);
+    }
+    
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
         if (me->export_type == JS_EXPORT_TYPE_LOCAL &&
@@ -26710,57 +28296,68 @@ static void js_mark_module_def(JSRuntime *rt, JSModuleDef *m,
     JS_MarkValue(rt, m->func_obj, mark_func);
     JS_MarkValue(rt, m->eval_exception, mark_func);
     JS_MarkValue(rt, m->meta_obj, mark_func);
+    JS_MarkValue(rt, m->promise, mark_func);
+    JS_MarkValue(rt, m->resolving_funcs[0], mark_func);
+    JS_MarkValue(rt, m->resolving_funcs[1], mark_func);
+    JS_MarkValue(rt, m->private_value, mark_func);
 }
 
-static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
+static void js_free_module_def(JSRuntime *rt, JSModuleDef *m)
 {
     int i;
 
-    JS_FreeAtom(ctx, m->module_name);
+    JS_FreeAtomRT(rt, m->module_name);
 
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        JS_FreeAtom(ctx, rme->module_name);
+        JS_FreeAtomRT(rt, rme->module_name);
+        JS_FreeValueRT(rt, rme->attributes);
     }
-    js_free(ctx, m->req_module_entries);
+    js_free_rt(rt, m->req_module_entries);
 
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
         if (me->export_type == JS_EXPORT_TYPE_LOCAL)
-            free_var_ref(ctx->rt, me->u.local.var_ref);
-        JS_FreeAtom(ctx, me->export_name);
-        JS_FreeAtom(ctx, me->local_name);
+            free_var_ref(rt, me->u.local.var_ref);
+        JS_FreeAtomRT(rt, me->export_name);
+        JS_FreeAtomRT(rt, me->local_name);
     }
-    js_free(ctx, m->export_entries);
+    js_free_rt(rt, m->export_entries);
 
-    js_free(ctx, m->star_export_entries);
+    js_free_rt(rt, m->star_export_entries);
 
     for(i = 0; i < m->import_entries_count; i++) {
         JSImportEntry *mi = &m->import_entries[i];
-        JS_FreeAtom(ctx, mi->import_name);
+        JS_FreeAtomRT(rt, mi->import_name);
     }
-    js_free(ctx, m->import_entries);
+    js_free_rt(rt, m->import_entries);
+    js_free_rt(rt, m->async_parent_modules);
 
-    JS_FreeValue(ctx, m->module_ns);
-    JS_FreeValue(ctx, m->func_obj);
-    JS_FreeValue(ctx, m->eval_exception);
-    JS_FreeValue(ctx, m->meta_obj);
-    list_del(&m->link);
-    js_free(ctx, m);
+    JS_FreeValueRT(rt, m->module_ns);
+    JS_FreeValueRT(rt, m->func_obj);
+    JS_FreeValueRT(rt, m->eval_exception);
+    JS_FreeValueRT(rt, m->meta_obj);
+    JS_FreeValueRT(rt, m->promise);
+    JS_FreeValueRT(rt, m->resolving_funcs[0]);
+    JS_FreeValueRT(rt, m->resolving_funcs[1]);
+    JS_FreeValueRT(rt, m->private_value);
+    /* during the GC the finalizers are called in an arbitrary
+       order so the module may no longer be referenced by the JSContext list */
+    if (m->link.next) {
+        list_del(&m->link);
+    }
+    remove_gc_object(&m->header);
+    if (rt->gc_phase == JS_GC_PHASE_REMOVE_CYCLES && m->header.ref_count != 0) {
+        list_add_tail(&m->header.link, &rt->gc_zero_ref_count_list);
+    } else {
+        js_free_rt(rt, m);
+    }
 }
 
 static int add_req_module_entry(JSContext *ctx, JSModuleDef *m,
                                 JSAtom module_name)
 {
     JSReqModuleEntry *rme;
-    int i;
-
-    /* no need to add the module request if it is already present */
-    for(i = 0; i < m->req_module_entries_count; i++) {
-        rme = &m->req_module_entries[i];
-        if (rme->module_name == module_name)
-            return i;
-    }
 
     if (js_resize_array(ctx, (void **)&m->req_module_entries,
                         sizeof(JSReqModuleEntry),
@@ -26770,7 +28367,8 @@ static int add_req_module_entry(JSContext *ctx, JSModuleDef *m,
     rme = &m->req_module_entries[m->req_module_entries_count++];
     rme->module_name = JS_DupAtom(ctx, module_name);
     rme->module = NULL;
-    return i;
+    rme->attributes = JS_UNDEFINED;
+    return m->req_module_entries_count - 1;
 }
 
 static JSExportEntry *find_export_entry(JSContext *ctx, JSModuleDef *m,
@@ -26850,6 +28448,8 @@ JSModuleDef *JS_NewCModule(JSContext *ctx, const char *name_str,
     if (name == JS_ATOM_NULL)
         return NULL;
     m = js_new_module_def(ctx, name);
+    if (!m)
+        return NULL;
     m->init_func = func;
     return m;
 }
@@ -26889,12 +28489,38 @@ int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
     return -1;
 }
 
+int JS_SetModulePrivateValue(JSContext *ctx, JSModuleDef *m, JSValue val)
+{
+    set_value(ctx, &m->private_value, val);
+    return 0;
+}
+
+JSValue JS_GetModulePrivateValue(JSContext *ctx, JSModuleDef *m)
+{
+    return JS_DupValue(ctx, m->private_value);
+}
+
 void JS_SetModuleLoaderFunc(JSRuntime *rt,
                             JSModuleNormalizeFunc *module_normalize,
                             JSModuleLoaderFunc *module_loader, void *opaque)
 {
     rt->module_normalize_func = module_normalize;
-    rt->module_loader_func = module_loader;
+    rt->module_loader_has_attr = FALSE;
+    rt->u.module_loader_func = module_loader;
+    rt->module_check_attrs = NULL;
+    rt->module_loader_opaque = opaque;
+}
+
+void JS_SetModuleLoaderFunc2(JSRuntime *rt,
+                             JSModuleNormalizeFunc *module_normalize,
+                             JSModuleLoaderFunc2 *module_loader,
+                             JSModuleCheckSupportedImportAttributes *module_check_attrs,
+                             void *opaque)
+{
+    rt->module_normalize_func = module_normalize;
+    rt->module_loader_has_attr = TRUE;
+    rt->u.module_loader_func2 = module_loader;
+    rt->module_check_attrs = module_check_attrs;
     rt->module_loader_opaque = opaque;
 }
 
@@ -26905,6 +28531,7 @@ static char *js_default_module_normalize_name(JSContext *ctx,
 {
     char *filename, *p;
     const char *r;
+    int cap;
     int len;
 
     if (name[0] != '.') {
@@ -26918,7 +28545,8 @@ static char *js_default_module_normalize_name(JSContext *ctx,
     else
         len = 0;
 
-    filename = js_malloc(ctx, len + strlen(name) + 1 + 1);
+    cap = len + strlen(name) + 1 + 1;
+    filename = js_malloc(ctx, cap);
     if (!filename)
         return NULL;
     memcpy(filename, base_name, len);
@@ -26950,8 +28578,8 @@ static char *js_default_module_normalize_name(JSContext *ctx,
         }
     }
     if (filename[0] != '\0')
-        strcat(filename, "/");
-    strcat(filename, r);
+        pstrcat(filename, cap, "/");
+    pstrcat(filename, cap, r);
     //    printf("normalize: %s %s -> %s\n", base_name, name, filename);
     return filename;
 }
@@ -26960,7 +28588,7 @@ static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name)
 {
     struct list_head *el;
     JSModuleDef *m;
-    
+
     /* first look at the loaded modules */
     list_for_each(el, &ctx->loaded_modules) {
         m = list_entry(el, JSModuleDef, link);
@@ -26973,7 +28601,8 @@ static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name)
 /* return NULL in case of exception (e.g. module could not be loaded) */
 static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
                                                     const char *base_cname,
-                                                    const char *cname1)
+                                                    const char *cname1,
+                                                    JSValueConst attributes)
 {
     JSRuntime *rt = ctx->rt;
     JSModuleDef *m;
@@ -27006,26 +28635,30 @@ static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
     JS_FreeAtom(ctx, module_name);
 
     /* load the module */
-    if (!rt->module_loader_func) {
+    if (!rt->u.module_loader_func) {
         /* XXX: use a syntax error ? */
         JS_ThrowReferenceError(ctx, "could not load module '%s'",
                                cname);
         js_free(ctx, cname);
         return NULL;
     }
-
-    m = rt->module_loader_func(ctx, cname, rt->module_loader_opaque);
+    if (rt->module_loader_has_attr) {
+        m = rt->u.module_loader_func2(ctx, cname, rt->module_loader_opaque, attributes);
+    } else {
+        m = rt->u.module_loader_func(ctx, cname, rt->module_loader_opaque);
+    }
     js_free(ctx, cname);
     return m;
 }
 
 static JSModuleDef *js_host_resolve_imported_module_atom(JSContext *ctx,
-                                                    JSAtom base_module_name,
-                                                    JSAtom module_name1)
+                                                         JSAtom base_module_name,
+                                                         JSAtom module_name1,
+                                                         JSValueConst attributes)
 {
     const char *base_cname, *cname;
     JSModuleDef *m;
-    
+
     base_cname = JS_AtomToCString(ctx, base_module_name);
     if (!base_cname)
         return NULL;
@@ -27034,7 +28667,7 @@ static JSModuleDef *js_host_resolve_imported_module_atom(JSContext *ctx,
         JS_FreeCString(ctx, base_cname);
         return NULL;
     }
-    m = js_host_resolve_imported_module(ctx, base_cname, cname);
+    m = js_host_resolve_imported_module(ctx, base_cname, cname, attributes);
     JS_FreeCString(ctx, base_cname);
     JS_FreeCString(ctx, cname);
     return m;
@@ -27218,7 +28851,7 @@ static void js_resolve_export_throw_error(JSContext *ctx,
 typedef enum {
     EXPORTED_NAME_AMBIGUOUS,
     EXPORTED_NAME_NORMAL,
-    EXPORTED_NAME_NS,
+    EXPORTED_NAME_DELAYED,
 } ExportedNameEntryEnum;
 
 typedef struct ExportedNameEntry {
@@ -27227,7 +28860,6 @@ typedef struct ExportedNameEntry {
     union {
         JSExportEntry *me; /* using when the list is built */
         JSVarRef *var_ref; /* EXPORTED_NAME_NORMAL */
-        JSModuleDef *module; /* for EXPORTED_NAME_NS */
     } u;
 } ExportedNameEntry;
 
@@ -27333,13 +28965,33 @@ static int exported_names_cmp(const void *p1, const void *p2, void *opaque)
     return ret;
 }
 
-static JSValue js_get_module_ns(JSContext *ctx, JSModuleDef *m);
-
 static JSValue js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
                                      void *opaque)
 {
     JSModuleDef *m = opaque;
-    return js_get_module_ns(ctx, m);
+    JSResolveResultEnum res;
+    JSExportEntry *res_me;
+    JSModuleDef *res_m;
+    JSVarRef *var_ref;
+
+    res = js_resolve_export(ctx, &res_m, &res_me, m, atom);
+    if (res != JS_RESOLVE_RES_FOUND) {
+        /* fail safe: normally no error should happen here except for memory */
+        js_resolve_export_throw_error(ctx, res, m, atom);
+        return JS_EXCEPTION;
+    }
+    if (res_me->local_name == JS_ATOM__star_) {
+        return JS_GetModuleNamespace(ctx, res_m->req_module_entries[res_me->u.req_module_idx].module);
+    } else {
+        if (res_me->u.local.var_ref) {
+            var_ref = res_me->u.local.var_ref;
+        } else {
+            JSObject *p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
+            var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
+        }
+        /* WARNING: a varref is returned as a string ! */
+        return JS_MKPTR(JS_TAG_STRING, var_ref);
+    }
 }
 
 static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
@@ -27384,17 +29036,18 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
             en->export_type = EXPORTED_NAME_AMBIGUOUS;
         } else {
             if (res_me->local_name == JS_ATOM__star_) {
-                en->export_type = EXPORTED_NAME_NS;
-                en->u.module = res_m->req_module_entries[res_me->u.req_module_idx].module;
+                en->export_type = EXPORTED_NAME_DELAYED;
             } else {
-                en->export_type = EXPORTED_NAME_NORMAL;
                 if (res_me->u.local.var_ref) {
                     en->u.var_ref = res_me->u.local.var_ref;
                 } else {
                     JSObject *p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
-                    p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
                     en->u.var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
                 }
+                if (en->u.var_ref == NULL)
+                    en->export_type = EXPORTED_NAME_DELAYED;
+                else
+                    en->export_type = EXPORTED_NAME_NORMAL;
             }
         }
     }
@@ -27418,13 +29071,13 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
                 pr->u.var_ref = var_ref;
             }
             break;
-        case EXPORTED_NAME_NS:
-            /* the exported namespace must be created on demand */
+        case EXPORTED_NAME_DELAYED:
+            /* the exported namespace or reference may depend on
+               circular references, so we resolve it lazily */
             if (JS_DefineAutoInitProperty(ctx, obj,
                                           en->export_name,
                                           JS_AUTOINIT_ID_MODULE_NS,
-                                          en->u.module, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
-                goto fail;
+                                          m, JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
             break;
         default:
             break;
@@ -27445,7 +29098,7 @@ static JSValue js_build_module_ns(JSContext *ctx, JSModuleDef *m)
     return JS_EXCEPTION;
 }
 
-static JSValue js_get_module_ns(JSContext *ctx, JSModuleDef *m)
+JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m)
 {
     if (JS_IsUndefined(m->module_ns)) {
         JSValue val;
@@ -27476,7 +29129,8 @@ static int js_resolve_module(JSContext *ctx, JSModuleDef *m)
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         m1 = js_host_resolve_imported_module_atom(ctx, m->module_name,
-                                                  rme->module_name);
+                                                  rme->module_name,
+                                                  rme->attributes);
         if (!m1)
             return -1;
         rme->module = m1;
@@ -27563,7 +29217,7 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     BOOL is_c_module;
     int i;
     JSVarRef *var_ref;
-    
+
     if (m->func_created)
         return 0;
 
@@ -27587,7 +29241,7 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     m->func_created = TRUE;
 
     /* do it on the dependencies */
-    
+
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         if (js_create_module_function(ctx, rme->module) < 0)
@@ -27595,12 +29249,13 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     }
 
     return 0;
-}    
+}
+
 
-    
 /* Prepare a module to be executed by resolving all the imported
    variables. */
-static int js_link_module(JSContext *ctx, JSModuleDef *m)
+static int js_inner_module_linking(JSContext *ctx, JSModuleDef *m,
+                                   JSModuleDef **pstack_top, int index)
 {
     int i;
     JSImportEntry *mi;
@@ -27609,22 +29264,48 @@ static int js_link_module(JSContext *ctx, JSModuleDef *m)
     JSObject *p;
     BOOL is_c_module;
     JSValue ret_val;
-    
-    if (m->instantiated)
-        return 0;
-    m->instantiated = TRUE;
+
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        return -1;
+    }
 
 #ifdef DUMP_MODULE_RESOLVE
     {
         char buf1[ATOM_GET_STR_BUF_SIZE];
-        printf("start instantiating module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
+        printf("js_inner_module_linking '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
     }
 #endif
 
+    if (m->status == JS_MODULE_STATUS_LINKING ||
+        m->status == JS_MODULE_STATUS_LINKED ||
+        m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+        m->status == JS_MODULE_STATUS_EVALUATED)
+        return index;
+
+    assert(m->status == JS_MODULE_STATUS_UNLINKED);
+    m->status = JS_MODULE_STATUS_LINKING;
+    m->dfs_index = index;
+    m->dfs_ancestor_index = index;
+    index++;
+    /* push 'm' on stack */
+    m->stack_prev = *pstack_top;
+    *pstack_top = m;
+
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
-        if (js_link_module(ctx, rme->module) < 0)
+        m1 = rme->module;
+        index = js_inner_module_linking(ctx, m1, pstack_top, index);
+        if (index < 0)
             goto fail;
+        assert(m1->status == JS_MODULE_STATUS_LINKING ||
+               m1->status == JS_MODULE_STATUS_LINKED ||
+               m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+               m1->status == JS_MODULE_STATUS_EVALUATED);
+        if (m1->status == JS_MODULE_STATUS_LINKING) {
+            m->dfs_ancestor_index = min_int(m->dfs_ancestor_index,
+                                            m1->dfs_ancestor_index);
+        }
     }
 
 #ifdef DUMP_MODULE_RESOLVE
@@ -27676,10 +29357,10 @@ static int js_link_module(JSContext *ctx, JSModuleDef *m)
             printf(": ");
 #endif
             m1 = m->req_module_entries[mi->req_module_idx].module;
-            if (mi->import_name == JS_ATOM__star_) {
+            if (mi->is_star) {
                 JSValue val;
                 /* name space import */
-                val = js_get_module_ns(ctx, m1);
+                val = JS_GetModuleNamespace(ctx, m1);
                 if (JS_IsException(val))
                     goto fail;
                 set_value(ctx, &var_refs[mi->var_idx]->value, val);
@@ -27703,7 +29384,7 @@ static int js_link_module(JSContext *ctx, JSModuleDef *m)
                     JSModuleDef *m2;
                     /* name space import from */
                     m2 = res_m->req_module_entries[res_me->u.req_module_idx].module;
-                    val = js_get_module_ns(ctx, m2);
+                    val = JS_GetModuleNamespace(ctx, m2);
                     if (JS_IsException(val))
                         goto fail;
                     var_ref = js_create_module_var(ctx, TRUE);
@@ -27750,14 +29431,59 @@ static int js_link_module(JSContext *ctx, JSModuleDef *m)
         JS_FreeValue(ctx, ret_val);
     }
 
+    assert(m->dfs_ancestor_index <= m->dfs_index);
+    if (m->dfs_index == m->dfs_ancestor_index) {
+        for(;;) {
+            /* pop m1 from stack */
+            m1 = *pstack_top;
+            *pstack_top = m1->stack_prev;
+            m1->status = JS_MODULE_STATUS_LINKED;
+            if (m1 == m)
+                break;
+        }
+    }
+
 #ifdef DUMP_MODULE_RESOLVE
-    printf("done instantiate\n");
+    printf("js_inner_module_linking done\n");
 #endif
-    return 0;
+    return index;
  fail:
     return -1;
 }
 
+/* Prepare a module to be executed by resolving all the imported
+   variables. */
+static int js_link_module(JSContext *ctx, JSModuleDef *m)
+{
+    JSModuleDef *stack_top, *m1;
+
+#ifdef DUMP_MODULE_RESOLVE
+    {
+        char buf1[ATOM_GET_STR_BUF_SIZE];
+        printf("js_link_module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
+    }
+#endif
+    assert(m->status == JS_MODULE_STATUS_UNLINKED ||
+           m->status == JS_MODULE_STATUS_LINKED ||
+           m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+           m->status == JS_MODULE_STATUS_EVALUATED);
+    stack_top = NULL;
+    if (js_inner_module_linking(ctx, m, &stack_top, 0) < 0) {
+        while (stack_top != NULL) {
+            m1 = stack_top;
+            assert(m1->status == JS_MODULE_STATUS_LINKING);
+            m1->status = JS_MODULE_STATUS_UNLINKED;
+            stack_top = m1->stack_prev;
+        }
+        return -1;
+    }
+    assert(stack_top == NULL);
+    assert(m->status == JS_MODULE_STATUS_LINKED ||
+           m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+           m->status == JS_MODULE_STATUS_EVALUATED);
+    return 0;
+}
+
 /* return JS_ATOM_NULL if the name cannot be found. Only works with
    not striped bytecode functions. */
 JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
@@ -27766,8 +29492,8 @@ JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
     JSFunctionBytecode *b;
     JSObject *p;
     /* XXX: currently we just use the filename of the englobing
-       function. It does not work for eval(). Need to add a
-       ScriptOrModule info in JSFunctionBytecode */
+       function from the debug info. May need to add a ScriptOrModule
+       info in JSFunctionBytecode. */
     sf = ctx->rt->current_stack_frame;
     if (!sf)
         return JS_ATOM_NULL;
@@ -27776,15 +29502,23 @@ JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels)
         if (!sf)
             return JS_ATOM_NULL;
     }
-    if (JS_VALUE_GET_TAG(sf->cur_func) != JS_TAG_OBJECT)
-        return JS_ATOM_NULL;
-    p = JS_VALUE_GET_OBJ(sf->cur_func);
-    if (!js_class_has_bytecode(p->class_id))
-        return JS_ATOM_NULL;
-    b = p->u.func.function_bytecode;
-    if (!b->has_debug)
-        return JS_ATOM_NULL;
-    return JS_DupAtom(ctx, b->debug.filename);
+    for(;;) {
+        if (JS_VALUE_GET_TAG(sf->cur_func) != JS_TAG_OBJECT)
+            return JS_ATOM_NULL;
+        p = JS_VALUE_GET_OBJ(sf->cur_func);
+        if (!js_class_has_bytecode(p->class_id))
+            return JS_ATOM_NULL;
+        b = p->u.func.function_bytecode;
+        if (!b->is_direct_or_indirect_eval) {
+            if (!b->has_debug)
+                return JS_ATOM_NULL;
+            return JS_DupAtom(ctx, b->debug.filename);
+        } else {
+            sf = sf->prev_frame;
+            if (!sf)
+                return JS_ATOM_NULL;
+        }
+    }
 }
 
 JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m)
@@ -27810,7 +29544,7 @@ static JSValue js_import_meta(JSContext *ctx)
 {
     JSAtom filename;
     JSModuleDef *m;
-    
+
     filename = JS_GetScriptOrModuleName(ctx, 0);
     if (filename == JS_ATOM_NULL)
         goto fail;
@@ -27827,29 +29561,111 @@ static JSValue js_import_meta(JSContext *ctx)
     return JS_GetImportMeta(ctx, m);
 }
 
-/* used by os.Worker() and import() */
-JSModuleDef *JS_RunModule(JSContext *ctx, const char *basename,
-                          const char *filename)
+static JSValue JS_NewModuleValue(JSContext *ctx, JSModuleDef *m)
+{
+    return JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+}
+
+static JSValue js_load_module_rejected(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv, int magic, JSValue *func_data)
+{
+    JSValueConst *resolving_funcs = (JSValueConst *)func_data;
+    JSValueConst error;
+    JSValue ret;
+
+    /* XXX: check if the test is necessary */
+    if (argc >= 1)
+        error = argv[0];
+    else
+        error = JS_UNDEFINED;
+    ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
+                  1, &error);
+    JS_FreeValue(ctx, ret);
+    return JS_UNDEFINED;
+}
+
+static JSValue js_load_module_fulfilled(JSContext *ctx, JSValueConst this_val,
+                                        int argc, JSValueConst *argv, int magic, JSValue *func_data)
+{
+    JSValueConst *resolving_funcs = (JSValueConst *)func_data;
+    JSModuleDef *m = JS_VALUE_GET_PTR(func_data[2]);
+    JSValue ret, ns;
+
+    /* return the module namespace */
+    ns = JS_GetModuleNamespace(ctx, m);
+    if (JS_IsException(ns)) {
+        JSValue err = JS_GetException(ctx);
+        js_load_module_rejected(ctx, JS_UNDEFINED, 1, (JSValueConst *)&err, 0, func_data);
+        return JS_UNDEFINED;
+    }
+    ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
+                   1, (JSValueConst *)&ns);
+    JS_FreeValue(ctx, ret);
+    JS_FreeValue(ctx, ns);
+    return JS_UNDEFINED;
+}
+
+static void JS_LoadModuleInternal(JSContext *ctx, const char *basename,
+                                  const char *filename,
+                                  JSValueConst *resolving_funcs,
+                                  JSValueConst attributes)
 {
+    JSValue evaluate_promise;
     JSModuleDef *m;
-    JSValue ret, func_obj;
-    
-    m = js_host_resolve_imported_module(ctx, basename, filename);
+    JSValue ret, err, func_obj, evaluate_resolving_funcs[2];
+    JSValueConst func_data[3];
+
+    m = js_host_resolve_imported_module(ctx, basename, filename, attributes);
     if (!m)
-        return NULL;
-    
+        goto fail;
+
     if (js_resolve_module(ctx, m) < 0) {
         js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
-        return NULL;
+        goto fail;
     }
 
     /* Evaluate the module code */
-    func_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
-    ret = JS_EvalFunction(ctx, func_obj);
-    if (JS_IsException(ret))
-        return NULL;
+    func_obj = JS_NewModuleValue(ctx, m);
+    evaluate_promise = JS_EvalFunction(ctx, func_obj);
+    if (JS_IsException(evaluate_promise)) {
+    fail:
+        err = JS_GetException(ctx);
+        ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
+                      1, (JSValueConst *)&err);
+        JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
+        JS_FreeValue(ctx, err);
+        return;
+    }
+
+    func_obj = JS_NewModuleValue(ctx, m);
+    func_data[0] = resolving_funcs[0];
+    func_data[1] = resolving_funcs[1];
+    func_data[2] = func_obj;
+    evaluate_resolving_funcs[0] = JS_NewCFunctionData(ctx, js_load_module_fulfilled, 0, 0, 3, func_data);
+    evaluate_resolving_funcs[1] = JS_NewCFunctionData(ctx, js_load_module_rejected, 0, 0, 3, func_data);
+    JS_FreeValue(ctx, func_obj);
+    ret = js_promise_then(ctx, evaluate_promise, 2, (JSValueConst *)evaluate_resolving_funcs);
     JS_FreeValue(ctx, ret);
-    return m;
+    JS_FreeValue(ctx, evaluate_resolving_funcs[0]);
+    JS_FreeValue(ctx, evaluate_resolving_funcs[1]);
+    JS_FreeValue(ctx, evaluate_promise);
+}
+
+/* Return a promise or an exception in case of memory error. Used by
+   os.Worker() */
+JSValue JS_LoadModule(JSContext *ctx, const char *basename,
+                      const char *filename)
+{
+    JSValue promise, resolving_funcs[2];
+
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise))
+        return JS_EXCEPTION;
+    JS_LoadModuleInternal(ctx, basename, filename,
+                          (JSValueConst *)resolving_funcs, JS_UNDEFINED);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    return promise;
 }
 
 static JSValue js_dynamic_import_job(JSContext *ctx,
@@ -27858,9 +29674,9 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
     JSValueConst *resolving_funcs = argv;
     JSValueConst basename_val = argv[2];
     JSValueConst specifier = argv[3];
-    JSModuleDef *m;
+    JSValueConst attributes = argv[4];
     const char *basename = NULL, *filename;
-    JSValue ret, err, ns;
+    JSValue ret, err;
 
     if (!JS_IsString(basename_val)) {
         JS_ThrowTypeError(ctx, "no function filename for import()");
@@ -27873,25 +29689,13 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
     filename = JS_ToCString(ctx, specifier);
     if (!filename)
         goto exception;
-                     
-    m = JS_RunModule(ctx, basename, filename);
-    JS_FreeCString(ctx, filename);
-    if (!m)
-        goto exception;
 
-    /* return the module namespace */
-    ns = js_get_module_ns(ctx, m);
-    if (JS_IsException(ns))
-        goto exception;
-
-    ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED,
-                   1, (JSValueConst *)&ns);
-    JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
-    JS_FreeValue(ctx, ns);
+    JS_LoadModuleInternal(ctx, basename, filename,
+                          resolving_funcs, attributes);
+    JS_FreeCString(ctx, filename);
     JS_FreeCString(ctx, basename);
     return JS_UNDEFINED;
  exception:
-
     err = JS_GetException(ctx);
     ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
                    1, (JSValueConst *)&err);
@@ -27901,11 +29705,12 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
     return JS_UNDEFINED;
 }
 
-static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
+static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier, JSValueConst options)
 {
     JSAtom basename;
-    JSValue promise, resolving_funcs[2], basename_val;
-    JSValueConst args[4];
+    JSValue promise, resolving_funcs[2], basename_val, err, ret;
+    JSValue specifier_str = JS_UNDEFINED, attributes = JS_UNDEFINED, attributes_obj = JS_UNDEFINED;
+    JSValueConst args[5];
 
     basename = JS_GetScriptOrModuleName(ctx, 0);
     if (basename == JS_ATOM_NULL)
@@ -27915,103 +29720,615 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     JS_FreeAtom(ctx, basename);
     if (JS_IsException(basename_val))
         return basename_val;
-    
+
     promise = JS_NewPromiseCapability(ctx, resolving_funcs);
     if (JS_IsException(promise)) {
         JS_FreeValue(ctx, basename_val);
         return promise;
     }
 
+    /* the string conversion must occur here */
+    specifier_str = JS_ToString(ctx, specifier);
+    if (JS_IsException(specifier_str))
+        goto exception;
+    
+    if (!JS_IsUndefined(options)) {
+        if (!JS_IsObject(options)) {
+            JS_ThrowTypeError(ctx, "options must be an object");
+            goto exception;
+        }
+        attributes_obj = JS_GetProperty(ctx, options, JS_ATOM_with);
+        if (JS_IsException(attributes_obj))
+            goto exception;
+        if (!JS_IsUndefined(attributes_obj)) {
+            JSPropertyEnum *atoms;
+            uint32_t atoms_len, i;
+            JSValue val;
+            
+            if (!JS_IsObject(attributes_obj)) {
+                JS_ThrowTypeError(ctx, "options.with must be an object");
+                goto exception;
+            }
+            attributes = JS_NewObjectProto(ctx, JS_NULL);
+            if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &atoms_len, JS_VALUE_GET_OBJ(attributes_obj),
+                                               JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY)) {
+                goto exception;
+            }
+            for(i = 0; i < atoms_len; i++) {
+                val = JS_GetProperty(ctx, attributes_obj, atoms[i].atom);
+                if (JS_IsException(val))
+                    goto exception1;
+                if (!JS_IsString(val)) {
+                    JS_FreeValue(ctx, val);
+                    JS_ThrowTypeError(ctx, "module attribute values must be strings");
+                    goto exception1;
+                }
+                if (JS_DefinePropertyValue(ctx, attributes,  atoms[i].atom, val,
+                                           JS_PROP_C_W_E) < 0) {
+                exception1:
+                    JS_FreePropertyEnum(ctx, atoms, atoms_len);
+                    goto exception;
+                }
+            }
+            JS_FreePropertyEnum(ctx, atoms, atoms_len);
+            if (ctx->rt->module_check_attrs &&
+                ctx->rt->module_check_attrs(ctx, ctx->rt->module_loader_opaque, attributes) < 0) {
+                goto exception;
+            }
+            JS_FreeValue(ctx, attributes_obj);
+        }
+    }
+
     args[0] = resolving_funcs[0];
     args[1] = resolving_funcs[1];
     args[2] = basename_val;
-    args[3] = specifier;
+    args[3] = specifier_str;
+    args[4] = attributes;
     
-    JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
-
+    /* cannot run JS_LoadModuleInternal synchronously because it would
+       cause an unexpected recursion in js_evaluate_module() */
+    JS_EnqueueJob(ctx, js_dynamic_import_job, 5, args);
+ done:
     JS_FreeValue(ctx, basename_val);
     JS_FreeValue(ctx, resolving_funcs[0]);
     JS_FreeValue(ctx, resolving_funcs[1]);
+    JS_FreeValue(ctx, specifier_str);
+    JS_FreeValue(ctx, attributes);
     return promise;
+ exception:
+    JS_FreeValue(ctx, attributes_obj);
+    err = JS_GetException(ctx);
+    ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
+                   1, (JSValueConst *)&err);
+    JS_FreeValue(ctx, ret);
+    JS_FreeValue(ctx, err);
+    goto done;
 }
 
-/* Run the <eval> function of the module and of all its requested
-   modules. */
-static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
+static void js_set_module_evaluated(JSContext *ctx, JSModuleDef *m)
+{
+    m->status = JS_MODULE_STATUS_EVALUATED;
+    if (!JS_IsUndefined(m->promise)) {
+        JSValue value, ret_val;
+        assert(m->cycle_root == m);
+        value = JS_UNDEFINED;
+        ret_val = JS_Call(ctx, m->resolving_funcs[0], JS_UNDEFINED,
+                          1, (JSValueConst *)&value);
+        JS_FreeValue(ctx, ret_val);
+    }
+}
+
+typedef struct {
+    JSModuleDef **tab;
+    int count;
+    int size;
+} ExecModuleList;
+
+/* XXX: slow. Could use a linked list instead of ExecModuleList */
+static BOOL find_in_exec_module_list(ExecModuleList *exec_list, JSModuleDef *m)
+{
+    int i;
+    for(i = 0; i < exec_list->count; i++) {
+        if (exec_list->tab[i] == m)
+            return TRUE;
+    }
+    return FALSE;
+}
+
+static int gather_available_ancestors(JSContext *ctx, JSModuleDef *module,
+                                      ExecModuleList *exec_list)
+{
+    int i;
+
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        return -1;
+    }
+    for(i = 0; i < module->async_parent_modules_count; i++) {
+        JSModuleDef *m = module->async_parent_modules[i];
+        if (!find_in_exec_module_list(exec_list, m) &&
+            !m->cycle_root->eval_has_exception) {
+            assert(m->status == JS_MODULE_STATUS_EVALUATING_ASYNC);
+            assert(!m->eval_has_exception);
+            assert(m->async_evaluation);
+            assert(m->pending_async_dependencies > 0);
+            m->pending_async_dependencies--;
+            if (m->pending_async_dependencies == 0) {
+                if (js_resize_array(ctx, (void **)&exec_list->tab, sizeof(exec_list->tab[0]), &exec_list->size, exec_list->count + 1)) {
+                    return -1;
+                }
+                exec_list->tab[exec_list->count++] = m;
+                if (!m->has_tla) {
+                    if (gather_available_ancestors(ctx, m, exec_list))
+                        return -1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static int exec_module_list_cmp(const void *p1, const void *p2, void *opaque)
+{
+    JSModuleDef *m1 = *(JSModuleDef **)p1;
+    JSModuleDef *m2 = *(JSModuleDef **)p2;
+    return (m1->async_evaluation_timestamp > m2->async_evaluation_timestamp) -
+        (m1->async_evaluation_timestamp < m2->async_evaluation_timestamp);
+}
+
+static int js_execute_async_module(JSContext *ctx, JSModuleDef *m);
+static int js_execute_sync_module(JSContext *ctx, JSModuleDef *m,
+                                  JSValue *pvalue);
+#ifdef DUMP_MODULE_EXEC
+static void js_dump_module(JSContext *ctx, const char *str, JSModuleDef *m)
+{
+    char buf1[ATOM_GET_STR_BUF_SIZE];
+    static const char *module_status_str[] = { "unlinked", "linking", "linked", "evaluating", "evaluating_async", "evaluated" };
+    printf("%s: %s status=%s\n", str, JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name), module_status_str[m->status]);
+}
+#endif
+
+static JSValue js_async_module_execution_rejected(JSContext *ctx, JSValueConst this_val,
+                                                  int argc, JSValueConst *argv, int magic, JSValue *func_data)
+{
+    JSModuleDef *module = JS_VALUE_GET_PTR(func_data[0]);
+    JSValueConst error = argv[0];
+    int i;
+
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, module);
+#endif
+    if (js_check_stack_overflow(ctx->rt, 0))
+        return JS_ThrowStackOverflow(ctx);
+
+    if (module->status == JS_MODULE_STATUS_EVALUATED) {
+        assert(module->eval_has_exception);
+        return JS_UNDEFINED;
+    }
+
+    assert(module->status == JS_MODULE_STATUS_EVALUATING_ASYNC);
+    assert(!module->eval_has_exception);
+    assert(module->async_evaluation);
+
+    module->eval_has_exception = TRUE;
+    module->eval_exception = JS_DupValue(ctx, error);
+    module->status = JS_MODULE_STATUS_EVALUATED;
+    module->async_evaluation = FALSE;
+
+    for(i = 0; i < module->async_parent_modules_count; i++) {
+        JSModuleDef *m = module->async_parent_modules[i];
+        JSValue m_obj = JS_NewModuleValue(ctx, m);
+        js_async_module_execution_rejected(ctx, JS_UNDEFINED, 1, &error, 0,
+                                           &m_obj);
+        JS_FreeValue(ctx, m_obj);
+    }
+
+    if (!JS_IsUndefined(module->promise)) {
+        JSValue ret_val;
+        assert(module->cycle_root == module);
+        ret_val = JS_Call(ctx, module->resolving_funcs[1], JS_UNDEFINED,
+                          1, &error);
+        JS_FreeValue(ctx, ret_val);
+    }
+    return JS_UNDEFINED;
+}
+
+static JSValue js_async_module_execution_fulfilled(JSContext *ctx, JSValueConst this_val,
+                                                   int argc, JSValueConst *argv, int magic, JSValue *func_data)
+{
+    JSModuleDef *module = JS_VALUE_GET_PTR(func_data[0]);
+    ExecModuleList exec_list_s, *exec_list = &exec_list_s;
+    int i;
+
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, module);
+#endif
+    if (module->status == JS_MODULE_STATUS_EVALUATED) {
+        assert(module->eval_has_exception);
+        return JS_UNDEFINED;
+    }
+    assert(module->status == JS_MODULE_STATUS_EVALUATING_ASYNC);
+    assert(!module->eval_has_exception);
+    assert(module->async_evaluation);
+    module->async_evaluation = FALSE;
+    js_set_module_evaluated(ctx, module);
+
+    exec_list->tab = NULL;
+    exec_list->count = 0;
+    exec_list->size = 0;
+
+    if (gather_available_ancestors(ctx, module, exec_list) < 0) {
+        js_free(ctx, exec_list->tab);
+        return JS_EXCEPTION;
+    }
+
+    /* sort by increasing async_evaluation timestamp */
+    rqsort(exec_list->tab, exec_list->count, sizeof(exec_list->tab[0]),
+           exec_module_list_cmp, NULL);
+
+    for(i = 0; i < exec_list->count; i++) {
+        JSModuleDef *m = exec_list->tab[i];
+#ifdef DUMP_MODULE_EXEC
+        printf("  %d/%d", i, exec_list->count); js_dump_module(ctx, "", m);
+#endif
+        if (m->status == JS_MODULE_STATUS_EVALUATED) {
+            assert(m->eval_has_exception);
+        } else if (m->has_tla) {
+            js_execute_async_module(ctx, m);
+        } else {
+            JSValue error;
+            if (js_execute_sync_module(ctx, m, &error) < 0) {
+                JSValue m_obj = JS_NewModuleValue(ctx, m);
+                js_async_module_execution_rejected(ctx, JS_UNDEFINED,
+                                                   1, (JSValueConst *)&error, 0,
+                                                   &m_obj);
+                JS_FreeValue(ctx, m_obj);
+                JS_FreeValue(ctx, error);
+            } else {
+                m->async_evaluation = FALSE;
+                js_set_module_evaluated(ctx, m);
+            }
+        }
+    }
+    js_free(ctx, exec_list->tab);
+    return JS_UNDEFINED;
+}
+
+static int js_execute_async_module(JSContext *ctx, JSModuleDef *m)
+{
+    JSValue promise, m_obj;
+    JSValue resolve_funcs[2], ret_val;
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, m);
+#endif
+    promise = js_async_function_call(ctx, m->func_obj, JS_UNDEFINED, 0, NULL, 0);
+    if (JS_IsException(promise))
+        return -1;
+    m_obj = JS_NewModuleValue(ctx, m);
+    resolve_funcs[0] = JS_NewCFunctionData(ctx, js_async_module_execution_fulfilled, 0, 0, 1, (JSValueConst *)&m_obj);
+    resolve_funcs[1] = JS_NewCFunctionData(ctx, js_async_module_execution_rejected, 0, 0, 1, (JSValueConst *)&m_obj);
+    ret_val = js_promise_then(ctx, promise, 2, (JSValueConst *)resolve_funcs);
+    JS_FreeValue(ctx, ret_val);
+    JS_FreeValue(ctx, m_obj);
+    JS_FreeValue(ctx, resolve_funcs[0]);
+    JS_FreeValue(ctx, resolve_funcs[1]);
+    JS_FreeValue(ctx, promise);
+    return 0;
+}
+
+/* return < 0 in case of exception. *pvalue contains the exception. */
+static int js_execute_sync_module(JSContext *ctx, JSModuleDef *m,
+                                  JSValue *pvalue)
+{
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, m);
+#endif
+    if (m->init_func) {
+        /* C module init : no asynchronous execution */
+        if (m->init_func(ctx, m) < 0)
+            goto fail;
+    } else {
+        JSValue promise;
+        JSPromiseStateEnum state;
+
+        promise = js_async_function_call(ctx, m->func_obj, JS_UNDEFINED, 0, NULL, 0);
+        if (JS_IsException(promise))
+            goto fail;
+        state = JS_PromiseState(ctx, promise);
+        if (state == JS_PROMISE_FULFILLED) {
+            JS_FreeValue(ctx, promise);
+        } else if (state == JS_PROMISE_REJECTED) {
+            *pvalue = JS_PromiseResult(ctx, promise);
+            JS_FreeValue(ctx, promise);
+            return -1;
+        } else {
+            JS_FreeValue(ctx, promise);
+            JS_ThrowTypeError(ctx, "promise is pending");
+        fail:
+            *pvalue = JS_GetException(ctx);
+            return -1;
+        }
+    }
+    *pvalue = JS_UNDEFINED;
+    return 0;
+}
+
+/* spec: InnerModuleEvaluation. Return (index, JS_UNDEFINED) or (-1,
+   exception) */
+static int js_inner_module_evaluation(JSContext *ctx, JSModuleDef *m,
+                                      int index, JSModuleDef **pstack_top,
+                                      JSValue *pvalue)
 {
     JSModuleDef *m1;
     int i;
-    JSValue ret_val;
 
-    if (m->eval_mark)
-        return JS_UNDEFINED; /* avoid cycles */
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, m);
+#endif
 
-    if (m->evaluated) {
-        /* if the module was already evaluated, rethrow the exception
-           it raised */
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        *pvalue = JS_GetException(ctx);
+        return -1;
+    }
+
+    if (m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+        m->status == JS_MODULE_STATUS_EVALUATED) {
         if (m->eval_has_exception) {
-            return JS_Throw(ctx, JS_DupValue(ctx, m->eval_exception));
+            *pvalue = JS_DupValue(ctx, m->eval_exception);
+            return -1;
         } else {
-            return JS_UNDEFINED;
+            *pvalue = JS_UNDEFINED;
+            return index;
         }
     }
+    if (m->status == JS_MODULE_STATUS_EVALUATING) {
+        *pvalue = JS_UNDEFINED;
+        return index;
+    }
+    assert(m->status == JS_MODULE_STATUS_LINKED);
 
-    m->eval_mark = TRUE;
+    m->status = JS_MODULE_STATUS_EVALUATING;
+    m->dfs_index = index;
+    m->dfs_ancestor_index = index;
+    m->pending_async_dependencies = 0;
+    index++;
+    /* push 'm' on stack */
+    m->stack_prev = *pstack_top;
+    *pstack_top = m;
 
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         m1 = rme->module;
-        if (!m1->eval_mark) {
-            ret_val = js_evaluate_module(ctx, m1);
-            if (JS_IsException(ret_val)) {
-                m->eval_mark = FALSE;
-                return ret_val;
+        index = js_inner_module_evaluation(ctx, m1, index, pstack_top, pvalue);
+        if (index < 0)
+            return -1;
+        assert(m1->status == JS_MODULE_STATUS_EVALUATING ||
+               m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+               m1->status == JS_MODULE_STATUS_EVALUATED);
+        if (m1->status == JS_MODULE_STATUS_EVALUATING) {
+            m->dfs_ancestor_index = min_int(m->dfs_ancestor_index,
+                                            m1->dfs_ancestor_index);
+        } else {
+            m1 = m1->cycle_root;
+            assert(m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+                   m1->status == JS_MODULE_STATUS_EVALUATED);
+            if (m1->eval_has_exception) {
+                *pvalue = JS_DupValue(ctx, m1->eval_exception);
+                return -1;
             }
-            JS_FreeValue(ctx, ret_val);
+        }
+        if (m1->async_evaluation) {
+            m->pending_async_dependencies++;
+            if (js_resize_array(ctx, (void **)&m1->async_parent_modules, sizeof(m1->async_parent_modules[0]), &m1->async_parent_modules_size, m1->async_parent_modules_count + 1)) {
+                *pvalue = JS_GetException(ctx);
+                return -1;
+            }
+            m1->async_parent_modules[m1->async_parent_modules_count++] = m;
         }
     }
 
-    if (m->init_func) {
-        /* C module init */
-        if (m->init_func(ctx, m) < 0)
-            ret_val = JS_EXCEPTION;
-        else
-            ret_val = JS_UNDEFINED;
+    if (m->pending_async_dependencies > 0) {
+        assert(!m->async_evaluation);
+        m->async_evaluation = TRUE;
+        m->async_evaluation_timestamp =
+            ctx->rt->module_async_evaluation_next_timestamp++;
+    } else if (m->has_tla) {
+        assert(!m->async_evaluation);
+        m->async_evaluation = TRUE;
+        m->async_evaluation_timestamp =
+            ctx->rt->module_async_evaluation_next_timestamp++;
+        js_execute_async_module(ctx, m);
     } else {
-        ret_val = JS_CallFree(ctx, m->func_obj, JS_UNDEFINED, 0, NULL);
-        m->func_obj = JS_UNDEFINED;
+        if (js_execute_sync_module(ctx, m, pvalue) < 0)
+            return -1;
     }
-    if (JS_IsException(ret_val)) {
-        /* save the thrown exception value */
-        m->eval_has_exception = TRUE;
-        m->eval_exception = JS_DupValue(ctx, ctx->rt->current_exception);
+
+    assert(m->dfs_ancestor_index <= m->dfs_index);
+    if (m->dfs_index == m->dfs_ancestor_index) {
+        for(;;) {
+            /* pop m1 from stack */
+            m1 = *pstack_top;
+            *pstack_top = m1->stack_prev;
+            if (!m1->async_evaluation) {
+                m1->status = JS_MODULE_STATUS_EVALUATED;
+            } else {
+                m1->status = JS_MODULE_STATUS_EVALUATING_ASYNC;
+            }
+            /* spec bug: cycle_root must be assigned before the test */
+            m1->cycle_root = m;
+            if (m1 == m)
+                break;
+        }
     }
-    m->eval_mark = FALSE;
-    m->evaluated = TRUE;
-    return ret_val;
+    *pvalue = JS_UNDEFINED;
+    return index;
+}
+
+/* Run the <eval> function of the module and of all its requested
+   modules. Return a promise or an exception. */
+static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
+{
+    JSModuleDef *m1, *stack_top;
+    JSValue ret_val, result;
+
+#ifdef DUMP_MODULE_EXEC
+    js_dump_module(ctx, __func__, m);
+#endif
+    assert(m->status == JS_MODULE_STATUS_LINKED ||
+           m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+           m->status == JS_MODULE_STATUS_EVALUATED);
+    if (m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+        m->status == JS_MODULE_STATUS_EVALUATED) {
+        m = m->cycle_root;
+    }
+    /* a promise may be created only on the cycle_root of a cycle */
+    if (!JS_IsUndefined(m->promise))
+        return JS_DupValue(ctx, m->promise);
+    m->promise = JS_NewPromiseCapability(ctx, m->resolving_funcs);
+    if (JS_IsException(m->promise))
+        return JS_EXCEPTION;
+
+    stack_top = NULL;
+    if (js_inner_module_evaluation(ctx, m, 0, &stack_top, &result) < 0) {
+        while (stack_top != NULL) {
+            m1 = stack_top;
+            assert(m1->status == JS_MODULE_STATUS_EVALUATING);
+            m1->status = JS_MODULE_STATUS_EVALUATED;
+            m1->eval_has_exception = TRUE;
+            m1->eval_exception = JS_DupValue(ctx, result);
+            m1->cycle_root = m; /* spec bug: should be present */
+            stack_top = m1->stack_prev;
+        }
+        JS_FreeValue(ctx, result);
+        assert(m->status == JS_MODULE_STATUS_EVALUATED);
+        assert(m->eval_has_exception);
+        ret_val = JS_Call(ctx, m->resolving_funcs[1], JS_UNDEFINED,
+                          1, (JSValueConst *)&m->eval_exception);
+        JS_FreeValue(ctx, ret_val);
+    } else {
+#ifdef DUMP_MODULE_EXEC
+        js_dump_module(ctx, "  done", m);
+#endif
+        assert(m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
+               m->status == JS_MODULE_STATUS_EVALUATED);
+        assert(!m->eval_has_exception);
+        if (!m->async_evaluation) {
+            JSValue value;
+            assert(m->status == JS_MODULE_STATUS_EVALUATED);
+            value = JS_UNDEFINED;
+            ret_val = JS_Call(ctx, m->resolving_funcs[0], JS_UNDEFINED,
+                              1, (JSValueConst *)&value);
+            JS_FreeValue(ctx, ret_val);
+        }
+        assert(stack_top == NULL);
+    }
+    return JS_DupValue(ctx, m->promise);
 }
 
-static __exception JSAtom js_parse_from_clause(JSParseState *s)
+static __exception int js_parse_with_clause(JSParseState *s, JSReqModuleEntry *rme)
+{
+    JSContext *ctx = s->ctx;
+    JSAtom key;
+    int ret;
+    const uint8_t *key_token_ptr;
+    
+    if (next_token(s))
+        return -1;
+    if (js_parse_expect(s, '{'))
+        return -1;
+    while (s->token.val != '}') {
+        key_token_ptr = s->token.ptr;
+        if (s->token.val == TOK_STRING) {
+            key = JS_ValueToAtom(ctx, s->token.u.str.str);
+            if (key == JS_ATOM_NULL)
+                return -1;
+        } else {
+            if (!token_is_ident(s->token.val)) {
+                js_parse_error(s, "identifier expected");
+                return -1;
+            }
+            key = JS_DupAtom(ctx, s->token.u.ident.atom);
+        }
+        if (next_token(s))
+            return -1;
+        if (js_parse_expect(s, ':')) {
+            JS_FreeAtom(ctx, key);
+            return -1;
+        }
+        if (s->token.val != TOK_STRING) {
+            js_parse_error_pos(s, key_token_ptr, "string expected");
+            return -1;
+        }
+        if (JS_IsUndefined(rme->attributes)) {
+            JSValue attributes = JS_NewObjectProto(ctx, JS_NULL);
+            if (JS_IsException(attributes)) {
+                JS_FreeAtom(ctx, key);
+                return -1;
+            }
+            rme->attributes = attributes;
+        }
+        ret = JS_HasProperty(ctx, rme->attributes, key);
+        if (ret != 0) {
+            JS_FreeAtom(ctx, key);
+            if (ret < 0)
+                return -1;
+            else
+                return js_parse_error(s, "duplicate with key");
+        }
+        ret = JS_DefinePropertyValue(ctx, rme->attributes, key,
+                                     JS_DupValue(ctx, s->token.u.str.str), JS_PROP_C_W_E);
+        JS_FreeAtom(ctx, key);
+        if (ret < 0)
+            return -1;
+        if (next_token(s))
+            return -1;
+        if (s->token.val != ',')
+            break;
+        if (next_token(s))
+            return -1;
+    }
+    if (!JS_IsUndefined(rme->attributes) &&
+        ctx->rt->module_check_attrs &&
+        ctx->rt->module_check_attrs(ctx, ctx->rt->module_loader_opaque, rme->attributes) < 0) {
+        return -1;
+    }
+    return js_parse_expect(s, '}');
+}
+
+/* return the module index in m->req_module_entries[] or < 0 if error */
+static __exception int js_parse_from_clause(JSParseState *s, JSModuleDef *m)
 {
     JSAtom module_name;
+    int idx;
+
     if (!token_is_pseudo_keyword(s, JS_ATOM_from)) {
         js_parse_error(s, "from clause expected");
-        return JS_ATOM_NULL;
+        return -1;
     }
     if (next_token(s))
-        return JS_ATOM_NULL;
+        return -1;
     if (s->token.val != TOK_STRING) {
         js_parse_error(s, "string expected");
-        return JS_ATOM_NULL;
+        return -1;
     }
     module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
     if (module_name == JS_ATOM_NULL)
-        return JS_ATOM_NULL;
+        return -1;
     if (next_token(s)) {
         JS_FreeAtom(s->ctx, module_name);
-        return JS_ATOM_NULL;
+        return -1;
     }
-    return module_name;
+
+    idx = add_req_module_entry(s->ctx, m, module_name);
+    JS_FreeAtom(s->ctx, module_name);
+    if (idx < 0)
+        return -1;
+    if (s->token.val == TOK_WITH) {
+        if (js_parse_with_clause(s, &m->req_module_entries[idx]))
+            return -1;
+    }
+    return idx;
 }
 
 static __exception int js_parse_export(JSParseState *s)
@@ -28020,7 +30337,6 @@ static __exception int js_parse_export(JSParseState *s)
     JSModuleDef *m = s->cur_func->module;
     JSAtom local_name, export_name;
     int first_export, idx, i, tok;
-    JSAtom module_name;
     JSExportEntry *me;
 
     if (next_token(s))
@@ -28034,7 +30350,7 @@ static __exception int js_parse_export(JSParseState *s)
                 peek_token(s, TRUE) == TOK_FUNCTION)) {
         return js_parse_function_decl2(s, JS_PARSE_FUNC_STATEMENT,
                                        JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                       s->token.ptr, s->token.line_num,
+                                       s->token.ptr,
                                        JS_PARSE_EXPORT_NAMED, NULL);
     }
 
@@ -28056,11 +30372,21 @@ static __exception int js_parse_export(JSParseState *s)
             if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
                 if (next_token(s))
                     goto fail;
-                if (!token_is_ident(s->token.val)) {
-                    js_parse_error(s, "identifier expected");
-                    goto fail;
+                if (s->token.val == TOK_STRING) {
+                    if (js_string_find_invalid_codepoint(JS_VALUE_GET_STRING(s->token.u.str.str)) >= 0) {
+                        js_parse_error(s, "contains unpaired surrogate");
+                        goto fail;
+                    }
+                    export_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
+                    if (export_name == JS_ATOM_NULL)
+                        goto fail;
+                } else {
+                    if (!token_is_ident(s->token.val)) {
+                        js_parse_error(s, "identifier expected");
+                        goto fail;
+                    }
+                    export_name = JS_DupAtom(ctx, s->token.u.ident.atom);
                 }
-                export_name = JS_DupAtom(ctx, s->token.u.ident.atom);
                 if (next_token(s)) {
                 fail:
                     JS_FreeAtom(ctx, local_name);
@@ -28085,11 +30411,7 @@ static __exception int js_parse_export(JSParseState *s)
         if (js_parse_expect(s, '}'))
             return -1;
         if (token_is_pseudo_keyword(s, JS_ATOM_from)) {
-            module_name = js_parse_from_clause(s);
-            if (module_name == JS_ATOM_NULL)
-                return -1;
-            idx = add_req_module_entry(ctx, m, module_name);
-            JS_FreeAtom(ctx, module_name);
+            idx = js_parse_from_clause(s, m);
             if (idx < 0)
                 return -1;
             for(i = first_export; i < m->export_entries_count; i++) {
@@ -28111,11 +30433,7 @@ static __exception int js_parse_export(JSParseState *s)
             export_name = JS_DupAtom(ctx, s->token.u.ident.atom);
             if (next_token(s))
                 goto fail1;
-            module_name = js_parse_from_clause(s);
-            if (module_name == JS_ATOM_NULL)
-                goto fail1;
-            idx = add_req_module_entry(ctx, m, module_name);
-            JS_FreeAtom(ctx, module_name);
+            idx = js_parse_from_clause(s, m);
             if (idx < 0)
                 goto fail1;
             me = add_export_entry(s, m, JS_ATOM__star_, export_name,
@@ -28125,11 +30443,7 @@ static __exception int js_parse_export(JSParseState *s)
                 return -1;
             me->u.req_module_idx = idx;
         } else {
-            module_name = js_parse_from_clause(s);
-            if (module_name == JS_ATOM_NULL)
-                return -1;
-            idx = add_req_module_entry(ctx, m, module_name);
-            JS_FreeAtom(ctx, module_name);
+            idx = js_parse_from_clause(s, m);
             if (idx < 0)
                 return -1;
             if (add_star_export_entry(ctx, m, idx) < 0)
@@ -28144,7 +30458,7 @@ static __exception int js_parse_export(JSParseState *s)
                     peek_token(s, TRUE) == TOK_FUNCTION)) {
             return js_parse_function_decl2(s, JS_PARSE_FUNC_STATEMENT,
                                            JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                           s->token.ptr, s->token.line_num,
+                                           s->token.ptr,
                                            JS_PARSE_EXPORT_DEFAULT, NULL);
         } else {
             if (js_parse_assign_expr(s))
@@ -28183,12 +30497,11 @@ static int add_closure_var(JSContext *ctx, JSFunctionDef *s,
                            JSVarKindEnum var_kind);
 
 static int add_import(JSParseState *s, JSModuleDef *m,
-                      JSAtom local_name, JSAtom import_name)
+                      JSAtom local_name, JSAtom import_name, BOOL is_star)
 {
     JSContext *ctx = s->ctx;
     int i, var_idx;
     JSImportEntry *mi;
-    BOOL is_local;
 
     if (local_name == JS_ATOM_arguments || local_name == JS_ATOM_eval)
         return js_parse_error(s, "invalid import binding");
@@ -28200,8 +30513,7 @@ static int add_import(JSParseState *s, JSModuleDef *m,
         }
     }
 
-    is_local = (import_name == JS_ATOM__star_);
-    var_idx = add_closure_var(ctx, s->cur_func, is_local, FALSE,
+    var_idx = add_closure_var(ctx, s->cur_func, is_star, FALSE,
                               m->import_entries_count,
                               local_name, TRUE, TRUE, FALSE);
     if (var_idx < 0)
@@ -28214,6 +30526,7 @@ static int add_import(JSParseState *s, JSModuleDef *m,
     mi = &m->import_entries[m->import_entries_count++];
     mi->import_name = JS_DupAtom(ctx, import_name);
     mi->var_idx = var_idx;
+    mi->is_star = is_star;
     return 0;
 }
 
@@ -28236,6 +30549,14 @@ static __exception int js_parse_import(JSParseState *s)
             JS_FreeAtom(ctx, module_name);
             return -1;
         }
+        idx = add_req_module_entry(ctx, m, module_name);
+        JS_FreeAtom(ctx, module_name);
+        if (idx < 0)
+            return -1;
+        if (s->token.val == TOK_WITH) {
+            if (js_parse_with_clause(s, &m->req_module_entries[idx]))
+                return -1;
+        }
     } else {
         if (s->token.val == TOK_IDENT) {
             if (s->token.u.ident.is_reserved) {
@@ -28246,7 +30567,7 @@ static __exception int js_parse_import(JSParseState *s)
             import_name = JS_ATOM_default;
             if (next_token(s))
                 goto fail;
-            if (add_import(s, m, local_name, import_name))
+            if (add_import(s, m, local_name, import_name, FALSE))
                 goto fail;
             JS_FreeAtom(ctx, local_name);
 
@@ -28272,7 +30593,7 @@ static __exception int js_parse_import(JSParseState *s)
             import_name = JS_ATOM__star_;
             if (next_token(s))
                 goto fail;
-            if (add_import(s, m, local_name, import_name))
+            if (add_import(s, m, local_name, import_name, TRUE))
                 goto fail;
             JS_FreeAtom(ctx, local_name);
         } else if (s->token.val == '{') {
@@ -28280,11 +30601,24 @@ static __exception int js_parse_import(JSParseState *s)
                 return -1;
 
             while (s->token.val != '}') {
-                if (!token_is_ident(s->token.val)) {
-                    js_parse_error(s, "identifier expected");
-                    return -1;
+                BOOL is_string;
+                if (s->token.val == TOK_STRING) {
+                    is_string = TRUE;
+                    if (js_string_find_invalid_codepoint(JS_VALUE_GET_STRING(s->token.u.str.str)) >= 0) {
+                        js_parse_error(s, "contains unpaired surrogate");
+                        return -1;
+                    }
+                    import_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
+                    if (import_name == JS_ATOM_NULL)
+                        return -1;
+                } else {
+                    is_string = FALSE;
+                    if (!token_is_ident(s->token.val)) {
+                        js_parse_error(s, "identifier expected");
+                        return -1;
+                    }
+                    import_name = JS_DupAtom(ctx, s->token.u.ident.atom);
                 }
-                import_name = JS_DupAtom(ctx, s->token.u.ident.atom);
                 local_name = JS_ATOM_NULL;
                 if (next_token(s))
                     goto fail;
@@ -28296,16 +30630,19 @@ static __exception int js_parse_import(JSParseState *s)
                         goto fail;
                     }
                     local_name = JS_DupAtom(ctx, s->token.u.ident.atom);
-                    if (next_token(s)) {
+                    if (next_token(s))
+                        goto fail;
+                } else {
+                    if (is_string) {
+                        js_parse_error(s, "expecting 'as'");
                     fail:
                         JS_FreeAtom(ctx, local_name);
                         JS_FreeAtom(ctx, import_name);
                         return -1;
                     }
-                } else {
                     local_name = JS_DupAtom(ctx, import_name);
                 }
-                if (add_import(s, m, local_name, import_name))
+                if (add_import(s, m, local_name, import_name, FALSE))
                     goto fail;
                 JS_FreeAtom(ctx, local_name);
                 JS_FreeAtom(ctx, import_name);
@@ -28318,14 +30655,10 @@ static __exception int js_parse_import(JSParseState *s)
                 return -1;
         }
     end_import_clause:
-        module_name = js_parse_from_clause(s);
-        if (module_name == JS_ATOM_NULL)
+        idx = js_parse_from_clause(s, m);
+        if (idx < 0)
             return -1;
     }
-    idx = add_req_module_entry(ctx, m, module_name);
-    JS_FreeAtom(ctx, module_name);
-    if (idx < 0)
-        return -1;
     for(i = first_import; i < m->import_entries_count; i++)
         m->import_entries[i].req_module_idx = idx;
 
@@ -28336,13 +30669,13 @@ static __exception int js_parse_source_element(JSParseState *s)
 {
     JSFunctionDef *fd = s->cur_func;
     int tok;
-    
+
     if (s->token.val == TOK_FUNCTION ||
         (token_is_pseudo_keyword(s, JS_ATOM_async) &&
          peek_token(s, TRUE) == TOK_FUNCTION)) {
         if (js_parse_function_decl(s, JS_PARSE_FUNC_STATEMENT,
                                    JS_FUNC_NORMAL, JS_ATOM_NULL,
-                                   s->token.ptr, s->token.line_num))
+                                   s->token.ptr))
             return -1;
     } else if (s->token.val == TOK_EXPORT && fd->module) {
         if (js_parse_export(s))
@@ -28364,7 +30697,9 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
                                           JSFunctionDef *parent,
                                           BOOL is_eval,
                                           BOOL is_func_expr,
-                                          const char *filename, int line_num)
+                                          const char *filename,
+                                          const uint8_t *source_ptr,
+                                          GetLineColCache *get_line_col_cache)
 {
     JSFunctionDef *fd;
 
@@ -28383,6 +30718,8 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
         fd->js_mode = parent->js_mode;
         fd->parent_scope_level = parent->scope_level;
     }
+    fd->strip_debug = ((ctx->rt->strip_flags & JS_STRIP_DEBUG) != 0);
+    fd->strip_source = ((ctx->rt->strip_flags & (JS_STRIP_DEBUG | JS_STRIP_SOURCE)) != 0);
 
     fd->is_eval = is_eval;
     fd->is_func_expr = is_func_expr;
@@ -28411,13 +30748,13 @@ static JSFunctionDef *js_new_function_def(JSContext *ctx,
     fd->body_scope = -1;
 
     fd->filename = JS_NewAtom(ctx, filename);
-    fd->line_num = line_num;
-
+    fd->source_pos = source_ptr - get_line_col_cache->buf_start;
+    fd->get_line_col_cache = get_line_col_cache;
+    
     js_dbuf_init(ctx, &fd->pc2line);
     //fd->pc2line_last_line_num = line_num;
     //fd->pc2line_last_pc = 0;
-    fd->last_opcode_line_num = line_num;
-
+    fd->last_opcode_source_ptr = source_ptr;
     return fd;
 }
 
@@ -28428,7 +30765,7 @@ static void free_bytecode_atoms(JSRuntime *rt,
     int pos, len, op;
     JSAtom atom;
     const JSOpCode *oi;
-    
+
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
@@ -28436,7 +30773,7 @@ static void free_bytecode_atoms(JSRuntime *rt,
             oi = &short_opcode_info(op);
         else
             oi = &opcode_info[op];
-            
+
         len = oi->size;
         switch(oi->fmt) {
         case OP_FMT_atom:
@@ -28444,6 +30781,8 @@ static void free_bytecode_atoms(JSRuntime *rt,
         case OP_FMT_atom_u16:
         case OP_FMT_atom_label_u8:
         case OP_FMT_atom_label_u16:
+            if ((pos + 1 + 4) > bc_len)
+                break; /* may happen if there is not enough memory when emiting bytecode */
             atom = get_u32(bc_buf + pos + 1);
             JS_FreeAtomRT(rt, atom);
             break;
@@ -28546,14 +30885,19 @@ static void dump_byte_code(JSContext *ctx, int pass,
                            const JSVarDef *vars, int var_count,
                            const JSClosureVar *closure_var, int closure_var_count,
                            const JSValue *cpool, uint32_t cpool_count,
-                           const char *source, int line_num,
+                           const char *source,
                            const LabelSlot *label_slots, JSFunctionBytecode *b)
 {
     const JSOpCode *oi;
-    int pos, pos_next, op, size, idx, addr, line, line1, in_source;
+    int pos, pos_next, op, size, idx, addr, line, line1, in_source, line_num;
     uint8_t *bits = js_mallocz(ctx, len * sizeof(*bits));
     BOOL use_short_opcodes = (b != NULL);
 
+    if (b) {
+        int col_num;
+        line_num = find_line_num(ctx, b, -1, &col_num);
+    }
+    
     /* scan for jump targets */
     for (pos = 0; pos < len; pos = pos_next) {
         op = tab[pos];
@@ -28606,10 +30950,12 @@ static void dump_byte_code(JSContext *ctx, int pass,
     pos = 0;
     while (pos < len) {
         op = tab[pos];
-        if (source) {
+        if (source && b) {
+            int col_num;
             if (b) {
-                line1 = find_line_num(ctx, b, pos) - line_num + 1;
+                line1 = find_line_num(ctx, b, pos, &col_num) - line_num + 1;
             } else if (op == OP_line_num) {
+                /* XXX: no longer works */
                 line1 = get_u32(tab + pos + 1) - line_num + 1;
             }
             if (line1 > line) {
@@ -28727,7 +31073,7 @@ static void dump_byte_code(JSContext *ctx, int pass,
         has_pool_idx:
             printf(" %u: ", idx);
             if (idx < cpool_count) {
-                JS_DumpValue(ctx, cpool[idx]);
+                JS_PrintValue(ctx, js_dump_value_write, stdout, cpool[idx], NULL);
             }
             break;
         case OP_FMT_atom:
@@ -28810,49 +31156,64 @@ static void dump_byte_code(JSContext *ctx, int pass,
     js_free(ctx, bits);
 }
 
-static __maybe_unused void dump_pc2line(JSContext *ctx, const uint8_t *buf, int len,
-                                                 int line_num)
+static __maybe_unused void dump_pc2line(JSContext *ctx, const uint8_t *buf, int len)
 {
-    const uint8_t *p_end, *p_next, *p;
-    int pc, v;
+    const uint8_t *p_end, *p;
+    int pc, v, line_num, col_num, ret;
     unsigned int op;
-
+    uint32_t val;
+    
     if (len <= 0)
         return;
 
-    printf("%5s %5s\n", "PC", "LINE");
+    printf("%5s %5s %5s\n", "PC", "LINE", "COL");
 
     p = buf;
     p_end = buf + len;
+    
+    /* get the function line and column numbers */
+    ret = get_leb128(&val, p, p_end);
+    if (ret < 0)
+        goto fail;
+    p += ret;
+    line_num = val + 1;
+
+    ret = get_leb128(&val, p, p_end);
+    if (ret < 0)
+        goto fail;
+    p += ret;
+    col_num = val + 1;
+
+    printf("%5s %5d %5d\n", "-", line_num, col_num);
+    
     pc = 0;
     while (p < p_end) {
         op = *p++;
         if (op == 0) {
-            v = unicode_from_utf8(p, p_end - p, &p_next);
-            if (v < 0)
+            ret = get_leb128(&val, p, p_end);
+            if (ret < 0)
                 goto fail;
-            pc += v;
-            p = p_next;
-            v = unicode_from_utf8(p, p_end - p, &p_next);
-            if (v < 0) {
-            fail:
-                printf("invalid pc2line encode pos=%d\n", (int)(p - buf));
-                return;
-            }
-            if (!(v & 1)) {
-                v = v >> 1;
-            } else {
-                v = -(v >> 1) - 1;
-            }
+            pc += val;
+            p += ret;
+            ret = get_sleb128(&v, p, p_end);
+            if (ret < 0)
+                goto fail;
+            p += ret;
             line_num += v;
-            p = p_next;
         } else {
             op -= PC2LINE_OP_FIRST;
             pc += (op / PC2LINE_RANGE);
             line_num += (op % PC2LINE_RANGE) + PC2LINE_BASE;
         }
-        printf("%5d %5d\n", pc, line_num);
+        ret = get_sleb128(&v, p, p_end);
+        if (ret < 0)
+            goto fail;
+        p += ret;
+        col_num += v;
+        
+        printf("%5d %5d %5d\n", pc, line_num, col_num);
     }
+ fail: ;
 }
 
 static __maybe_unused void js_dump_function_bytecode(JSContext *ctx, JSFunctionBytecode *b)
@@ -28862,8 +31223,10 @@ static __maybe_unused void js_dump_function_bytecode(JSContext *ctx, JSFunctionB
     const char *str;
 
     if (b->has_debug && b->debug.filename != JS_ATOM_NULL) {
+        int line_num, col_num;
         str = JS_AtomGetStr(ctx, atom_buf, sizeof(atom_buf), b->debug.filename);
-        printf("%s:%d: ", str, b->debug.line_num);
+        line_num = find_line_num(ctx, b, -1, &col_num);
+        printf("%s:%d:%d: ", str, line_num, col_num);
     }
 
     str = JS_AtomGetStr(ctx, atom_buf, sizeof(atom_buf), b->func_name);
@@ -28872,10 +31235,6 @@ static __maybe_unused void js_dump_function_bytecode(JSContext *ctx, JSFunctionB
         printf("  mode:");
         if (b->js_mode & JS_MODE_STRICT)
             printf(" strict");
-#ifdef CONFIG_BIGNUM
-        if (b->js_mode & JS_MODE_MATH)
-            printf(" math");
-#endif
         printf("\n");
     }
     if (b->arg_count && b->vardefs) {
@@ -28922,10 +31281,10 @@ static __maybe_unused void js_dump_function_bytecode(JSContext *ctx, JSFunctionB
                    b->closure_var, b->closure_var_count,
                    b->cpool, b->cpool_count,
                    b->has_debug ? b->debug.source : NULL,
-                   b->has_debug ? b->debug.line_num : -1, NULL, b);
+                   NULL, b);
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 32)
     if (b->has_debug)
-        dump_pc2line(ctx, b->debug.pc2line_buf, b->debug.pc2line_len, b->debug.line_num);
+        dump_pc2line(ctx, b->debug.pc2line_buf, b->debug.pc2line_len);
 #endif
     printf("\n");
 }
@@ -29213,13 +31572,19 @@ static void var_object_test(JSContext *ctx, JSFunctionDef *s,
 {
     dbuf_putc(bc, get_with_scope_opcode(op));
     dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
-    *plabel_done = new_label_fd(s, *plabel_done);
+    if (*plabel_done < 0) {
+        *plabel_done = new_label_fd(s);
+        if (*plabel_done < 0) {
+            dbuf_set_error(bc);
+            return;
+        }
+    }
     dbuf_put_u32(bc, *plabel_done);
     dbuf_putc(bc, is_with);
     update_label(s, *plabel_done, 1);
     s->jump_size++;
 }
-    
+
 /* return the position of the next opcode */
 static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                              JSAtom var_name, int scope_level, int op,
@@ -29342,6 +31707,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         case OP_scope_get_ref:
             dbuf_putc(bc, OP_undefined);
             /* fall thru */
+        case OP_scope_get_var_checkthis:
         case OP_scope_get_var_undef:
         case OP_scope_get_var:
         case OP_scope_put_var:
@@ -29367,7 +31733,12 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
                     }
                 } else {
                     if (s->vars[var_idx].is_lexical) {
-                        dbuf_putc(bc, OP_get_loc_check);
+                        if (op == OP_scope_get_var_checkthis) {
+                            /* only used for 'this' return in derived class constructors */
+                            dbuf_putc(bc, OP_get_loc_checkthis);
+                        } else {
+                            dbuf_putc(bc, OP_get_loc_check);
+                        }
                     } else {
                         dbuf_putc(bc, OP_get_loc);
                     }
@@ -29425,7 +31796,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
         is_arg_scope = (idx == ARG_SCOPE_END);
         if (var_idx >= 0)
             break;
-        
+
         if (!is_arg_scope) {
             var_idx = find_var(ctx, fd, var_name);
             if (var_idx >= 0)
@@ -29469,7 +31840,7 @@ static int resolve_scope_var(JSContext *ctx, JSFunctionDef *s,
             dbuf_put_u16(bc, idx);
             var_object_test(ctx, s, var_name, op, bc, &label_done, 0);
         }
-        
+
         if (fd->is_eval)
             break; /* it it necessarily the top level function */
     }
@@ -29672,7 +32043,7 @@ static void get_loc_or_ref(DynBuf *bc, BOOL is_ref, int idx)
 {
     /* if the field is not initialized, the error is catched when
        accessing it */
-    if (is_ref) 
+    if (is_ref)
         dbuf_putc(bc, OP_get_var_ref);
     else
         dbuf_putc(bc, OP_get_loc);
@@ -29687,7 +32058,7 @@ static int resolve_scope_private_field1(JSContext *ctx,
     int idx, var_kind;
     JSFunctionDef *fd;
     BOOL is_ref;
-    
+
     fd = s;
     is_ref = FALSE;
     for(;;) {
@@ -29831,6 +32202,10 @@ static int resolve_scope_private_field(JSContext *ctx, JSFunctionDef *s,
             abort();
         }
         break;
+    case OP_scope_in_private_field:
+        get_loc_or_ref(bc, is_ref, idx);
+        dbuf_putc(bc, OP_private_in);
+        break;
     default:
         abort();
     }
@@ -30015,7 +32390,7 @@ static __exception int add_closure_variables(JSContext *ctx, JSFunctionDef *s,
     int i, count;
     JSVarDef *vd;
     BOOL is_arg_scope;
-    
+
     count = b->arg_count + b->var_count + b->closure_var_count;
     s->closure_var = NULL;
     s->closure_var_count = 0;
@@ -30248,8 +32623,11 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
        evaluating the module so that the exported functions are
        visible if there are cyclic module references */
     if (s->module) {
-        label_next = new_label_fd(s, -1);
-        
+        label_next = new_label_fd(s);
+        if (label_next < 0) {
+            dbuf_set_error(bc);
+            return;
+        }
         /* if 'this' is true, initialize the global variables and return */
         dbuf_putc(bc, OP_push_this);
         dbuf_putc(bc, OP_if_false);
@@ -30257,7 +32635,7 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
         update_label(s, label_next, 1);
         s->jump_size++;
     }
-    
+
     /* add the global variables (only happens if s->is_global_var is
        true) */
     for(i = 0; i < s->global_var_count; i++) {
@@ -30286,7 +32664,7 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
         }
         if (!has_closure) {
             int flags;
-            
+
             flags = 0;
             if (s->eval_type != JS_EVAL_TYPE_GLOBAL)
                 flags |= JS_PROP_CONFIGURABLE;
@@ -30294,11 +32672,11 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
                 /* global function definitions need a specific handling */
                 dbuf_putc(bc, OP_fclosure);
                 dbuf_put_u32(bc, hf->cpool_idx);
-                
+
                 dbuf_putc(bc, OP_define_func);
                 dbuf_put_u32(bc, JS_DupAtom(ctx, hf->var_name));
                 dbuf_putc(bc, flags);
-                
+
                 goto done_global_var;
             } else {
                 if (hf->is_lexical) {
@@ -30342,7 +32720,7 @@ static void instantiate_hoisted_definitions(JSContext *ctx, JSFunctionDef *s, Dy
 
     if (s->module) {
         dbuf_putc(bc, OP_return_undef);
-        
+
         dbuf_putc(bc, OP_label);
         dbuf_put_u32(bc, label_next);
         s->label_slots[label_next].pos2 = bc->size;
@@ -30447,7 +32825,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
     for(i = 0; i < s->global_var_count; i++) {
         JSGlobalVar *hf = &s->global_vars[i];
         int flags;
-        
+
         /* check if global variable (XXX: simplify) */
         for(idx = 0; idx < s->closure_var_count; idx++) {
             JSClosureVar *cv = &s->closure_var[idx];
@@ -30469,7 +32847,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                 cv->var_name == JS_ATOM__arg_var_)
                 goto next;
         }
-        
+
         dbuf_putc(&bc_out, OP_check_define_var);
         dbuf_put_u32(&bc_out, JS_DupAtom(ctx, hf->var_name));
         flags = 0;
@@ -30499,15 +32877,16 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
                 mark_eval_captured_variables(ctx, s, scope);
                 dbuf_putc(&bc_out, op);
                 dbuf_put_u16(&bc_out, call_argc);
-                dbuf_put_u16(&bc_out, s->scopes[scope].first + 1);
+                dbuf_put_u16(&bc_out, s->scopes[scope].first - ARG_SCOPE_END);
             }
             break;
         case OP_apply_eval: /* convert scope index to adjusted variable index */
             scope = get_u16(bc_buf + pos + 1);
             mark_eval_captured_variables(ctx, s, scope);
             dbuf_putc(&bc_out, op);
-            dbuf_put_u16(&bc_out, s->scopes[scope].first + 1);
+            dbuf_put_u16(&bc_out, s->scopes[scope].first - ARG_SCOPE_END);
             break;
+        case OP_scope_get_var_checkthis:
         case OP_scope_get_var_undef:
         case OP_scope_get_var:
         case OP_scope_put_var:
@@ -30537,6 +32916,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         case OP_scope_get_private_field:
         case OP_scope_get_private_field2:
         case OP_scope_put_private_field:
+        case OP_scope_in_private_field:
             {
                 int ret;
                 var_name = get_u32(bc_buf + pos + 1);
@@ -30748,7 +33128,18 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         case OP_set_class_name:
             /* only used during parsing */
             break;
-            
+
+        case OP_get_field_opt_chain: /* equivalent to OP_get_field */
+            {
+                JSAtom name = get_u32(bc_buf + pos + 1);
+                dbuf_putc(&bc_out, OP_get_field);
+                dbuf_put_u32(&bc_out, name);
+            }
+            break;
+        case OP_get_array_el_opt_chain: /* equivalent to OP_get_array_el */
+            dbuf_putc(&bc_out, OP_get_array_el);
+            break;
+
         default:
         no_change:
             dbuf_put(&bc_out, bc_buf + pos, len);
@@ -30778,40 +33169,58 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
     return -1;
 }
 
-/* the pc2line table gives a line number for each PC value */
-static void add_pc2line_info(JSFunctionDef *s, uint32_t pc, int line_num)
+/* the pc2line table gives a source position for each PC value */
+static void add_pc2line_info(JSFunctionDef *s, uint32_t pc, uint32_t source_pos)
 {
     if (s->line_number_slots != NULL
     &&  s->line_number_count < s->line_number_size
     &&  pc >= s->line_number_last_pc
-    &&  line_num != s->line_number_last) {
+    &&  source_pos != s->line_number_last) {
         s->line_number_slots[s->line_number_count].pc = pc;
-        s->line_number_slots[s->line_number_count].line_num = line_num;
+        s->line_number_slots[s->line_number_count].source_pos = source_pos;
         s->line_number_count++;
         s->line_number_last_pc = pc;
-        s->line_number_last = line_num;
+        s->line_number_last = source_pos;
     }
 }
 
+/* XXX: could use a more compact storage */
+/* XXX: get_line_col_cached() is slow. For more predictable
+   performance, line/cols could be stored every N source
+   bytes. Alternatively, get_line_col_cached() could be issued in
+   emit_source_pos() so that the deltas are more likely to be
+   small. */
 static void compute_pc2line_info(JSFunctionDef *s)
 {
-    if (!(s->js_mode & JS_MODE_STRIP) && s->line_number_slots) {
-        int last_line_num = s->line_num;
+    if (!s->strip_debug) {
+        int last_line_num, last_col_num;
         uint32_t last_pc = 0;
-        int i;
-
+        int i, line_num, col_num;
+        const uint8_t *buf_start = s->get_line_col_cache->buf_start;
         js_dbuf_init(s->ctx, &s->pc2line);
+
+        last_line_num = get_line_col_cached(s->get_line_col_cache,
+                                            &last_col_num,
+                                            buf_start + s->source_pos);
+        dbuf_put_leb128(&s->pc2line, last_line_num); /* line number minus 1 */
+        dbuf_put_leb128(&s->pc2line, last_col_num); /* column number minus 1 */
+
         for (i = 0; i < s->line_number_count; i++) {
             uint32_t pc = s->line_number_slots[i].pc;
-            int line_num = s->line_number_slots[i].line_num;
-            int diff_pc, diff_line;
+            uint32_t source_pos = s->line_number_slots[i].source_pos;
+            int diff_pc, diff_line, diff_col;
 
-            if (line_num < 0)
+            if (source_pos == -1)
                 continue;
-
             diff_pc = pc - last_pc;
+            if (diff_pc < 0)
+                continue;
+
+            line_num = get_line_col_cached(s->get_line_col_cache, &col_num,
+                                           buf_start + source_pos);
             diff_line = line_num - last_line_num;
-            if (diff_line == 0 || diff_pc < 0)
+            diff_col = col_num - last_col_num;
+            if (diff_line == 0 && diff_col == 0)
                 continue;
 
             if (diff_line >= PC2LINE_BASE &&
@@ -30825,8 +33234,11 @@ static void compute_pc2line_info(JSFunctionDef *s)
                 dbuf_put_leb128(&s->pc2line, diff_pc);
                 dbuf_put_sleb128(&s->pc2line, diff_line);
             }
+            dbuf_put_sleb128(&s->pc2line, diff_col);
+                
             last_pc = pc;
             last_line_num = line_num;
+            last_col_num = col_num;
         }
     }
 }
@@ -30872,10 +33284,11 @@ static BOOL code_has_label(CodeContext *s, int pos, int label)
 /* return the target label, following the OP_goto jumps
    the first opcode at destination is stored in *pop
  */
-static int find_jump_target(JSFunctionDef *s, int label, int *pop, int *pline)
+static int find_jump_target(JSFunctionDef *s, int label0, int *pop, int *pline)
 {
-    int i, pos, op;
+    int i, pos, op, label;
 
+    label = label0;
     update_label(s, label, -1);
     for (i = 0; i < 10; i++) {
         assert(label >= 0 && label < s->label_count);
@@ -30906,6 +33319,19 @@ static int find_jump_target(JSFunctionDef *s, int label, int *pop, int *pline)
         }
     }
     /* cycle detected, could issue a warning */
+    /* XXX: the combination of find_jump_target() and skip_dead_code()
+       seems incorrect with cyclic labels. See for exemple:
+
+       for (;;) {
+       l:break l;
+       l:break l;
+       l:break l;
+       l:break l;
+       }
+
+       Avoiding changing the target is just a workaround and might not
+       suffice to completely fix the problem. */
+    label = label0;
  done:
     *pop = op;
     update_label(s, label, +1);
@@ -31008,7 +33434,7 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
 
     label_slots = s->label_slots;
 
-    line_num = s->line_num;
+    line_num = s->source_pos;
 
     cc.bc_buf = bc_buf = s->byte_code.buf;
     cc.bc_len = bc_len = s->byte_code.size;
@@ -31022,11 +33448,11 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
     }
 #endif
     /* XXX: Should skip this phase if not generating SHORT_OPCODES */
-    if (s->line_number_size && !(s->js_mode & JS_MODE_STRIP)) {
+    if (s->line_number_size && !s->strip_debug) {
         s->line_number_slots = js_mallocz(s->ctx, sizeof(*s->line_number_slots) * s->line_number_size);
         if (s->line_number_slots == NULL)
             return -1;
-        s->line_number_last = s->line_num;
+        s->line_number_last = s->source_pos;
         s->line_number_last_pc = 0;
     }
 
@@ -31175,7 +33601,7 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                 if (op1 == OP_return || op1 == OP_return_undef || op1 == OP_throw) {
                     /* jump to return/throw: remove jump, append return/throw */
                     /* updating the line number obfuscates assembly listing */
-                    //if (line1 >= 0) line_num = line1;
+                    //if (line1 != -1) line_num = line1;
                     update_label(s, label, -1);
                     add_pc2line_info(s, bc_out.size, line_num);
                     dbuf_putc(&bc_out, op1);
@@ -31223,7 +33649,7 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
                     int pos1 = cc.pos;
                     int line1 = cc.line_num;
                     if (code_has_label(&cc, pos1, label)) {
-                        if (line1 >= 0) line_num = line1;
+                        if (line1 != -1) line_num = line1;
                         pos_next = pos1;
                         update_label(s, label, -1);
                         label = cc.label;
@@ -31296,7 +33722,6 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
         case OP_with_delete_var:
         case OP_with_make_ref:
         case OP_with_get_ref:
-        case OP_with_get_ref_undef:
             {
                 JSAtom atom;
                 int is_with;
@@ -31423,6 +33848,26 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
             }
             goto no_change;
 
+        case OP_push_bigint_i32:
+            if (OPTIMIZE) {
+                /* transform i32(val) neg -> i32(-val) */
+                val = get_i32(bc_buf + pos + 1);
+                if (val != INT32_MIN
+                &&  code_match(&cc, pos_next, OP_neg, -1)) {
+                    if (cc.line_num >= 0) line_num = cc.line_num;
+                    if (code_match(&cc, cc.pos, OP_drop, -1)) {
+                        if (cc.line_num >= 0) line_num = cc.line_num;
+                    } else {
+                        add_pc2line_info(s, bc_out.size, line_num);
+                        dbuf_putc(&bc_out, OP_push_bigint_i32);
+                        dbuf_put_u32(&bc_out, -val);
+                    }
+                    pos_next = cc.pos;
+                    break;
+                }
+            }
+            goto no_change;
+
 #if SHORT_OPCODES
         case OP_push_const:
         case OP_fclosure:
@@ -31471,9 +33916,8 @@ static __exception int resolve_labels(JSContext *ctx, JSFunctionDef *s)
             goto no_change;
 
         case OP_to_propkey:
-        case OP_to_propkey2:
             if (OPTIMIZE) {
-                /* remove redundant to_propkey/to_propkey2 opcodes when storing simple data */
+                /* remove redundant to_propkey opcodes when storing simple data */
                 if (code_match(&cc, pos_next, M3(OP_get_loc, OP_get_arg, OP_get_var_ref), -1, OP_put_array_el, -1)
                 ||  code_match(&cc, pos_next, M3(OP_push_i32, OP_push_const, OP_push_atom_value), OP_put_array_el, -1)
                 ||  code_match(&cc, pos_next, M4(OP_undefined, OP_null, OP_push_true, OP_push_false), OP_put_array_el, -1)) {
@@ -31880,6 +34324,7 @@ typedef struct StackSizeState {
     int bc_len;
     int stack_len_max;
     uint16_t *stack_level_tab;
+    int32_t *catch_pos_tab;
     int *pc_stack;
     int pc_stack_len;
     int pc_stack_size;
@@ -31887,7 +34332,7 @@ typedef struct StackSizeState {
 
 /* 'op' is only used for error indication */
 static __exception int ss_check(JSContext *ctx, StackSizeState *s,
-                                int pos, int op, int stack_len)
+                                int pos, int op, int stack_len, int catch_pos)
 {
     if ((unsigned)pos >= s->bc_len) {
         JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
@@ -31906,6 +34351,10 @@ static __exception int ss_check(JSContext *ctx, StackSizeState *s,
             JS_ThrowInternalError(ctx, "inconsistent stack size: %d %d (pc=%d)",
                                   s->stack_level_tab[pos], stack_len, pos);
             return -1;
+        } else if (s->catch_pos_tab[pos] != catch_pos) {
+            JS_ThrowInternalError(ctx, "inconsistent catch position: %d %d (pc=%d)",
+                                  s->catch_pos_tab[pos], catch_pos, pos);
+            return -1;
         } else {
             return 0;
         }
@@ -31913,6 +34362,7 @@ static __exception int ss_check(JSContext *ctx, StackSizeState *s,
 
     /* mark as explored and store the stack size */
     s->stack_level_tab[pos] = stack_len;
+    s->catch_pos_tab[pos] = catch_pos;
 
     /* queue the new PC to explore */
     if (js_resize_array(ctx, (void **)&s->pc_stack, sizeof(s->pc_stack[0]),
@@ -31927,7 +34377,7 @@ static __exception int compute_stack_size(JSContext *ctx,
                                           int *pstack_size)
 {
     StackSizeState s_s, *s = &s_s;
-    int i, diff, n_pop, pos_next, stack_len, pos, op;
+    int i, diff, n_pop, pos_next, stack_len, pos, op, catch_pos, catch_level;
     const JSOpCode *oi;
     const uint8_t *bc_buf;
 
@@ -31940,24 +34390,33 @@ static __exception int compute_stack_size(JSContext *ctx,
         return -1;
     for(i = 0; i < s->bc_len; i++)
         s->stack_level_tab[i] = 0xffff;
-    s->stack_len_max = 0;
     s->pc_stack = NULL;
+    s->catch_pos_tab = js_malloc(ctx, sizeof(s->catch_pos_tab[0]) *
+                                   s->bc_len);
+    if (!s->catch_pos_tab)
+        goto fail;
+
+    s->stack_len_max = 0;
     s->pc_stack_len = 0;
     s->pc_stack_size = 0;
 
     /* breadth-first graph exploration */
-    if (ss_check(ctx, s, 0, OP_invalid, 0))
+    if (ss_check(ctx, s, 0, OP_invalid, 0, -1))
         goto fail;
 
     while (s->pc_stack_len > 0) {
         pos = s->pc_stack[--s->pc_stack_len];
         stack_len = s->stack_level_tab[pos];
+        catch_pos = s->catch_pos_tab[pos];
         op = bc_buf[pos];
         if (op == 0 || op >= OP_COUNT) {
             JS_ThrowInternalError(ctx, "invalid opcode (op=%d, pc=%d)", op, pos);
             goto fail;
         }
         oi = &short_opcode_info(op);
+#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 64)
+        printf("%5d: %10s %5d %5d\n", pos, oi->name, stack_len, catch_pos);
+#endif
         pos_next = pos + oi->size;
         if (pos_next > s->bc_len) {
             JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
@@ -32013,55 +34472,103 @@ static __exception int compute_stack_size(JSContext *ctx,
         case OP_if_true8:
         case OP_if_false8:
             diff = (int8_t)bc_buf[pos + 1];
-            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len))
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
                 goto fail;
             break;
 #endif
         case OP_if_true:
         case OP_if_false:
-        case OP_catch:
             diff = get_u32(bc_buf + pos + 1);
-            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len))
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
                 goto fail;
             break;
         case OP_gosub:
             diff = get_u32(bc_buf + pos + 1);
-            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len + 1))
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len + 1, catch_pos))
                 goto fail;
             break;
         case OP_with_get_var:
         case OP_with_delete_var:
             diff = get_u32(bc_buf + pos + 5);
-            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 1))
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 1, catch_pos))
                 goto fail;
             break;
         case OP_with_make_ref:
         case OP_with_get_ref:
-        case OP_with_get_ref_undef:
             diff = get_u32(bc_buf + pos + 5);
-            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 2))
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len + 2, catch_pos))
                 goto fail;
             break;
         case OP_with_put_var:
             diff = get_u32(bc_buf + pos + 5);
-            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len - 1))
+            if (ss_check(ctx, s, pos + 5 + diff, op, stack_len - 1, catch_pos))
                 goto fail;
             break;
-
+        case OP_catch:
+            diff = get_u32(bc_buf + pos + 1);
+            if (ss_check(ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
+                goto fail;
+            catch_pos = pos;
+            break;
+        case OP_for_of_start:
+        case OP_for_await_of_start:
+            catch_pos = pos;
+            break;
+            /* we assume the catch offset entry is only removed with
+               some op codes */
+        case OP_drop:
+            catch_level = stack_len;
+            goto check_catch;
+        case OP_nip:
+            catch_level = stack_len - 1;
+            goto check_catch;
+        case OP_nip1:
+            catch_level = stack_len - 1;
+            goto check_catch;
+        case OP_iterator_close:
+            catch_level = stack_len + 2;
+        check_catch:
+            /* Note: for for_of_start/for_await_of_start we consider
+               the catch offset is on the first stack entry instead of
+               the thirst */
+            if (catch_pos >= 0) {
+                int level;
+                level = s->stack_level_tab[catch_pos];
+                if (bc_buf[catch_pos] != OP_catch)
+                    level++; /* for_of_start, for_wait_of_start */
+                /* catch_level = stack_level before op_catch is executed ? */
+                if (catch_level == level) {
+                    catch_pos = s->catch_pos_tab[catch_pos];
+                }
+            }
+            break;
+        case OP_nip_catch:
+            if (catch_pos < 0) {
+                JS_ThrowInternalError(ctx, "nip_catch: no catch op (pc=%d)", pos);
+                goto fail;
+            }
+            stack_len = s->stack_level_tab[catch_pos];
+            if (bc_buf[catch_pos] != OP_catch)
+                stack_len++; /* for_of_start, for_wait_of_start */
+            stack_len++; /* no stack overflow is possible by construction */
+            catch_pos = s->catch_pos_tab[catch_pos];
+            break;
         default:
             break;
         }
-        if (ss_check(ctx, s, pos_next, op, stack_len))
+        if (ss_check(ctx, s, pos_next, op, stack_len, catch_pos))
             goto fail;
     done_insn: ;
     }
-    js_free(ctx, s->stack_level_tab);
     js_free(ctx, s->pc_stack);
+    js_free(ctx, s->catch_pos_tab);
+    js_free(ctx, s->stack_level_tab);
     *pstack_size = s->stack_len_max;
     return 0;
  fail:
-    js_free(ctx, s->stack_level_tab);
     js_free(ctx, s->pc_stack);
+    js_free(ctx, s->catch_pos_tab);
+    js_free(ctx, s->stack_level_tab);
     *pstack_size = 0;
     return -1;
 }
@@ -32167,12 +34674,12 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     }
 
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 4)
-    if (!(fd->js_mode & JS_MODE_STRIP)) {
+    if (!fd->strip_debug) {
         printf("pass 1\n");
         dump_byte_code(ctx, 1, fd->byte_code.buf, fd->byte_code.size,
                        fd->args, fd->arg_count, fd->vars, fd->var_count,
                        fd->closure_var, fd->closure_var_count,
-                       fd->cpool, fd->cpool_count, fd->source, fd->line_num,
+                       fd->cpool, fd->cpool_count, fd->source,
                        fd->label_slots, NULL);
         printf("\n");
     }
@@ -32182,12 +34689,12 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
         goto fail;
 
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 2)
-    if (!(fd->js_mode & JS_MODE_STRIP)) {
+    if (!fd->strip_debug) {
         printf("pass 2\n");
         dump_byte_code(ctx, 2, fd->byte_code.buf, fd->byte_code.size,
                        fd->args, fd->arg_count, fd->vars, fd->var_count,
                        fd->closure_var, fd->closure_var_count,
-                       fd->cpool, fd->cpool_count, fd->source, fd->line_num,
+                       fd->cpool, fd->cpool_count, fd->source,
                        fd->label_slots, NULL);
         printf("\n");
     }
@@ -32199,7 +34706,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     if (compute_stack_size(ctx, fd, &stack_size) < 0)
         goto fail;
 
-    if (fd->js_mode & JS_MODE_STRIP) {
+    if (fd->strip_debug) {
         function_size = offsetof(JSFunctionBytecode, debug);
     } else {
         function_size = sizeof(*b);
@@ -32207,7 +34714,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     cpool_offset = function_size;
     function_size += fd->cpool_count * sizeof(*fd->cpool);
     vardefs_offset = function_size;
-    if (!(fd->js_mode & JS_MODE_STRIP) || fd->has_eval_call) {
+    if (!fd->strip_debug || fd->has_eval_call) {
         function_size += (fd->arg_count + fd->var_count) * sizeof(*b->vardefs);
     }
     closure_var_offset = function_size;
@@ -32228,7 +34735,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
 
     b->func_name = fd->func_name;
     if (fd->arg_count + fd->var_count > 0) {
-        if ((fd->js_mode & JS_MODE_STRIP) && !fd->has_eval_call) {
+        if (fd->strip_debug && !fd->has_eval_call) {
             /* Strip variable definitions not needed at runtime */
             int i;
             for(i = 0; i < fd->var_count; i++) {
@@ -32243,8 +34750,8 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
             }
         } else {
             b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
-            memcpy(b->vardefs, fd->args, fd->arg_count * sizeof(fd->args[0]));
-            memcpy(b->vardefs + fd->arg_count, fd->vars, fd->var_count * sizeof(fd->vars[0]));
+            memcpy_no_ub(b->vardefs, fd->args, fd->arg_count * sizeof(fd->args[0]));
+            memcpy_no_ub(b->vardefs + fd->arg_count, fd->vars, fd->var_count * sizeof(fd->vars[0]));
         }
         b->var_count = fd->var_count;
         b->arg_count = fd->arg_count;
@@ -32262,7 +34769,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
 
     b->stack_size = stack_size;
 
-    if (fd->js_mode & JS_MODE_STRIP) {
+    if (fd->strip_debug) {
         JS_FreeAtom(ctx, fd->filename);
         dbuf_free(&fd->pc2line);    // probably useless
     } else {
@@ -32271,7 +34778,6 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
          */
         b->has_debug = 1;
         b->debug.filename = fd->filename;
-        b->debug.line_num = fd->line_num;
 
         //DynBuf pc2line;
         //compute_pc2line_info(fd, &pc2line);
@@ -32305,13 +34811,14 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     b->super_call_allowed = fd->super_call_allowed;
     b->super_allowed = fd->super_allowed;
     b->arguments_allowed = fd->arguments_allowed;
-    b->backtrace_barrier = fd->backtrace_barrier;
+    b->is_direct_or_indirect_eval = (fd->eval_type == JS_EVAL_TYPE_DIRECT ||
+                                     fd->eval_type == JS_EVAL_TYPE_INDIRECT);
     b->realm = JS_DupContext(ctx);
 
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-    
+
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
-    if (!(fd->js_mode & JS_MODE_STRIP)) {
+    if (!fd->strip_debug) {
         js_dump_function_bytecode(ctx, b);
     }
 #endif
@@ -32453,20 +34960,16 @@ static __exception int js_parse_directives(JSParseState *s)
             s->cur_func->has_use_strict = TRUE;
             s->cur_func->js_mode |= JS_MODE_STRICT;
         }
-#if !defined(DUMP_BYTECODE) || !(DUMP_BYTECODE & 8)
-        else if (!strcmp(str, "use strip")) {
-            s->cur_func->js_mode |= JS_MODE_STRIP;
-        }
-#endif
-#ifdef CONFIG_BIGNUM
-        else if (s->ctx->bignum_ext && !strcmp(str, "use math")) {
-            s->cur_func->js_mode |= JS_MODE_MATH;
-        }
-#endif
     }
     return js_parse_seek_token(s, &pos);
 }
 
+/* return TRUE if the keyword is forbidden only in strict mode */
+static BOOL is_strict_future_keyword(JSAtom atom)
+{
+    return (atom >= JS_ATOM_LAST_KEYWORD + 1 && atom <= JS_ATOM_LAST_STRICT_KEYWORD);
+}
+
 static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
                                          JSAtom func_name)
 {
@@ -32477,13 +34980,15 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
         if (!fd->has_simple_parameter_list && fd->has_use_strict) {
             return js_parse_error(s, "\"use strict\" not allowed in function with default or destructuring parameter");
         }
-        if (func_name == JS_ATOM_eval || func_name == JS_ATOM_arguments) {
+        if (func_name == JS_ATOM_eval || func_name == JS_ATOM_arguments ||
+            is_strict_future_keyword(func_name)) {
             return js_parse_error(s, "invalid function name in strict code");
         }
         for (idx = 0; idx < fd->arg_count; idx++) {
             name = fd->args[idx].var_name;
 
-            if (name == JS_ATOM_eval || name == JS_ATOM_arguments) {
+            if (name == JS_ATOM_eval || name == JS_ATOM_arguments ||
+                is_strict_future_keyword(name)) {
                 return js_parse_error(s, "invalid argument name in strict code");
             }
         }
@@ -32521,15 +35026,16 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
 static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
 {
     JSFunctionDef *fd;
-    
+
     fd = js_new_function_def(s->ctx, s->cur_func, FALSE, FALSE,
-                             s->filename, 0);
+                             s->filename, s->buf_start,
+                             &s->get_line_col_cache);
     if (!fd)
         return NULL;
     fd->func_name = JS_ATOM_NULL;
     fd->has_prototype = FALSE;
     fd->has_home_object = TRUE;
-    
+
     fd->has_arguments_binding = FALSE;
     fd->has_this_binding = TRUE;
     fd->is_derived_class_constructor = FALSE;
@@ -32537,7 +35043,7 @@ static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
     fd->super_call_allowed = FALSE;
     fd->super_allowed = fd->has_home_object;
     fd->arguments_allowed = FALSE;
-    
+
     fd->func_kind = JS_FUNC_NORMAL;
     fd->func_type = JS_PARSE_FUNC_METHOD;
     return fd;
@@ -32550,7 +35056,6 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                                                JSFunctionKindEnum func_kind,
                                                JSAtom func_name,
                                                const uint8_t *ptr,
-                                               int function_line_num,
                                                JSParseExportEnum export_flag,
                                                JSFunctionDef **pfd)
 {
@@ -32588,8 +35093,9 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                  func_type == JS_PARSE_FUNC_EXPR &&
                  (func_kind & JS_FUNC_GENERATOR)) ||
                 (s->token.u.ident.atom == JS_ATOM_await &&
-                 func_type == JS_PARSE_FUNC_EXPR &&
-                 (func_kind & JS_FUNC_ASYNC))) {
+                 ((func_type == JS_PARSE_FUNC_EXPR &&
+                   (func_kind & JS_FUNC_ASYNC)) ||
+                  func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT))) {
                 return js_parse_error_reserved_identifier(s);
             }
         }
@@ -32664,7 +35170,8 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     }
 
     fd = js_new_function_def(ctx, fd, FALSE, is_expr,
-                             s->filename, function_line_num);
+                             s->filename, ptr,
+                             &s->get_line_col_cache);
     if (!fd) {
         JS_FreeAtom(ctx, func_name);
         return -1;
@@ -32683,7 +35190,8 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                            func_type == JS_PARSE_FUNC_SETTER ||
                            func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR ||
                            func_type == JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR);
-    fd->has_arguments_binding = (func_type != JS_PARSE_FUNC_ARROW);
+    fd->has_arguments_binding = (func_type != JS_PARSE_FUNC_ARROW &&
+                                 func_type != JS_PARSE_FUNC_CLASS_STATIC_INIT);
     fd->has_this_binding = fd->has_arguments_binding;
     fd->is_derived_class_constructor = (func_type == JS_PARSE_FUNC_DERIVED_CLASS_CONSTRUCTOR);
     if (func_type == JS_PARSE_FUNC_ARROW) {
@@ -32691,6 +35199,11 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         fd->super_call_allowed = fd->parent->super_call_allowed;
         fd->super_allowed = fd->parent->super_allowed;
         fd->arguments_allowed = fd->parent->arguments_allowed;
+    } else if (func_type == JS_PARSE_FUNC_CLASS_STATIC_INIT) {
+        fd->new_target_allowed = TRUE; // although new.target === undefined
+        fd->super_call_allowed = FALSE;
+        fd->super_allowed = TRUE;
+        fd->arguments_allowed = FALSE;
     } else {
         fd->new_target_allowed = TRUE;
         fd->super_call_allowed = fd->is_derived_class_constructor;
@@ -32713,7 +35226,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     if (func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
         emit_class_field_init(s);
     }
-    
+
     /* parse arguments */
     fd->has_simple_parameter_list = TRUE;
     fd->has_parameter_expressions = FALSE;
@@ -32728,7 +35241,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         if (add_arg(ctx, fd, name) < 0)
             goto fail;
         fd->defined_arg_count = 1;
-    } else {
+    } else if (func_type != JS_PARSE_FUNC_CLASS_STATIC_INIT) {
         if (s->token.val == '(') {
             int skip_bits;
             /* if there is an '=' inside the parameter list, we
@@ -32748,13 +35261,15 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             if (push_scope(s) < 0)
                 return -1;
         }
-        
+
         while (s->token.val != ')') {
             JSAtom name;
             BOOL rest = FALSE;
             int idx, has_initializer;
 
             if (s->token.val == TOK_ELLIPSIS) {
+                if (func_type == JS_PARSE_FUNC_SETTER)
+                    goto fail_accessor;
                 fd->has_simple_parameter_list = FALSE;
                 rest = TRUE;
                 if (next_token(s))
@@ -32771,7 +35286,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     emit_op(s, OP_get_arg);
                     emit_u16(s, idx);
                 }
-                has_initializer = js_parse_destructuring_element(s, fd->has_parameter_expressions ? TOK_LET : TOK_VAR, 1, TRUE, -1, TRUE);
+                has_initializer = js_parse_destructuring_element(s, fd->has_parameter_expressions ? TOK_LET : TOK_VAR, 1, TRUE, -1, TRUE, FALSE);
                 if (has_initializer < 0)
                     goto fail;
                 if (has_initializer)
@@ -32789,6 +35304,8 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     goto fail;
                 }
                 if (fd->has_parameter_expressions) {
+                    if (js_parse_check_duplicate_parameter(s, name))
+                        goto fail;
                     if (define_var(s, fd, name, JS_VAR_DEF_LET) < 0)
                         goto fail;
                 }
@@ -32813,7 +35330,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     has_opt_arg = TRUE;
                 } else if (s->token.val == '=') {
                     int label;
-                    
+
                     fd->has_simple_parameter_list = FALSE;
                     has_opt_arg = TRUE;
 
@@ -32866,6 +35383,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         }
         if ((func_type == JS_PARSE_FUNC_GETTER && fd->arg_count != 0) ||
             (func_type == JS_PARSE_FUNC_SETTER && fd->arg_count != 1)) {
+        fail_accessor:
             js_parse_error(s, "invalid number of arguments for getter or setter");
             goto fail;
         }
@@ -32896,7 +35414,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             }
             idx = vd->scope_next;
         }
-        
+
         /* the argument scope has no parent, hence we don't use pop_scope(s) */
         emit_op(s, OP_leave_scope);
         emit_u16(s, fd->scope_level);
@@ -32905,7 +35423,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         fd->scope_level = 0;
         fd->scope_first = fd->scopes[fd->scope_level].first;
     }
-    
+
     if (next_token(s))
         goto fail;
 
@@ -32920,7 +35438,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     push_scope(s);  /* enter body scope */
     fd->body_scope = fd->scope_level;
 
-    if (s->token.val == TOK_ARROW) {
+    if (s->token.val == TOK_ARROW && func_type == JS_PARSE_FUNC_ARROW) {
         if (next_token(s))
             goto fail;
 
@@ -32936,7 +35454,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
             else
                 emit_op(s, OP_return);
 
-            if (!(fd->js_mode & JS_MODE_STRIP)) {
+            if (!fd->strip_source) {
                 /* save the function source code */
                 /* the end of the function source code is after the last
                    token of the function source stored into s->last_ptr */
@@ -32949,8 +35467,10 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         }
     }
 
-    if (js_parse_expect(s, '{'))
-        goto fail;
+    if (func_type != JS_PARSE_FUNC_CLASS_STATIC_INIT) {
+        if (js_parse_expect(s, '{'))
+            goto fail;
+    }
 
     if (js_parse_directives(s))
         goto fail;
@@ -32963,7 +35483,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
         if (js_parse_source_element(s))
             goto fail;
     }
-    if (!(fd->js_mode & JS_MODE_STRIP)) {
+    if (!fd->strip_source) {
         /* save the function source code */
         fd->source_len = s->buf_ptr - ptr;
         fd->source = js_strndup(ctx, (const char *)ptr, fd->source_len);
@@ -32980,9 +35500,15 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     if (js_is_live_code(s)) {
         emit_return(s, FALSE);
     }
-done:
+ done:
     s->cur_func = fd->parent;
 
+    /* Reparse identifiers after the function is terminated so that
+       the token is parsed in the englobing function. It could be done
+       by just using next_token() here for normal functions, but it is
+       necessary for arrow functions with an expression body. */
+    reparse_ident_token(s);
+
     /* create the function object */
     {
         int idx;
@@ -33019,7 +35545,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     /* it is considered as defined at the top level
                        (needed for annex B.3.3.4 and B.3.3.5
                        checks) */
-                    hf->scope_level = 0; 
+                    hf->scope_level = 0;
                     hf->force_init = ((s->cur_func->js_mode & JS_MODE_STRICT) != 0);
                     /* store directly into global var, bypass lexical scope */
                     emit_op(s, OP_dup);
@@ -33097,12 +35623,10 @@ static __exception int js_parse_function_decl(JSParseState *s,
                                               JSParseFunctionEnum func_type,
                                               JSFunctionKindEnum func_kind,
                                               JSAtom func_name,
-                                              const uint8_t *ptr,
-                                              int function_line_num)
+                                              const uint8_t *ptr)
 {
     return js_parse_function_decl2(s, func_type, func_kind, func_name, ptr,
-                                   function_line_num, JS_PARSE_EXPORT_NONE,
-                                   NULL);
+                                   JS_PARSE_EXPORT_NONE, NULL);
 }
 
 static __exception int js_parse_program(JSParseState *s)
@@ -33134,12 +35658,24 @@ static __exception int js_parse_program(JSParseState *s)
 
     if (!s->is_module) {
         /* return the value of the hidden variable eval_ret_idx  */
-        emit_op(s, OP_get_loc);
-        emit_u16(s, fd->eval_ret_idx);
+        if (fd->func_kind == JS_FUNC_ASYNC) {
+            /* wrap the return value in an object so that promises can
+               be safely returned */
+            emit_op(s, OP_object);
+            emit_op(s, OP_dup);
 
-        emit_op(s, OP_return);
+            emit_op(s, OP_get_loc);
+            emit_u16(s, fd->eval_ret_idx);
+
+            emit_op(s, OP_put_field);
+            emit_atom(s, JS_ATOM_value);
+        } else {
+            emit_op(s, OP_get_loc);
+            emit_u16(s, fd->eval_ret_idx);
+        }
+        emit_return(s, TRUE);
     } else {
-        emit_op(s, OP_return_undef);
+        emit_return(s, FALSE);
     }
 
     return 0;
@@ -33152,11 +35688,15 @@ static void js_parse_init(JSContext *ctx, JSParseState *s,
     memset(s, 0, sizeof(*s));
     s->ctx = ctx;
     s->filename = filename;
-    s->line_num = 1;
-    s->buf_ptr = (const uint8_t *)input;
+    s->buf_start = s->buf_ptr = (const uint8_t *)input;
     s->buf_end = s->buf_ptr + input_len;
     s->token.val = ' ';
-    s->token.line_num = 1;
+    s->token.ptr = s->buf_ptr;
+
+    s->get_line_col_cache.ptr = s->buf_start;
+    s->get_line_col_cache.buf_start = s->buf_start;
+    s->get_line_col_cache.line_num = 0;
+    s->get_line_col_cache.col_num = 0;
 }
 
 static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
@@ -33182,7 +35722,6 @@ static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
         ret_val = js_evaluate_module(ctx, m);
         if (JS_IsException(ret_val)) {
         fail:
-            js_free_modules(ctx, JS_FREE_MODULE_NOT_EVALUATED);
             return JS_EXCEPTION;
         }
     } else {
@@ -33197,31 +35736,6 @@ JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj)
     return JS_EvalFunctionInternal(ctx, fun_obj, ctx->global_obj, NULL, NULL);
 }
 
-static void skip_shebang(JSParseState *s)
-{
-    const uint8_t *p = s->buf_ptr;
-    int c;
-
-    if (p[0] == '#' && p[1] == '!') {
-        p += 2;
-        while (p < s->buf_end) {
-            if (*p == '\n' || *p == '\r') {
-                break;
-            } else if (*p >= 0x80) {
-                c = unicode_from_utf8(p, UTF8_CHAR_LEN_MAX, &p);
-                if (c == CP_LS || c == CP_PS) {
-                    break;
-                } else if (c == -1) {
-                    p++; /* skip invalid UTF-8 */
-                }
-            } else {
-                p++;
-            }
-        }
-        s->buf_ptr = p;
-    }
-}
-
 /* 'input' must be zero terminated i.e. input[input_len] = '\0'. */
 static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                  const char *input, size_t input_len,
@@ -33237,7 +35751,7 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
     JSModuleDef *m;
 
     js_parse_init(ctx, s, input, input_len, filename);
-    skip_shebang(s);
+    skip_shebang(&s->buf_ptr, s->buf_end);
 
     eval_type = flags & JS_EVAL_TYPE_MASK;
     m = NULL;
@@ -33258,8 +35772,6 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
         js_mode = 0;
         if (flags & JS_EVAL_FLAG_STRICT)
             js_mode |= JS_MODE_STRICT;
-        if (flags & JS_EVAL_FLAG_STRIP)
-            js_mode |= JS_MODE_STRIP;
         if (eval_type == JS_EVAL_TYPE_MODULE) {
             JSAtom module_name = JS_NewAtom(ctx, filename);
             if (module_name == JS_ATOM_NULL)
@@ -33270,13 +35782,13 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
             js_mode |= JS_MODE_STRICT;
         }
     }
-    fd = js_new_function_def(ctx, NULL, TRUE, FALSE, filename, 1);
+    fd = js_new_function_def(ctx, NULL, TRUE, FALSE, filename,
+                             s->buf_start, &s->get_line_col_cache);
     if (!fd)
         goto fail1;
     s->cur_func = fd;
     fd->eval_type = eval_type;
     fd->has_this_binding = (eval_type != JS_EVAL_TYPE_DIRECT);
-    fd->backtrace_barrier = ((flags & JS_EVAL_FLAG_BACKTRACE_BARRIER) != 0);
     if (eval_type == JS_EVAL_TYPE_DIRECT) {
         fd->new_target_allowed = b->new_target_allowed;
         fd->super_call_allowed = b->super_call_allowed;
@@ -33295,12 +35807,16 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
             goto fail;
     }
     fd->module = m;
+    if (m != NULL || (flags & JS_EVAL_FLAG_ASYNC)) {
+        fd->in_function_body = TRUE;
+        fd->func_kind = JS_FUNC_ASYNC;
+    }
     s->is_module = (m != NULL);
     s->allow_html_comments = !s->is_module;
 
     push_scope(s); /* body scope */
     fd->body_scope = fd->scope_level;
-    
+
     err = js_parse_program(s);
     if (err) {
     fail:
@@ -33309,6 +35825,9 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
         goto fail1;
     }
 
+    if (m != NULL)
+        m->has_tla = fd->has_await;
+
     /* create the function object and all the enclosed functions */
     fun_obj = js_create_function(ctx, fd);
     if (JS_IsException(fun_obj))
@@ -33318,7 +35837,7 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
         m->func_obj = fun_obj;
         if (js_resolve_module(ctx, m) < 0)
             goto fail1;
-        fun_obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+        fun_obj = JS_NewModuleValue(ctx, m);
     }
     if (flags & JS_EVAL_FLAG_COMPILE_ONLY) {
         ret_val = fun_obj;
@@ -33329,7 +35848,7 @@ static JSValue __JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
  fail1:
     /* XXX: should free all the unresolved dependencies */
     if (m)
-        js_free_module_def(ctx, m);
+        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
     return JS_EXCEPTION;
 }
 
@@ -33338,11 +35857,22 @@ static JSValue JS_EvalInternal(JSContext *ctx, JSValueConst this_obj,
                                const char *input, size_t input_len,
                                const char *filename, int flags, int scope_idx)
 {
+    BOOL backtrace_barrier = ((flags & JS_EVAL_FLAG_BACKTRACE_BARRIER) != 0);
+    int saved_js_mode = 0;
+    JSValue ret;
+    
     if (unlikely(!ctx->eval_internal)) {
         return JS_ThrowTypeError(ctx, "eval is not supported");
     }
-    return ctx->eval_internal(ctx, this_obj, input, input_len, filename,
-                              flags, scope_idx);
+    if (backtrace_barrier && ctx->rt->current_stack_frame) {
+        saved_js_mode = ctx->rt->current_stack_frame->js_mode;
+        ctx->rt->current_stack_frame->js_mode |= JS_MODE_BACKTRACE_BARRIER;
+    }
+    ret = ctx->eval_internal(ctx, this_obj, input, input_len, filename,
+                             flags, scope_idx);
+    if (backtrace_barrier && ctx->rt->current_stack_frame)
+        ctx->rt->current_stack_frame->js_mode = saved_js_mode;
+    return ret;
 }
 
 static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
@@ -33435,13 +35965,13 @@ static int js_object_list_resize_hash(JSContext *ctx, JSObjectList *s,
     js_free(ctx, s->hash_table);
     s->hash_table = new_hash_table;
     s->hash_size = new_hash_size;
-    
+
     for(i = 0; i < s->hash_size; i++) {
         s->hash_table[i] = -1;
     }
     for(i = 0; i < s->object_count; i++) {
         e = &s->object_tab[i];
-        h = js_object_list_get_hash(e->obj, s->hash_size); 
+        h = js_object_list_get_hash(e->obj, s->hash_size);
         e->hash_next = s->hash_table[h];
         s->hash_table[h] = i;
     }
@@ -33454,7 +35984,7 @@ static int js_object_list_add(JSContext *ctx, JSObjectList *s, JSObject *obj)
 {
     JSObjectListEntry *e;
     uint32_t h, new_hash_size;
-    
+
     if (js_resize_array(ctx, (void *)&s->object_tab,
                         sizeof(s->object_tab[0]),
                         &s->object_size, s->object_count + 1))
@@ -33467,7 +35997,7 @@ static int js_object_list_add(JSContext *ctx, JSObjectList *s, JSObject *obj)
             return -1;
     }
     e = &s->object_tab[s->object_count++];
-    h = js_object_list_get_hash(obj, s->hash_size); 
+    h = js_object_list_get_hash(obj, s->hash_size);
     e->obj = obj;
     e->hash_next = s->hash_table[h];
     s->hash_table[h] = s->object_count - 1;
@@ -33483,7 +36013,7 @@ static int js_object_list_find(JSContext *ctx, JSObjectList *s, JSObject *obj)
     /* must test empty size because there is no hash table */
     if (s->object_count == 0)
         return -1;
-    h = js_object_list_get_hash(obj, s->hash_size); 
+    h = js_object_list_get_hash(obj, s->hash_size);
     p = s->hash_table[h];
     while (p != -1) {
         e = &s->object_tab[p];
@@ -33514,8 +36044,6 @@ typedef enum BCTagEnum {
     BC_TAG_OBJECT,
     BC_TAG_ARRAY,
     BC_TAG_BIG_INT,
-    BC_TAG_BIG_FLOAT,
-    BC_TAG_BIG_DECIMAL,
     BC_TAG_TEMPLATE_OBJECT,
     BC_TAG_FUNCTION_BYTECODE,
     BC_TAG_MODULE,
@@ -33527,22 +36055,11 @@ typedef enum BCTagEnum {
     BC_TAG_OBJECT_REFERENCE,
 } BCTagEnum;
 
-#ifdef CONFIG_BIGNUM
-#define BC_BASE_VERSION 2
-#else
-#define BC_BASE_VERSION 1
-#endif
-#define BC_BE_VERSION 0x40
-#ifdef WORDS_BIGENDIAN
-#define BC_VERSION (BC_BASE_VERSION | BC_BE_VERSION)
-#else
-#define BC_VERSION BC_BASE_VERSION
-#endif
+#define BC_VERSION 5
 
 typedef struct BCWriterState {
     JSContext *ctx;
     DynBuf dbuf;
-    BOOL byte_swap : 8;
     BOOL allow_bytecode : 8;
     BOOL allow_sab : 8;
     BOOL allow_reference : 8;
@@ -33572,8 +36089,6 @@ static const char * const bc_tag_str[] = {
     "object",
     "array",
     "bigint",
-    "bigfloat",
-    "bigdecimal",
     "template",
     "function",
     "module",
@@ -33586,6 +36101,15 @@ static const char * const bc_tag_str[] = {
 };
 #endif
 
+static inline BOOL is_be(void)
+{
+    union {
+        uint16_t a;
+        uint8_t  b;
+    } u = {0x100};
+    return u.b;
+}
+
 static void bc_put_u8(BCWriterState *s, uint8_t v)
 {
     dbuf_putc(&s->dbuf, v);
@@ -33593,21 +36117,21 @@ static void bc_put_u8(BCWriterState *s, uint8_t v)
 
 static void bc_put_u16(BCWriterState *s, uint16_t v)
 {
-    if (s->byte_swap)
+    if (is_be())
         v = bswap16(v);
     dbuf_put_u16(&s->dbuf, v);
 }
 
 static __maybe_unused void bc_put_u32(BCWriterState *s, uint32_t v)
 {
-    if (s->byte_swap)
+    if (is_be())
         v = bswap32(v);
     dbuf_put_u32(&s->dbuf, v);
 }
 
 static void bc_put_u64(BCWriterState *s, uint64_t v)
 {
-    if (s->byte_swap)
+    if (is_be())
         v = bswap64(v);
     dbuf_put(&s->dbuf, (uint8_t *)&v, sizeof(v));
 }
@@ -33777,7 +36301,7 @@ static int JS_WriteFunctionBytecode(BCWriterState *s,
         pos += len;
     }
 
-    if (s->byte_swap)
+    if (is_be())
         bc_byte_swap(bc_buf, bc_len);
 
     dbuf_put(&s->dbuf, bc_buf, bc_len);
@@ -33801,138 +36325,50 @@ static void JS_WriteString(BCWriterState *s, JSString *p)
     }
 }
 
-static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
+static int JS_WriteBigInt(BCWriterState *s, JSValueConst obj)
 {
-    uint32_t tag, tag1;
-    int64_t e;
-    JSBigFloat *bf = JS_VALUE_GET_PTR(obj);
-    bf_t *a = &bf->num;
-    size_t len, i, n1, j;
-    limb_t v;
-
-    tag = JS_VALUE_GET_TAG(obj);
-    switch(tag) {
-    case JS_TAG_BIG_INT:
-        tag1 = BC_TAG_BIG_INT;
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        tag1 = BC_TAG_BIG_FLOAT;
-        break;
-    case JS_TAG_BIG_DECIMAL:
-        tag1 = BC_TAG_BIG_DECIMAL;
-        break;
-#endif        
-    default:
-        abort();
-    }
-    bc_put_u8(s, tag1);
+    JSBigIntBuf buf;
+    JSBigInt *p;
+    uint32_t len, i;
+    js_limb_t v, b;
+    int shift;
+    
+    bc_put_u8(s, BC_TAG_BIG_INT);
 
-    /* sign + exponent */
-    if (a->expn == BF_EXP_ZERO)
-        e = 0;
-    else if (a->expn == BF_EXP_INF)
-        e = 1;
-    else if (a->expn == BF_EXP_NAN)
-        e = 2;
-    else if (a->expn >= 0)
-        e = a->expn + 3;
+    if (JS_VALUE_GET_TAG(obj) == JS_TAG_SHORT_BIG_INT)
+        p = js_bigint_set_short(&buf, obj);
     else
-        e = a->expn;
-    e = (e << 1) | a->sign;
-    if (e < INT32_MIN || e > INT32_MAX) {
-        JS_ThrowInternalError(s->ctx, "bignum exponent is too large");
-        return -1;
+        p = JS_VALUE_GET_PTR(obj);
+    if (p->len == 1 && p->tab[0] == 0) {
+        /* zero case */
+        len = 0;
+    } else {
+        /* compute the length of the two's complement representation
+           in bytes */
+        len = p->len * (JS_LIMB_BITS / 8);
+        v = p->tab[p->len - 1];
+        shift = JS_LIMB_BITS - 8;
+        while (shift > 0) {
+            b = (v >> shift) & 0xff;
+            if (b != 0x00 && b != 0xff)
+                break;
+            if ((b & 1) != ((v >> (shift - 1)) & 1))
+                break;
+            shift -= 8;
+            len--;
+        }
     }
-    bc_put_sleb128(s, e);
-
-    /* mantissa */
-    if (a->len != 0) {
-        if (tag != JS_TAG_BIG_DECIMAL) {
-            i = 0;
-            while (i < a->len && a->tab[i] == 0)
-                i++;
-            assert(i < a->len);
-            v = a->tab[i];
-            n1 = sizeof(limb_t);
-            while ((v & 0xff) == 0) {
-                n1--;
-                v >>= 8;
-            }
-            i++;
-            len = (a->len - i) * sizeof(limb_t) + n1;
-            if (len > INT32_MAX) {
-                JS_ThrowInternalError(s->ctx, "bignum is too large");
-                return -1;
-            }
-            bc_put_leb128(s, len);
-            /* always saved in byte based little endian representation */
-            for(j = 0; j < n1; j++) {
-                dbuf_putc(&s->dbuf, v >> (j * 8));
-            }
-            for(; i < a->len; i++) {
-                limb_t v = a->tab[i];
-#if LIMB_BITS == 32
-#ifdef WORDS_BIGENDIAN
-                v = bswap32(v);
-#endif
-                dbuf_put_u32(&s->dbuf, v);
+    bc_put_leb128(s, len);
+    if (len > 0) {
+        for(i = 0; i < (len / (JS_LIMB_BITS / 8)); i++) {
+#if JS_LIMB_BITS == 32
+            bc_put_u32(s, p->tab[i]);
 #else
-#ifdef WORDS_BIGENDIAN
-                v = bswap64(v);
-#endif
-                dbuf_put_u64(&s->dbuf, v);
+            bc_put_u64(s, p->tab[i]);
 #endif
-            }
-        } else {
-            int bpos, d;
-            uint8_t v8;
-            size_t i0;
-            
-            /* little endian BCD */
-            i = 0;
-            while (i < a->len && a->tab[i] == 0)
-                i++;
-            assert(i < a->len);
-            len = a->len * LIMB_DIGITS;
-            v = a->tab[i];
-            j = 0;
-            while ((v % 10) == 0) {
-                j++;
-                v /= 10;
-            }
-            len -= j;
-            assert(len > 0);
-            if (len > INT32_MAX) {
-                JS_ThrowInternalError(s->ctx, "bignum is too large");
-                return -1;
-            }
-            bc_put_leb128(s, len);
-            
-            bpos = 0;
-            v8 = 0;
-            i0 = i;
-            for(; i < a->len; i++) {
-                if (i != i0) {
-                    v = a->tab[i];
-                    j = 0;
-                }
-                for(; j < LIMB_DIGITS; j++) {
-                    d = v % 10;
-                    v /= 10;
-                    if (bpos == 0) {
-                        v8 = d;
-                        bpos = 1;
-                    } else {
-                        dbuf_putc(&s->dbuf, v8 | (d << 4));
-                        bpos = 0;
-                    }
-                }
-            }
-            /* flush the last digit */
-            if (bpos) {
-                dbuf_putc(&s->dbuf, v8);
-            }
+        }
+        for(i = 0; i < len % (JS_LIMB_BITS / 8); i++) {
+            bc_put_u8(s, (p->tab[p->len - 1] >> (i * 8)) & 0xff);
         }
     }
     return 0;
@@ -33945,7 +36381,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     JSFunctionBytecode *b = JS_VALUE_GET_PTR(obj);
     uint32_t flags;
     int idx, i;
-    
+
     bc_put_u8(s, BC_TAG_FUNCTION_BYTECODE);
     flags = idx = 0;
     bc_set_flags(&flags, &idx, b->has_prototype, 1);
@@ -33958,12 +36394,12 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     bc_set_flags(&flags, &idx, b->super_allowed, 1);
     bc_set_flags(&flags, &idx, b->arguments_allowed, 1);
     bc_set_flags(&flags, &idx, b->has_debug, 1);
-    bc_set_flags(&flags, &idx, b->backtrace_barrier, 1);
+    bc_set_flags(&flags, &idx, b->is_direct_or_indirect_eval, 1);
     assert(idx <= 16);
     bc_put_u16(s, flags);
     bc_put_u8(s, b->js_mode);
     bc_put_atom(s, b->func_name);
-    
+
     bc_put_leb128(s, b->arg_count);
     bc_put_leb128(s, b->var_count);
     bc_put_leb128(s, b->defined_arg_count);
@@ -33990,7 +36426,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     } else {
         bc_put_leb128(s, 0);
     }
-    
+
     for(i = 0; i < b->closure_var_count; i++) {
         JSClosureVar *cv = &b->closure_var[i];
         bc_put_atom(s, cv->var_name);
@@ -34004,17 +36440,22 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
         assert(idx <= 8);
         bc_put_u8(s, flags);
     }
-    
+
     if (JS_WriteFunctionBytecode(s, b->byte_code_buf, b->byte_code_len))
         goto fail;
-    
+
     if (b->has_debug) {
         bc_put_atom(s, b->debug.filename);
-        bc_put_leb128(s, b->debug.line_num);
         bc_put_leb128(s, b->debug.pc2line_len);
         dbuf_put(&s->dbuf, b->debug.pc2line_buf, b->debug.pc2line_len);
+        if (b->debug.source) {
+            bc_put_leb128(s, b->debug.source_len);
+            dbuf_put(&s->dbuf, (uint8_t *)b->debug.source, b->debug.source_len);
+        } else {
+            bc_put_leb128(s, 0);
+        }
     }
-    
+
     for(i = 0; i < b->cpool_count; i++) {
         if (JS_WriteObjectRec(s, b->cpool[i]))
             goto fail;
@@ -34028,16 +36469,18 @@ static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
 {
     JSModuleDef *m = JS_VALUE_GET_PTR(obj);
     int i;
-    
+
     bc_put_u8(s, BC_TAG_MODULE);
     bc_put_atom(s, m->module_name);
-    
+
     bc_put_leb128(s, m->req_module_entries_count);
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         bc_put_atom(s, rme->module_name);
+        if (JS_WriteObjectRec(s, rme->attributes))
+            goto fail;
     }
-    
+
     bc_put_leb128(s, m->export_entries_count);
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
@@ -34050,21 +36493,24 @@ static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
         }
         bc_put_atom(s, me->export_name);
     }
-    
+
     bc_put_leb128(s, m->star_export_entries_count);
     for(i = 0; i < m->star_export_entries_count; i++) {
         JSStarExportEntry *se = &m->star_export_entries[i];
         bc_put_leb128(s, se->req_module_idx);
     }
-    
+
     bc_put_leb128(s, m->import_entries_count);
     for(i = 0; i < m->import_entries_count; i++) {
         JSImportEntry *mi = &m->import_entries[i];
         bc_put_leb128(s, mi->var_idx);
+        bc_put_u8(s, mi->is_star);
         bc_put_atom(s, mi->import_name);
         bc_put_leb128(s, mi->req_module_idx);
     }
-    
+
+    bc_put_u8(s, m->has_tla);
+
     if (JS_WriteObjectRec(s, m->func_obj))
         goto fail;
     return 0;
@@ -34079,7 +36525,7 @@ static int JS_WriteArray(BCWriterState *s, JSValueConst obj)
     JSValue val;
     int ret;
     BOOL is_template;
-    
+
     if (s->allow_bytecode && !p->extensible) {
         /* not extensible array: we consider it is a
            template when we are saving bytecode */
@@ -34237,6 +36683,16 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
             JS_WriteString(s, p);
         }
         break;
+    case JS_TAG_STRING_ROPE:
+        {
+            JSValue str;
+            str = JS_ToString(s->ctx, obj);
+            if (JS_IsException(str))
+                goto fail;
+            JS_WriteObjectRec(s, str);
+            JS_FreeValue(s->ctx, str);
+        }
+        break;
     case JS_TAG_FUNCTION_BYTECODE:
         if (!s->allow_bytecode)
             goto invalid_tag;
@@ -34253,7 +36709,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
         {
             JSObject *p = JS_VALUE_GET_OBJ(obj);
             int ret, idx;
-            
+
             if (s->allow_reference) {
                 idx = js_object_list_find(s->ctx, &s->object_list, p);
                 if (idx >= 0) {
@@ -34294,10 +36750,6 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
             case JS_CLASS_STRING:
             case JS_CLASS_BOOLEAN:
             case JS_CLASS_BIG_INT:
-#ifdef CONFIG_BIGNUM
-            case JS_CLASS_BIG_FLOAT:
-            case JS_CLASS_BIG_DECIMAL:
-#endif
                 bc_put_u8(s, BC_TAG_OBJECT_VALUE);
                 ret = JS_WriteObjectRec(s, p->u.object_data);
                 break;
@@ -34316,12 +36768,9 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
                 goto fail;
         }
         break;
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-    case JS_TAG_BIG_DECIMAL:
-#endif
-        if (JS_WriteBigNum(s, obj))
+        if (JS_WriteBigInt(s, obj))
             goto fail;
         break;
     default:
@@ -34341,15 +36790,10 @@ static int JS_WriteObjectAtoms(BCWriterState *s)
     JSRuntime *rt = s->ctx->rt;
     DynBuf dbuf1;
     int i, atoms_size;
-    uint8_t version;
 
     dbuf1 = s->dbuf;
     js_dbuf_init(s->ctx, &s->dbuf);
-
-    version = BC_VERSION;
-    if (s->byte_swap)
-        version ^= BC_BE_VERSION;
-    bc_put_u8(s, version);
+    bc_put_u8(s, BC_VERSION);
 
     bc_put_leb128(s, s->idx_to_atom_count);
     for(i = 0; i < s->idx_to_atom_count; i++) {
@@ -34382,8 +36826,6 @@ uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
 
     memset(s, 0, sizeof(*s));
     s->ctx = ctx;
-    /* XXX: byte swapped output is untested */
-    s->byte_swap = ((flags & JS_WRITE_OBJ_BSWAP) != 0);
     s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
     s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
     s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
@@ -34394,7 +36836,7 @@ uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
         s->first_atom = 1;
     js_dbuf_init(ctx, &s->dbuf);
     js_object_list_init(&s->object_list);
-    
+
     if (JS_WriteObjectRec(s, obj))
         goto fail;
     if (JS_WriteObjectAtoms(s))
@@ -34442,7 +36884,7 @@ typedef struct BCReaderState {
     JSObject **objects;
     int objects_count;
     int objects_size;
-    
+
 #ifdef DUMP_READ_OBJECT
     const uint8_t *ptr_last;
     int level;
@@ -34504,33 +36946,45 @@ static int bc_get_u8(BCReaderState *s, uint8_t *pval)
 
 static int bc_get_u16(BCReaderState *s, uint16_t *pval)
 {
+    uint16_t v;
     if (unlikely(s->buf_end - s->ptr < 2)) {
         *pval = 0; /* avoid warning */
         return bc_read_error_end(s);
     }
-    *pval = get_u16(s->ptr);
+    v = get_u16(s->ptr);
+    if (is_be())
+        v = bswap16(v);
+    *pval = v;
     s->ptr += 2;
     return 0;
 }
 
 static __maybe_unused int bc_get_u32(BCReaderState *s, uint32_t *pval)
 {
+    uint32_t v;
     if (unlikely(s->buf_end - s->ptr < 4)) {
         *pval = 0; /* avoid warning */
         return bc_read_error_end(s);
     }
-    *pval = get_u32(s->ptr);
+    v = get_u32(s->ptr);
+    if (is_be())
+        v = bswap32(v);
+    *pval = v;
     s->ptr += 4;
     return 0;
 }
 
 static int bc_get_u64(BCReaderState *s, uint64_t *pval)
 {
+    uint64_t v;
     if (unlikely(s->buf_end - s->ptr < 8)) {
         *pval = 0; /* avoid warning */
         return bc_read_error_end(s);
     }
-    *pval = get_u64(s->ptr);
+    v = get_u64(s->ptr);
+    if (is_be())
+        v = bswap64(v);
+    *pval = v;
     s->ptr += 8;
     return 0;
 }
@@ -34629,6 +37083,10 @@ static JSString *JS_ReadString(BCReaderState *s)
         return NULL;
     is_wide_char = len & 1;
     len >>= 1;
+    if (len > JS_STRING_LEN_MAX) {
+        JS_ThrowInternalError(s->ctx, "string too long");
+        return NULL;
+    }
     p = js_alloc_string(s->ctx, len, is_wide_char);
     if (!p) {
         s->error_state = -1;
@@ -34642,7 +37100,13 @@ static JSString *JS_ReadString(BCReaderState *s)
     }
     memcpy(p->u.str8, s->ptr, size);
     s->ptr += size;
-    if (!is_wide_char) {
+    if (is_wide_char) {
+        if (is_be()) {
+            uint32_t i;
+            for (i = 0; i < len; i++)
+                p->u.str16[i] = bswap16(p->u.str16[i]);
+        }
+    } else {
         p->u.str8[size] = '\0'; /* add the trailing zero for 8 bit strings */
     }
 #ifdef DUMP_READ_OBJECT
@@ -34681,6 +37145,9 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     }
     b->byte_code_buf = bc_buf;
 
+    if (is_be())
+        bc_byte_swap(bc_buf, bc_len);
+
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
@@ -34715,135 +37182,53 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     return 0;
 }
 
-static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
+static JSValue JS_ReadBigInt(BCReaderState *s)
 {
     JSValue obj = JS_UNDEFINED;
+    uint32_t len, i, n;
+    JSBigInt *p;
+    js_limb_t v;
     uint8_t v8;
-    int32_t e;
-    uint32_t len;
-    limb_t l, i, n, j;
-    JSBigFloat *p;
-    limb_t v;
-    bf_t *a;
-    int bpos, d;
     
-    p = js_new_bf(s->ctx);
-    if (!p)
+    if (bc_get_leb128(s, &len))
         goto fail;
-    switch(tag) {
-    case BC_TAG_BIG_INT:
-        obj = JS_MKPTR(JS_TAG_BIG_INT, p);
-        break;
-#ifdef CONFIG_BIGNUM
-    case BC_TAG_BIG_FLOAT:
-        obj = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
-        break;
-    case BC_TAG_BIG_DECIMAL:
-        obj = JS_MKPTR(JS_TAG_BIG_DECIMAL, p);
-        break;
-#endif        
-    default:
-        abort();
+    bc_read_trace(s, "len=%" PRId64 "\n", (int64_t)len);
+    if (len == 0) {
+        /* zero case */
+        bc_read_trace(s, "}\n");
+        return __JS_NewShortBigInt(s->ctx, 0);
     }
-
-    /* sign + exponent */
-    if (bc_get_sleb128(s, &e))
+    p = js_bigint_new(s->ctx, (len - 1) / (JS_LIMB_BITS / 8) + 1);
+    if (!p)
         goto fail;
-
-    a = &p->num;
-    a->sign = e & 1;
-    e >>= 1;
-    if (e == 0)
-        a->expn = BF_EXP_ZERO;
-    else if (e == 1)
-        a->expn = BF_EXP_INF;
-    else if (e == 2)
-        a->expn = BF_EXP_NAN;
-    else if (e >= 3)
-        a->expn = e - 3;
-    else
-        a->expn = e;
-
-    /* mantissa */
-    if (a->expn != BF_EXP_ZERO &&
-        a->expn != BF_EXP_INF &&
-        a->expn != BF_EXP_NAN) {
-        if (bc_get_leb128(s, &len))
-            goto fail;
-        bc_read_trace(s, "len=%" PRId64 "\n", (int64_t)len);
-        if (len == 0) {
-            JS_ThrowInternalError(s->ctx, "invalid bignum length");
-            goto fail;
-        }
-        if (tag != BC_TAG_BIG_DECIMAL)
-            l = (len + sizeof(limb_t) - 1) / sizeof(limb_t);
-        else
-            l = (len + LIMB_DIGITS - 1) / LIMB_DIGITS;
-        if (bf_resize(a, l)) {
-            JS_ThrowOutOfMemory(s->ctx);
+    for(i = 0; i < len / (JS_LIMB_BITS / 8); i++) {
+#if JS_LIMB_BITS == 32
+        if (bc_get_u32(s, &v))
             goto fail;
-        }
-        if (tag != BC_TAG_BIG_DECIMAL) {
-            n = len & (sizeof(limb_t) - 1);
-            if (n != 0) {
-                v = 0;
-                for(i = 0; i < n; i++) {
-                    if (bc_get_u8(s, &v8))
-                        goto fail;
-                    v |= (limb_t)v8 << ((sizeof(limb_t) - n + i) * 8);
-                }
-                a->tab[0] = v;
-                i = 1;
-            } else {
-                i = 0;
-            }
-            for(; i < l; i++) {
-#if LIMB_BITS == 32
-                if (bc_get_u32(s, &v))
-                    goto fail;
-#ifdef WORDS_BIGENDIAN
-                v = bswap32(v);
-#endif
 #else
-                if (bc_get_u64(s, &v))
-                    goto fail;
-#ifdef WORDS_BIGENDIAN
-                v = bswap64(v);
-#endif
+        if (bc_get_u64(s, &v))
+            goto fail;
 #endif
-                a->tab[i] = v;
-            }
-        } else {
-            bpos = 0;
-            for(i = 0; i < l; i++) {
-                if (i == 0 && (n = len % LIMB_DIGITS) != 0) {
-                    j = LIMB_DIGITS - n;
-                } else {
-                    j = 0;
-                }
-                v = 0;
-                for(; j < LIMB_DIGITS; j++) {
-                    if (bpos == 0) {
-                        if (bc_get_u8(s, &v8))
-                            goto fail;
-                        d = v8 & 0xf;
-                        bpos = 1;
-                    } else {
-                        d = v8 >> 4;
-                        bpos = 0;
-                    }
-                    if (d >= 10) {
-                        JS_ThrowInternalError(s->ctx, "invalid digit");
-                        goto fail;
-                    }
-                    v += mp_pow_dec[j] * d;
-                }
-                a->tab[i] = v;
-            }
+        p->tab[i] = v;
+    }
+    n = len % (JS_LIMB_BITS / 8);
+    if (n != 0) {
+        int shift;
+        v = 0;
+        for(i = 0; i < n; i++) {
+            if (bc_get_u8(s, &v8))
+                goto fail;
+            v |= (js_limb_t)v8 << (i * 8);
+        }
+        shift = JS_LIMB_BITS - n * 8;
+        /* extend the sign */
+        if (shift != 0) {
+            v = (js_slimb_t)(v << shift) >> shift;
         }
+        p->tab[p->len - 1] = v;
     }
     bc_read_trace(s, "}\n");
-    return obj;
+    return JS_CompactBigInt(s->ctx, p);
  fail:
     JS_FreeValue(s->ctx, obj);
     return JS_EXCEPTION;
@@ -34896,7 +37281,7 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     bc.super_allowed = bc_get_flags(v16, &idx, 1);
     bc.arguments_allowed = bc_get_flags(v16, &idx, 1);
     bc.has_debug = bc_get_flags(v16, &idx, 1);
-    bc.backtrace_barrier = bc_get_flags(v16, &idx, 1);
+    bc.is_direct_or_indirect_eval = bc_get_flags(v16, &idx, 1);
     bc.read_only_bytecode = s->is_rom_data;
     if (bc_get_u8(s, &v8))
         goto fail;
@@ -34939,7 +37324,7 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     b = js_mallocz(ctx, function_size);
     if (!b)
         return JS_EXCEPTION;
-            
+
     memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
     b->header.ref_count = 1;
     if (local_count != 0) {
@@ -34951,9 +37336,9 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     if (b->cpool_count != 0) {
         b->cpool = (void *)((uint8_t*)b + cpool_offset);
     }
-    
+
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-            
+
     obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
 
 #ifdef DUMP_READ_OBJECT
@@ -35024,8 +37409,9 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
         bc_read_trace(s, "debug {\n");
         if (bc_get_atom(s, &b->debug.filename))
             goto fail;
-        if (bc_get_leb128_int(s, &b->debug.line_num))
-            goto fail;
+#ifdef DUMP_READ_OBJECT
+        bc_read_trace(s, "filename: "); print_atom(s->ctx, b->debug.filename); printf("\n");
+#endif
         if (bc_get_leb128_int(s, &b->debug.pc2line_len))
             goto fail;
         if (b->debug.pc2line_len) {
@@ -35035,9 +37421,16 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
             if (bc_get_buf(s, b->debug.pc2line_buf, b->debug.pc2line_len))
                 goto fail;
         }
-#ifdef DUMP_READ_OBJECT
-        bc_read_trace(s, "filename: "); print_atom(s->ctx, b->debug.filename); printf("\n");
-#endif
+        if (bc_get_leb128_int(s, &b->debug.source_len))
+            goto fail;
+        if (b->debug.source_len) {
+            bc_read_trace(s, "source: %d bytes\n", b->source_len);
+            b->debug.source = js_mallocz(ctx, b->debug.source_len);
+            if (!b->debug.source)
+                goto fail;
+            if (bc_get_buf(s, (uint8_t *)b->debug.source, b->debug.source_len))
+                goto fail;
+        }
         bc_read_trace(s, "}\n");
     }
     if (b->cpool_count != 0) {
@@ -35066,7 +37459,7 @@ static JSValue JS_ReadModule(BCReaderState *s)
     JSAtom module_name;
     int i;
     uint8_t v8;
-    
+
     if (bc_get_atom(s, &module_name))
         goto fail;
 #ifdef DUMP_READ_OBJECT
@@ -35075,7 +37468,7 @@ static JSValue JS_ReadModule(BCReaderState *s)
     m = js_new_module_def(ctx, module_name);
     if (!m)
         goto fail;
-    obj = JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
+    obj = JS_NewModuleValue(ctx, m);
     if (bc_get_leb128_int(s, &m->req_module_entries_count))
         goto fail;
     if (m->req_module_entries_count != 0) {
@@ -35085,8 +37478,13 @@ static JSValue JS_ReadModule(BCReaderState *s)
             goto fail;
         for(i = 0; i < m->req_module_entries_count; i++) {
             JSReqModuleEntry *rme = &m->req_module_entries[i];
+            JSValue val;
             if (bc_get_atom(s, &rme->module_name))
                 goto fail;
+            val = JS_ReadObjectRec(s);
+            if (JS_IsException(val))
+                goto fail;
+            rme->attributes = val;
         }
     }
 
@@ -35139,8 +37537,12 @@ static JSValue JS_ReadModule(BCReaderState *s)
             goto fail;
         for(i = 0; i < m->import_entries_count; i++) {
             JSImportEntry *mi = &m->import_entries[i];
+            uint8_t v8;
             if (bc_get_leb128_int(s, &mi->var_idx))
                 goto fail;
+            if (bc_get_u8(s, &v8))
+                goto fail;
+            mi->is_star = (v8 != 0);
             if (bc_get_atom(s, &mi->import_name))
                 goto fail;
             if (bc_get_leb128_int(s, &mi->req_module_idx))
@@ -35148,13 +37550,17 @@ static JSValue JS_ReadModule(BCReaderState *s)
         }
     }
 
+    if (bc_get_u8(s, &v8))
+        goto fail;
+    m->has_tla = (v8 != 0);
+
     m->func_obj = JS_ReadObjectRec(s);
     if (JS_IsException(m->func_obj))
         goto fail;
     return obj;
  fail:
     if (m) {
-        js_free_module_def(ctx, m);
+        JS_FreeValue(ctx, JS_MKPTR(JS_TAG_MODULE, m));
     }
     return JS_EXCEPTION;
 }
@@ -35167,7 +37573,7 @@ static JSValue JS_ReadObjectTag(BCReaderState *s)
     JSAtom atom;
     JSValue val;
     int ret;
-    
+
     obj = JS_NewObject(ctx);
     if (BC_add_object_ref(s, obj))
         goto fail;
@@ -35247,7 +37653,7 @@ static JSValue JS_ReadTypedArray(BCReaderState *s)
     uint8_t array_tag;
     JSValueConst args[3];
     uint32_t offset, len, idx;
-    
+
     if (bc_get_u8(s, &array_tag))
         return JS_EXCEPTION;
     if (array_tag >= JS_TYPED_ARRAY_COUNT)
@@ -35292,7 +37698,7 @@ static JSValue JS_ReadArrayBuffer(BCReaderState *s)
     JSContext *ctx = s->ctx;
     uint32_t byte_length;
     JSValue obj;
-    
+
     if (bc_get_leb128(s, &byte_length))
         return JS_EXCEPTION;
     if (unlikely(s->buf_end - s->ptr < byte_length)) {
@@ -35318,7 +37724,7 @@ static JSValue JS_ReadSharedArrayBuffer(BCReaderState *s)
     uint8_t *data_ptr;
     JSValue obj;
     uint64_t u64;
-    
+
     if (bc_get_leb128(s, &byte_length))
         return JS_EXCEPTION;
     if (bc_get_u64(s, &u64))
@@ -35473,11 +37879,7 @@ static JSValue JS_ReadObjectRec(BCReaderState *s)
         obj = JS_ReadObjectValue(s);
         break;
     case BC_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-    case BC_TAG_BIG_FLOAT:
-    case BC_TAG_BIG_DECIMAL:
-#endif
-        obj = JS_ReadBigNum(s, tag);
+        obj = JS_ReadBigInt(s);
         break;
     case BC_TAG_OBJECT_REFERENCE:
         {
@@ -35512,7 +37914,6 @@ static int JS_ReadObjectAtoms(BCReaderState *s)
 
     if (bc_get_u8(s, &v8))
         return -1;
-    /* XXX: could support byte swapped input */
     if (v8 != BC_VERSION) {
         JS_ThrowSyntaxError(s->ctx, "invalid version (%d expected=%d)",
                             v8, BC_VERSION);
@@ -35751,17 +38152,22 @@ static int JS_InstantiateFunctionListItem(JSContext *ctx, JSValueConst obj,
     return 0;
 }
 
-void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
-                                const JSCFunctionListEntry *tab, int len)
+int JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
+                               const JSCFunctionListEntry *tab, int len)
 {
-    int i;
+    int i, ret;
 
     for (i = 0; i < len; i++) {
         const JSCFunctionListEntry *e = &tab[i];
         JSAtom atom = find_atom(ctx, e->name);
-        JS_InstantiateFunctionListItem(ctx, obj, atom, e);
+        if (atom == JS_ATOM_NULL)
+            return -1;
+        ret = JS_InstantiateFunctionListItem(ctx, obj, atom, e);
         JS_FreeAtom(ctx, atom);
+        if (ret)
+            return -1;
     }
+    return 0;
 }
 
 int JS_AddModuleExportList(JSContext *ctx, JSModuleDef *m,
@@ -35828,7 +38234,7 @@ static void JS_SetConstructor2(JSContext *ctx,
     set_cycle_flag(ctx, proto);
 }
 
-void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
                        JSValueConst proto)
 {
     JS_SetConstructor2(ctx, func_obj, proto,
@@ -35878,7 +38284,6 @@ static JSValue js_global_isNaN(JSContext *ctx, JSValueConst this_val,
 {
     double d;
 
-    /* XXX: does this work for bigfloat? */
     if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
         return JS_EXCEPTION;
     return JS_NewBool(ctx, isnan(d));
@@ -35887,12 +38292,10 @@ static JSValue js_global_isNaN(JSContext *ctx, JSValueConst this_val,
 static JSValue js_global_isFinite(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv)
 {
-    BOOL res;
     double d;
     if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
         return JS_EXCEPTION;
-    res = isfinite(d);
-    return JS_NewBool(ctx, res);
+    return JS_NewBool(ctx, isfinite(d));
 }
 
 /* Object class */
@@ -35910,29 +38313,31 @@ static JSValue JS_ToObject(JSContext *ctx, JSValueConst val)
     case JS_TAG_OBJECT:
     case JS_TAG_EXCEPTION:
         return JS_DupValue(ctx, val);
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_INT);
         goto set_value;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-        obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_FLOAT);
-        goto set_value;
-    case JS_TAG_BIG_DECIMAL:
-        obj = JS_NewObjectClass(ctx, JS_CLASS_BIG_DECIMAL);
-        goto set_value;
-#endif
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
         obj = JS_NewObjectClass(ctx, JS_CLASS_NUMBER);
         goto set_value;
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         /* XXX: should call the string constructor */
         {
-            JSString *p1 = JS_VALUE_GET_STRING(val);
+            JSValue str;
+            str = JS_ToString(ctx, val); /* ensure that we never store a rope */
+            if (JS_IsException(str))
+                return JS_EXCEPTION;
             obj = JS_NewObjectClass(ctx, JS_CLASS_STRING);
-            JS_DefinePropertyValue(ctx, obj, JS_ATOM_length, JS_NewInt32(ctx, p1->len), 0);
+            if (!JS_IsException(obj)) {
+                JS_DefinePropertyValue(ctx, obj, JS_ATOM_length,
+                                       JS_NewInt32(ctx, JS_VALUE_GET_STRING(str)->len), 0);
+                JS_SetObjectData(ctx, obj, JS_DupValue(ctx, str));
+            }
+            JS_FreeValue(ctx, str);
+            return obj;
         }
-        goto set_value;
     case JS_TAG_BOOL:
         obj = JS_NewObjectClass(ctx, JS_CLASS_BOOLEAN);
         goto set_value;
@@ -35966,6 +38371,14 @@ static int js_obj_to_desc(JSContext *ctx, JSPropertyDescriptor *d,
     val = JS_UNDEFINED;
     getter = JS_UNDEFINED;
     setter = JS_UNDEFINED;
+    if (JS_HasProperty(ctx, desc, JS_ATOM_enumerable)) {
+        JSValue prop = JS_GetProperty(ctx, desc, JS_ATOM_enumerable);
+        if (JS_IsException(prop))
+            goto fail;
+        flags |= JS_PROP_HAS_ENUMERABLE;
+        if (JS_ToBoolFree(ctx, prop))
+            flags |= JS_PROP_ENUMERABLE;
+    }
     if (JS_HasProperty(ctx, desc, JS_ATOM_configurable)) {
         JSValue prop = JS_GetProperty(ctx, desc, JS_ATOM_configurable);
         if (JS_IsException(prop))
@@ -35974,6 +38387,12 @@ static int js_obj_to_desc(JSContext *ctx, JSPropertyDescriptor *d,
         if (JS_ToBoolFree(ctx, prop))
             flags |= JS_PROP_CONFIGURABLE;
     }
+    if (JS_HasProperty(ctx, desc, JS_ATOM_value)) {
+        flags |= JS_PROP_HAS_VALUE;
+        val = JS_GetProperty(ctx, desc, JS_ATOM_value);
+        if (JS_IsException(val))
+            goto fail;
+    }
     if (JS_HasProperty(ctx, desc, JS_ATOM_writable)) {
         JSValue prop = JS_GetProperty(ctx, desc, JS_ATOM_writable);
         if (JS_IsException(prop))
@@ -35982,20 +38401,6 @@ static int js_obj_to_desc(JSContext *ctx, JSPropertyDescriptor *d,
         if (JS_ToBoolFree(ctx, prop))
             flags |= JS_PROP_WRITABLE;
     }
-    if (JS_HasProperty(ctx, desc, JS_ATOM_enumerable)) {
-        JSValue prop = JS_GetProperty(ctx, desc, JS_ATOM_enumerable);
-        if (JS_IsException(prop))
-            goto fail;
-        flags |= JS_PROP_HAS_ENUMERABLE;
-        if (JS_ToBoolFree(ctx, prop))
-            flags |= JS_PROP_ENUMERABLE;
-    }
-    if (JS_HasProperty(ctx, desc, JS_ATOM_value)) {
-        flags |= JS_PROP_HAS_VALUE;
-        val = JS_GetProperty(ctx, desc, JS_ATOM_value);
-        if (JS_IsException(val))
-            goto fail;
-    }
     if (JS_HasProperty(ctx, desc, JS_ATOM_get)) {
         flags |= JS_PROP_HAS_GET;
         getter = JS_GetProperty(ctx, desc, JS_ATOM_get);
@@ -36066,6 +38471,7 @@ static __exception int JS_ObjectDefineProperties(JSContext *ctx,
     if (JS_IsException(props))
         return -1;
     p = JS_VALUE_GET_OBJ(props);
+    /* XXX: not done in the same order as the spec */
     if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK) < 0)
         goto exception;
     for(i = 0; i < len; i++) {
@@ -36079,7 +38485,7 @@ static __exception int JS_ObjectDefineProperties(JSContext *ctx,
     ret = 0;
 
 exception:
-    js_free_prop_enum(ctx, atoms, len);
+    JS_FreePropertyEnum(ctx, atoms, len);
     JS_FreeValue(ctx, props);
     JS_FreeValue(ctx, desc);
     return ret;
@@ -36286,13 +38692,13 @@ static JSValue js_object_getOwnPropertyDescriptor(JSContext *ctx, JSValueConst t
             } else {
                 if (JS_DefinePropertyValue(ctx, ret, JS_ATOM_value, JS_DupValue(ctx, desc.value), flags) < 0
                 ||  JS_DefinePropertyValue(ctx, ret, JS_ATOM_writable,
-                                           JS_NewBool(ctx, (desc.flags & JS_PROP_WRITABLE) != 0), flags) < 0)
+                                           JS_NewBool(ctx, desc.flags & JS_PROP_WRITABLE), flags) < 0)
                     goto exception1;
             }
             if (JS_DefinePropertyValue(ctx, ret, JS_ATOM_enumerable,
-                                       JS_NewBool(ctx, (desc.flags & JS_PROP_ENUMERABLE) != 0), flags) < 0
+                                       JS_NewBool(ctx, desc.flags & JS_PROP_ENUMERABLE), flags) < 0
             ||  JS_DefinePropertyValue(ctx, ret, JS_ATOM_configurable,
-                                       JS_NewBool(ctx, (desc.flags & JS_PROP_CONFIGURABLE) != 0), flags) < 0)
+                                       JS_NewBool(ctx, desc.flags & JS_PROP_CONFIGURABLE), flags) < 0)
                 goto exception1;
             js_free_desc(ctx, &desc);
         }
@@ -36350,12 +38756,12 @@ static JSValue js_object_getOwnPropertyDescriptors(JSContext *ctx, JSValueConst
                 goto exception;
         }
     }
-    js_free_prop_enum(ctx, props, len);
+    JS_FreePropertyEnum(ctx, props, len);
     JS_FreeValue(ctx, obj);
     return r;
 
 exception:
-    js_free_prop_enum(ctx, props, len);
+    JS_FreePropertyEnum(ctx, props, len);
     JS_FreeValue(ctx, obj);
     JS_FreeValue(ctx, r);
     return JS_EXCEPTION;
@@ -36435,7 +38841,7 @@ static JSValue JS_GetOwnPropertyNames2(JSContext *ctx, JSValueConst obj1,
     JS_FreeValue(ctx, r);
     r = JS_EXCEPTION;
 done:
-    js_free_prop_enum(ctx, atoms, len);
+    JS_FreePropertyEnum(ctx, atoms, len);
     JS_FreeValue(ctx, obj);
     return r;
 }
@@ -36573,9 +38979,9 @@ static JSValue js_object_toString(JSContext *ctx, JSValueConst this_val,
     JSObject *p;
 
     if (JS_IsNull(this_val)) {
-        tag = JS_NewString(ctx, "Null");
+        tag = js_new_string8(ctx, "Null");
     } else if (JS_IsUndefined(this_val)) {
-        tag = JS_NewString(ctx, "Undefined");
+        tag = js_new_string8(ctx, "Undefined");
     } else {
         obj = JS_ToObject(ctx, this_val);
         if (JS_IsException(obj))
@@ -36671,7 +39077,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
     if (!res) {
         return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
     }
-    
+
     p = JS_VALUE_GET_OBJ(obj);
     flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
     if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
@@ -36696,11 +39102,11 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
                               JS_UNDEFINED, JS_UNDEFINED, desc_flags) < 0)
             goto exception;
     }
-    js_free_prop_enum(ctx, props, len);
+    JS_FreePropertyEnum(ctx, props, len);
     return JS_DupValue(ctx, obj);
 
  exception:
-    js_free_prop_enum(ctx, props, len);
+    JS_FreePropertyEnum(ctx, props, len);
     return JS_EXCEPTION;
 }
 
@@ -36712,7 +39118,7 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
     JSPropertyEnum *props;
     uint32_t len, i;
     int flags, res;
-    
+
     if (!JS_IsObject(obj))
         return JS_TRUE;
 
@@ -36741,12 +39147,12 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
     if (res < 0)
         return JS_EXCEPTION;
     res ^= 1;
-done:        
-    js_free_prop_enum(ctx, props, len);
+done:
+    JS_FreePropertyEnum(ctx, props, len);
     return JS_NewBool(ctx, res);
 
 exception:
-    js_free_prop_enum(ctx, props, len);
+    JS_FreePropertyEnum(ctx, props, len);
     return JS_EXCEPTION;
 }
 
@@ -36764,24 +39170,22 @@ static JSValue js_object_fromEntries(JSContext *ctx, JSValueConst this_val,
     obj = JS_NewObject(ctx);
     if (JS_IsException(obj))
         return obj;
-    
+
     iter = JS_GetIterator(ctx, iterable, FALSE);
     if (JS_IsException(iter))
         goto fail;
     next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
     if (JS_IsException(next_method))
         goto fail;
-    
+
     for(;;) {
         JSValue key, value, item;
         item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
         if (JS_IsException(item))
             goto fail;
-        if (done) {
-            JS_FreeValue(ctx, item);
+        if (done)
             break;
-        }
-        
+
         key = JS_UNDEFINED;
         value = JS_UNDEFINED;
         if (!JS_IsObject(item)) {
@@ -37024,23 +39428,23 @@ static JSValue js_object_isPrototypeOf(JSContext *ctx, JSValueConst this_val,
 static JSValue js_object_propertyIsEnumerable(JSContext *ctx, JSValueConst this_val,
                                               int argc, JSValueConst *argv)
 {
-    JSValue obj, res = JS_EXCEPTION;
-    JSAtom prop = JS_ATOM_NULL;
+    JSValue obj = JS_UNDEFINED, res = JS_EXCEPTION;
+    JSAtom prop;
     JSPropertyDescriptor desc;
     int has_prop;
 
-    obj = JS_ToObject(ctx, this_val);
-    if (JS_IsException(obj))
-        goto exception;
     prop = JS_ValueToAtom(ctx, argv[0]);
     if (unlikely(prop == JS_ATOM_NULL))
         goto exception;
+    obj = JS_ToObject(ctx, this_val);
+    if (JS_IsException(obj))
+        goto exception;
 
     has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
     if (has_prop < 0)
         goto exception;
     if (has_prop) {
-        res = JS_NewBool(ctx, (desc.flags & JS_PROP_ENUMERABLE) != 0);
+        res = JS_NewBool(ctx, desc.flags & JS_PROP_ENUMERABLE);
         js_free_desc(ctx, &desc);
     } else {
         res = JS_FALSE;
@@ -37105,6 +39509,7 @@ static const JSCFunctionListEntry js_object_funcs[] = {
     JS_CFUNC_DEF("defineProperties", 2, js_object_defineProperties ),
     JS_CFUNC_DEF("getOwnPropertyNames", 1, js_object_getOwnPropertyNames ),
     JS_CFUNC_DEF("getOwnPropertySymbols", 1, js_object_getOwnPropertySymbols ),
+    JS_CFUNC_MAGIC_DEF("groupBy", 2, js_object_groupBy, 0 ),
     JS_CFUNC_MAGIC_DEF("keys", 1, js_object_keys, JS_ITERATOR_KIND_KEY ),
     JS_CFUNC_MAGIC_DEF("values", 1, js_object_keys, JS_ITERATOR_KIND_VALUE ),
     JS_CFUNC_MAGIC_DEF("entries", 1, js_object_keys, JS_ITERATOR_KIND_KEY_AND_VALUE ),
@@ -37166,7 +39571,7 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
 
     string_buffer_init(ctx, b, 0);
     string_buffer_putc8(b, '(');
-    
+
     if (func_kind == JS_FUNC_ASYNC || func_kind == JS_FUNC_ASYNC_GENERATOR) {
         string_buffer_puts8(b, "async ");
     }
@@ -37264,6 +39669,7 @@ static JSValue *build_arg_list(JSContext *ctx, uint32_t *plen,
                                JSValueConst array_arg)
 {
     uint32_t len, i;
+    int64_t len64;
     JSValue *tab, ret;
     JSObject *p;
 
@@ -37271,12 +39677,15 @@ static JSValue *build_arg_list(JSContext *ctx, uint32_t *plen,
         JS_ThrowTypeError(ctx, "not a object");
         return NULL;
     }
-    if (js_get_length32(ctx, &len, array_arg))
+    if (js_get_length64(ctx, &len64, array_arg))
         return NULL;
-    if (len > JS_MAX_LOCAL_VARS) {
-        JS_ThrowInternalError(ctx, "too many arguments");
+    if (len64 > JS_MAX_LOCAL_VARS) {
+        // XXX: check for stack overflow?
+        JS_ThrowRangeError(ctx, "too many arguments in function call (only %d allowed)",
+                           JS_MAX_LOCAL_VARS);
         return NULL;
     }
+    len = len64;
     /* avoid allocating 0 bytes */
     tab = js_mallocz(ctx, sizeof(tab[0]) * max_uint32(1, len));
     if (!tab)
@@ -37488,7 +39897,8 @@ static const JSCFunctionListEntry js_function_proto_funcs[] = {
     JS_CFUNC_DEF("toString", 0, js_function_toString ),
     JS_CFUNC_DEF("[Symbol.hasInstance]", 1, js_function_hasInstance ),
     JS_CGETSET_DEF("fileName", js_function_proto_fileName, NULL ),
-    JS_CGETSET_DEF("lineNumber", js_function_proto_lineNumber, NULL ),
+    JS_CGETSET_MAGIC_DEF("lineNumber", js_function_proto_lineNumber, NULL, 0 ),
+    JS_CGETSET_MAGIC_DEF("columnNumber", js_function_proto_lineNumber, NULL, 1 ),
 };
 
 /* Error class */
@@ -37499,7 +39909,7 @@ static JSValue iterator_to_array(JSContext *ctx, JSValueConst items)
     JSValue v, r = JS_UNDEFINED;
     int64_t k;
     BOOL done;
-    
+
     iter = JS_GetIterator(ctx, items, FALSE);
     if (JS_IsException(iter))
         goto exception;
@@ -37535,7 +39945,8 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
                                     int argc, JSValueConst *argv, int magic)
 {
     JSValue obj, msg, proto;
-    JSValueConst message;
+    JSValueConst message, options;
+    int arg_index;
 
     if (JS_IsUndefined(new_target))
         new_target = JS_GetActiveFunction(ctx);
@@ -37545,7 +39956,7 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
     if (!JS_IsObject(proto)) {
         JSContext *realm;
         JSValueConst proto1;
-        
+
         JS_FreeValue(ctx, proto);
         realm = JS_GetFunctionRealm(ctx, new_target);
         if (!realm)
@@ -37561,12 +39972,9 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
     JS_FreeValue(ctx, proto);
     if (JS_IsException(obj))
         return obj;
-    if (magic == JS_AGGREGATE_ERROR) {
-        message = argv[1];
-    } else {
-        message = argv[0];
-    }
+    arg_index = (magic == JS_AGGREGATE_ERROR);
 
+    message = argv[arg_index++];
     if (!JS_IsUndefined(message)) {
         msg = JS_ToString(ctx, message);
         if (unlikely(JS_IsException(msg)))
@@ -37575,6 +39983,22 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
                                JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     }
 
+    if (arg_index < argc) {
+        options = argv[arg_index];
+        if (JS_IsObject(options)) {
+            int present = JS_HasProperty(ctx, options, JS_ATOM_cause);
+            if (present < 0)
+                goto exception;
+            if (present) {
+                JSValue cause = JS_GetProperty(ctx, options, JS_ATOM_cause);
+                if (JS_IsException(cause))
+                    goto exception;
+                JS_DefinePropertyValue(ctx, obj, JS_ATOM_cause, cause,
+                                       JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+            }
+        }
+    }
+
     if (magic == JS_AGGREGATE_ERROR) {
         JSValue error_list = iterator_to_array(ctx, argv[0]);
         if (JS_IsException(error_list))
@@ -37584,7 +40008,7 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
     }
 
     /* skip the Error() function in the backtrace */
-    build_backtrace(ctx, obj, NULL, 0, JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL);
+    build_backtrace(ctx, obj, NULL, 0, 0, JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL);
     return obj;
  exception:
     JS_FreeValue(ctx, obj);
@@ -37626,6 +40050,16 @@ static const JSCFunctionListEntry js_error_proto_funcs[] = {
     JS_PROP_STRING_DEF("message", "", JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE ),
 };
 
+static JSValue js_error_isError(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv)
+{
+    return JS_NewBool(ctx, JS_IsError(ctx, argv[0]));
+}
+
+static const JSCFunctionListEntry js_error_funcs[] = {
+    JS_CFUNC_DEF("isError", 1, js_error_isError),
+};
+
 /* AggregateError */
 
 /* used by C code. */
@@ -37633,7 +40067,7 @@ static JSValue js_aggregate_error_constructor(JSContext *ctx,
                                               JSValueConst errors)
 {
     JSValue obj;
-    
+
     obj = JS_NewObjectProtoClass(ctx,
                                  ctx->native_error_proto[JS_AGGREGATE_ERROR],
                                  JS_CLASS_ERROR);
@@ -37699,7 +40133,7 @@ static int JS_CopySubArray(JSContext *ctx,
             fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
             if (fromPresent < 0)
                 goto exception;
-            
+
             if (fromPresent) {
                 if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
                     goto exception;
@@ -37749,8 +40183,7 @@ static JSValue js_array_from(JSContext *ctx, JSValueConst this_val,
     // from(items, mapfn = void 0, this_arg = void 0)
     JSValueConst items = argv[0], mapfn, this_arg;
     JSValueConst args[2];
-    JSValue stack[2];
-    JSValue iter, r, v, v2, arrayLike;
+    JSValue iter, r, v, v2, arrayLike, next_method, enum_obj;
     int64_t k, len;
     int done, mapping;
 
@@ -37759,8 +40192,9 @@ static JSValue js_array_from(JSContext *ctx, JSValueConst this_val,
     this_arg = JS_UNDEFINED;
     r = JS_UNDEFINED;
     arrayLike = JS_UNDEFINED;
-    stack[0] = JS_UNDEFINED;
-    stack[1] = JS_UNDEFINED;
+    iter = JS_UNDEFINED;
+    enum_obj = JS_UNDEFINED;
+    next_method = JS_UNDEFINED;
 
     if (argc > 1) {
         mapfn = argv[1];
@@ -37775,21 +40209,27 @@ static JSValue js_array_from(JSContext *ctx, JSValueConst this_val,
     iter = JS_GetProperty(ctx, items, JS_ATOM_Symbol_iterator);
     if (JS_IsException(iter))
         goto exception;
-    if (!JS_IsUndefined(iter)) {
-        JS_FreeValue(ctx, iter);
+    if (!JS_IsUndefined(iter) && !JS_IsNull(iter)) {
+        if (!JS_IsFunction(ctx, iter)) {
+            JS_ThrowTypeError(ctx, "value is not iterable");
+            goto exception;
+        }
         if (JS_IsConstructor(ctx, this_val))
             r = JS_CallConstructor(ctx, this_val, 0, NULL);
         else
             r = JS_NewArray(ctx);
         if (JS_IsException(r))
             goto exception;
-        stack[0] = JS_DupValue(ctx, items);
-        if (js_for_of_start(ctx, &stack[1], FALSE))
+        enum_obj = JS_GetIterator2(ctx, items, iter);
+        if (JS_IsException(enum_obj))
+            goto exception;
+        next_method = JS_GetProperty(ctx, enum_obj, JS_ATOM_next);
+        if (JS_IsException(next_method))
             goto exception;
         for (k = 0;; k++) {
-            v = JS_IteratorNext(ctx, stack[0], stack[1], 0, NULL, &done);
+            v = JS_IteratorNext(ctx, enum_obj, next_method, 0, NULL, &done);
             if (JS_IsException(v))
-                goto exception_close;
+                goto exception;
             if (done)
                 break;
             if (mapping) {
@@ -37844,15 +40284,15 @@ static JSValue js_array_from(JSContext *ctx, JSValueConst this_val,
     goto done;
 
  exception_close:
-    if (!JS_IsUndefined(stack[0]))
-        JS_IteratorClose(ctx, stack[0], TRUE);
+    JS_IteratorClose(ctx, enum_obj, TRUE);
  exception:
     JS_FreeValue(ctx, r);
     r = JS_EXCEPTION;
  done:
     JS_FreeValue(ctx, arrayLike);
-    JS_FreeValue(ctx, stack[0]);
-    JS_FreeValue(ctx, stack[1]);
+    JS_FreeValue(ctx, iter);
+    JS_FreeValue(ctx, enum_obj);
+    JS_FreeValue(ctx, next_method);
     return r;
 }
 
@@ -37907,7 +40347,7 @@ static JSValue JS_ArraySpeciesCreate(JSContext *ctx, JSValueConst obj,
     JSValue ctor, ret, species;
     int res;
     JSContext *realm;
-    
+
     res = JS_IsArray(ctx, obj);
     if (res < 0)
         return JS_EXCEPTION;
@@ -37975,7 +40415,7 @@ static JSValue js_array_at(JSContext *ctx, JSValueConst this_val,
     int64_t len, idx;
     JSValue *arrp;
     uint32_t count;
-    
+
     obj = JS_ToObject(ctx, this_val);
     if (js_get_length64(ctx, &len, obj))
         goto exception;
@@ -38003,6 +40443,71 @@ static JSValue js_array_at(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+static JSValue js_array_with(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    JSValue arr, obj, ret, *arrp, *pval;
+    JSObject *p;
+    int64_t i, len, idx;
+    uint32_t count32;
+
+    ret = JS_EXCEPTION;
+    arr = JS_UNDEFINED;
+    obj = JS_ToObject(ctx, this_val);
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+
+    if (JS_ToInt64Sat(ctx, &idx, argv[0]))
+        goto exception;
+
+    if (idx < 0)
+        idx = len + idx;
+
+    if (idx < 0 || idx >= len) {
+        JS_ThrowRangeError(ctx, "invalid array index: %" PRId64, idx);
+        goto exception;
+    }
+
+    arr = js_allocate_fast_array(ctx, len);
+    if (JS_IsException(arr))
+        goto exception;
+
+    p = JS_VALUE_GET_OBJ(arr);
+    i = 0;
+    pval = p->u.array.u.values;
+    if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
+        for (; i < idx; i++, pval++)
+            *pval = JS_DupValue(ctx, arrp[i]);
+        *pval = JS_DupValue(ctx, argv[1]);
+        for (i++, pval++; i < len; i++, pval++)
+            *pval = JS_DupValue(ctx, arrp[i]);
+    } else {
+        for (; i < idx; i++, pval++)
+            if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
+                goto fill_and_fail;
+        *pval = JS_DupValue(ctx, argv[1]);
+        for (i++, pval++; i < len; i++, pval++) {
+            if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval)) {
+            fill_and_fail:
+                for (; i < len; i++, pval++)
+                    *pval = JS_UNDEFINED;
+                goto exception;
+            }
+        }
+    }
+
+    if (JS_SetProperty(ctx, arr, JS_ATOM_length, JS_NewInt64(ctx, len)) < 0)
+        goto exception;
+
+    ret = arr;
+    arr = JS_UNDEFINED;
+
+exception:
+    JS_FreeValue(ctx, arr);
+    JS_FreeValue(ctx, obj);
+    return ret;
+}
+
 static JSValue js_array_concat(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
 {
@@ -38107,7 +40612,7 @@ static JSValue js_array_every(JSContext *ctx, JSValueConst this_val,
     this_arg = JS_UNDEFINED;
     if (argc > 1)
         this_arg = argv[1];
-        
+
     if (check_function(ctx, func))
         goto exception;
 
@@ -38368,9 +40873,10 @@ static JSValue js_array_includes(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
     JSValue obj, val;
-    int64_t len, n, res;
+    int64_t len, n;
     JSValue *arrp;
     uint32_t count;
+    int res;
 
     obj = JS_ToObject(ctx, this_val);
     if (js_get_length64(ctx, &len, obj))
@@ -38502,10 +41008,10 @@ static JSValue js_array_lastIndexOf(JSContext *ctx, JSValueConst this_val,
 }
 
 enum {
-    special_find,
-    special_findIndex,
-    special_findLast,
-    special_findLastIndex,
+    ArrayFind,
+    ArrayFindIndex,
+    ArrayFindLast,
+    ArrayFindLastIndex,
 };
 
 static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
@@ -38531,14 +41037,13 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
     if (argc > 1)
         this_arg = argv[1];
 
-    if (mode == special_findLast || mode == special_findLastIndex) {
+    k = 0;
+    dir = 1;
+    end = len;
+    if (mode == ArrayFindLast || mode == ArrayFindLastIndex) {
         k = len - 1;
         dir = -1;
         end = -1;
-    } else {
-        k = 0;
-        dir = 1;
-        end = len;
     }
 
     // TODO(bnoordhuis) add fast path for fast arrays
@@ -38556,7 +41061,7 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(res))
             goto exception;
         if (JS_ToBoolFree(ctx, res)) {
-            if (mode == special_findIndex || mode == special_findLastIndex) {
+            if (mode == ArrayFindIndex || mode == ArrayFindLastIndex) {
                 JS_FreeValue(ctx, val);
                 JS_FreeValue(ctx, obj);
                 return index_val;
@@ -38570,7 +41075,7 @@ static JSValue js_array_find(JSContext *ctx, JSValueConst this_val,
         JS_FreeValue(ctx, index_val);
     }
     JS_FreeValue(ctx, obj);
-    if (mode == special_findIndex || mode == special_findLastIndex)
+    if (mode == ArrayFindIndex || mode == ArrayFindLastIndex)
         return JS_NewInt32(ctx, -1);
     else
         return JS_UNDEFINED;
@@ -38821,6 +41326,61 @@ static JSValue js_array_reverse(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+// Note: a.toReversed() is a.slice().reverse() with the twist that a.slice()
+// leaves holes in sparse arrays intact whereas a.toReversed() replaces them
+// with undefined, thus in effect creating a dense array.
+// Does not use Array[@@species], always returns a base Array.
+static JSValue js_array_toReversed(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
+{
+    JSValue arr, obj, ret, *arrp, *pval;
+    JSObject *p;
+    int64_t i, len;
+    uint32_t count32;
+
+    ret = JS_EXCEPTION;
+    arr = JS_UNDEFINED;
+    obj = JS_ToObject(ctx, this_val);
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+
+    arr = js_allocate_fast_array(ctx, len);
+    if (JS_IsException(arr))
+        goto exception;
+
+    if (len > 0) {
+        p = JS_VALUE_GET_OBJ(arr);
+
+        i = len - 1;
+        pval = p->u.array.u.values;
+        if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
+            for (; i >= 0; i--, pval++)
+                *pval = JS_DupValue(ctx, arrp[i]);
+        } else {
+            // Query order is observable; test262 expects descending order.
+            for (; i >= 0; i--, pval++) {
+                if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval)) {
+                    // Exception; initialize remaining elements.
+                    for (; i >= 0; i--, pval++)
+                        *pval = JS_UNDEFINED;
+                    goto exception;
+                }
+            }
+        }
+
+        if (JS_SetProperty(ctx, arr, JS_ATOM_length, JS_NewInt64(ctx, len)) < 0)
+            goto exception;
+    }
+
+    ret = arr;
+    arr = JS_UNDEFINED;
+
+exception:
+    JS_FreeValue(ctx, arr);
+    JS_FreeValue(ctx, obj);
+    return ret;
+}
+
 static JSValue js_array_slice(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv, int splice)
 {
@@ -38928,6 +41488,92 @@ static JSValue js_array_slice(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+static JSValue js_array_toSpliced(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv)
+{
+    JSValue arr, obj, ret, *arrp, *pval, *last;
+    JSObject *p;
+    int64_t i, j, len, newlen, start, add, del;
+    uint32_t count32;
+
+    pval = NULL;
+    last = NULL;
+    ret = JS_EXCEPTION;
+    arr = JS_UNDEFINED;
+
+    obj = JS_ToObject(ctx, this_val);
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+
+    start = 0;
+    if (argc > 0)
+        if (JS_ToInt64Clamp(ctx, &start, argv[0], 0, len, len))
+            goto exception;
+
+    del = 0;
+    if (argc > 0)
+        del = len - start;
+    if (argc > 1)
+        if (JS_ToInt64Clamp(ctx, &del, argv[1], 0, del, 0))
+            goto exception;
+
+    add = 0;
+    if (argc > 2)
+        add = argc - 2;
+
+    newlen = len + add - del;
+    if (newlen > MAX_SAFE_INTEGER) {
+        JS_ThrowTypeError(ctx, "invalid array length");
+        goto exception;
+    }
+
+    arr = js_allocate_fast_array(ctx, newlen);
+    if (JS_IsException(arr))
+        goto exception;
+
+    if (newlen <= 0)
+        goto done;
+
+    p = JS_VALUE_GET_OBJ(arr);
+    pval = &p->u.array.u.values[0];
+    last = &p->u.array.u.values[newlen];
+
+    if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
+        for (i = 0; i < start; i++, pval++)
+            *pval = JS_DupValue(ctx, arrp[i]);
+        for (j = 0; j < add; j++, pval++)
+            *pval = JS_DupValue(ctx, argv[2 + j]);
+        for (i += del; i < len; i++, pval++)
+            *pval = JS_DupValue(ctx, arrp[i]);
+    } else {
+        for (i = 0; i < start; i++, pval++)
+            if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
+                goto exception;
+        for (j = 0; j < add; j++, pval++)
+            *pval = JS_DupValue(ctx, argv[2 + j]);
+        for (i += del; i < len; i++, pval++)
+            if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
+                goto exception;
+    }
+
+    assert(pval == last);
+
+    if (JS_SetProperty(ctx, arr, JS_ATOM_length, JS_NewInt64(ctx, newlen)) < 0)
+        goto exception;
+
+done:
+    ret = arr;
+    arr = JS_UNDEFINED;
+
+exception:
+    while (pval != last)
+        *pval++ = JS_UNDEFINED;
+
+    JS_FreeValue(ctx, arr);
+    JS_FreeValue(ctx, obj);
+    return ret;
+}
+
 static JSValue js_array_copyWithin(JSContext *ctx, JSValueConst this_val,
                                    int argc, JSValueConst *argv)
 {
@@ -39231,6 +41877,68 @@ static JSValue js_array_sort(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
+// Note: a.toSorted() is a.slice().sort() with the twist that a.slice()
+// leaves holes in sparse arrays intact whereas a.toSorted() replaces them
+// with undefined, thus in effect creating a dense array.
+// Does not use Array[@@species], always returns a base Array.
+static JSValue js_array_toSorted(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
+{
+    JSValue arr, obj, ret, *arrp, *pval;
+    JSObject *p;
+    int64_t i, len;
+    uint32_t count32;
+    int ok;
+
+    ok = JS_IsUndefined(argv[0]) || JS_IsFunction(ctx, argv[0]);
+    if (!ok)
+        return JS_ThrowTypeError(ctx, "not a function");
+
+    ret = JS_EXCEPTION;
+    arr = JS_UNDEFINED;
+    obj = JS_ToObject(ctx, this_val);
+    if (js_get_length64(ctx, &len, obj))
+        goto exception;
+
+    arr = js_allocate_fast_array(ctx, len);
+    if (JS_IsException(arr))
+        goto exception;
+
+    if (len > 0) {
+        p = JS_VALUE_GET_OBJ(arr);
+        i = 0;
+        pval = p->u.array.u.values;
+        if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
+            for (; i < len; i++, pval++)
+                *pval = JS_DupValue(ctx, arrp[i]);
+        } else {
+            for (; i < len; i++, pval++) {
+                if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval)) {
+                    for (; i < len; i++, pval++)
+                        *pval = JS_UNDEFINED;
+                    goto exception;
+                }
+            }
+        }
+
+        if (JS_SetProperty(ctx, arr, JS_ATOM_length, JS_NewInt64(ctx, len)) < 0)
+            goto exception;
+    }
+
+    ret = js_array_sort(ctx, arr, argc, argv);
+    if (JS_IsException(ret))
+        goto exception;
+    JS_FreeValue(ctx, ret);
+
+    ret = arr;
+    arr = JS_UNDEFINED;
+
+exception:
+    JS_FreeValue(ctx, arr);
+    JS_FreeValue(ctx, obj);
+    return ret;
+}
+
 typedef struct JSArrayIteratorData {
     JSValue obj;
     JSIteratorKindEnum kind;
@@ -39384,6 +42092,7 @@ static const JSCFunctionListEntry js_iterator_proto_funcs[] = {
 
 static const JSCFunctionListEntry js_array_proto_funcs[] = {
     JS_CFUNC_DEF("at", 1, js_array_at ),
+    JS_CFUNC_DEF("with", 2, js_array_with ),
     JS_CFUNC_DEF("concat", 1, js_array_concat ),
     JS_CFUNC_MAGIC_DEF("every", 1, js_array_every, special_every ),
     JS_CFUNC_MAGIC_DEF("some", 1, js_array_every, special_some ),
@@ -39393,10 +42102,10 @@ static const JSCFunctionListEntry js_array_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("reduce", 1, js_array_reduce, special_reduce ),
     JS_CFUNC_MAGIC_DEF("reduceRight", 1, js_array_reduce, special_reduceRight ),
     JS_CFUNC_DEF("fill", 1, js_array_fill ),
-    JS_CFUNC_MAGIC_DEF("find", 1, js_array_find, special_find ),
-    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_array_find, special_findIndex ),
-    JS_CFUNC_MAGIC_DEF("findLast", 1, js_array_find, special_findLast ),
-    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_array_find, special_findLastIndex ),
+    JS_CFUNC_MAGIC_DEF("find", 1, js_array_find, ArrayFind ),
+    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_array_find, ArrayFindIndex ),
+    JS_CFUNC_MAGIC_DEF("findLast", 1, js_array_find, ArrayFindLast ),
+    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_array_find, ArrayFindLastIndex ),
     JS_CFUNC_DEF("indexOf", 1, js_array_indexOf ),
     JS_CFUNC_DEF("lastIndexOf", 1, js_array_lastIndexOf ),
     JS_CFUNC_DEF("includes", 1, js_array_includes ),
@@ -39408,9 +42117,12 @@ static const JSCFunctionListEntry js_array_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("shift", 0, js_array_pop, 1 ),
     JS_CFUNC_MAGIC_DEF("unshift", 1, js_array_push, 1 ),
     JS_CFUNC_DEF("reverse", 0, js_array_reverse ),
+    JS_CFUNC_DEF("toReversed", 0, js_array_toReversed ),
     JS_CFUNC_DEF("sort", 1, js_array_sort ),
+    JS_CFUNC_DEF("toSorted", 1, js_array_toSorted ),
     JS_CFUNC_MAGIC_DEF("slice", 2, js_array_slice, 0 ),
     JS_CFUNC_MAGIC_DEF("splice", 2, js_array_slice, 1 ),
+    JS_CFUNC_DEF("toSpliced", 2, js_array_toSpliced ),
     JS_CFUNC_DEF("copyWithin", 2, js_array_copyWithin ),
     JS_CFUNC_MAGIC_DEF("flatMap", 1, js_array_flatten, 1 ),
     JS_CFUNC_MAGIC_DEF("flat", 0, js_array_flatten, 0 ),
@@ -39438,28 +42150,20 @@ static JSValue js_number_constructor(JSContext *ctx, JSValueConst new_target,
         if (JS_IsException(val))
             return val;
         switch(JS_VALUE_GET_TAG(val)) {
+        case JS_TAG_SHORT_BIG_INT:
+            val = JS_NewInt64(ctx, JS_VALUE_GET_SHORT_BIG_INT(val));
+            if (JS_IsException(val))
+                return val;
+            break;
         case JS_TAG_BIG_INT:
-#ifdef CONFIG_BIGNUM
-        case JS_TAG_BIG_FLOAT:
-#endif            
             {
-                JSBigFloat *p = JS_VALUE_GET_PTR(val);
+                JSBigInt *p = JS_VALUE_GET_PTR(val);
                 double d;
-                bf_get_float64(&p->num, &d, BF_RNDN);
+                d = js_bigint_to_float64(ctx, p);
                 JS_FreeValue(ctx, val);
-                val = __JS_NewFloat64(ctx, d);
+                val = JS_NewFloat64(ctx, d);
             }
             break;
-#ifdef CONFIG_BIGNUM
-        case JS_TAG_BIG_DECIMAL:
-            val = JS_ToStringFree(ctx, val);
-            if (JS_IsException(val))
-                return val;
-            val = JS_ToNumberFree(ctx, val);
-            if (JS_IsException(val))
-                return val;
-            break;
-#endif
         default:
             break;
         }
@@ -39586,7 +42290,7 @@ static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv, int magic)
 {
     JSValue val;
-    int base;
+    int base, flags;
     double d;
 
     val = js_thisNumberValue(ctx, this_val);
@@ -39599,9 +42303,18 @@ static JSValue js_number_toString(JSContext *ctx, JSValueConst this_val,
         if (base < 0)
             goto fail;
     }
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_INT) {
+        char buf1[70];
+        int len;
+        len = i64toa_radix(buf1, JS_VALUE_GET_INT(val), base);
+        return js_new_string8_len(ctx, buf1, len);
+    }
     if (JS_ToFloat64Free(ctx, &d, val))
         return JS_EXCEPTION;
-    return js_dtoa(ctx, d, base, 0, JS_DTOA_VAR_FORMAT);
+    flags = JS_DTOA_FORMAT_FREE;
+    if (base != 10)
+        flags |= JS_DTOA_EXP_DISABLED;
+    return js_dtoa2(ctx, d, base, 0, flags);
  fail:
     JS_FreeValue(ctx, val);
     return JS_EXCEPTION;
@@ -39611,7 +42324,7 @@ static JSValue js_number_toFixed(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv)
 {
     JSValue val;
-    int f;
+    int f, flags;
     double d;
 
     val = js_thisNumberValue(ctx, this_val);
@@ -39623,11 +42336,11 @@ static JSValue js_number_toFixed(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     if (f < 0 || f > 100)
         return JS_ThrowRangeError(ctx, "invalid number of digits");
-    if (fabs(d) >= 1e21) {
-        return JS_ToStringFree(ctx, __JS_NewFloat64(ctx, d));
-    } else {
-        return js_dtoa(ctx, d, 10, f, JS_DTOA_FRAC_FORMAT);
-    }
+    if (fabs(d) >= 1e21)
+        flags = JS_DTOA_FORMAT_FREE;
+    else
+        flags = JS_DTOA_FORMAT_FRAC;
+    return js_dtoa2(ctx, d, 10, f, flags);
 }
 
 static JSValue js_number_toExponential(JSContext *ctx, JSValueConst this_val,
@@ -39648,15 +42361,15 @@ static JSValue js_number_toExponential(JSContext *ctx, JSValueConst this_val,
         return JS_ToStringFree(ctx,  __JS_NewFloat64(ctx, d));
     }
     if (JS_IsUndefined(argv[0])) {
-        flags = 0;
+        flags = JS_DTOA_FORMAT_FREE;
         f = 0;
     } else {
         if (f < 0 || f > 100)
             return JS_ThrowRangeError(ctx, "invalid number of digits");
         f++;
-        flags = JS_DTOA_FIXED_FORMAT;
+        flags = JS_DTOA_FORMAT_FIXED;
     }
-    return js_dtoa(ctx, d, 10, f, flags | JS_DTOA_FORCE_EXP);
+    return js_dtoa2(ctx, d, 10, f, flags | JS_DTOA_EXP_ENABLED);
 }
 
 static JSValue js_number_toPrecision(JSContext *ctx, JSValueConst this_val,
@@ -39681,7 +42394,7 @@ static JSValue js_number_toPrecision(JSContext *ctx, JSValueConst this_val,
     }
     if (p < 1 || p > 100)
         return JS_ThrowRangeError(ctx, "invalid number of digits");
-    return js_dtoa(ctx, d, 10, p, JS_DTOA_FIXED_FORMAT);
+    return js_dtoa2(ctx, d, 10, p, JS_DTOA_FORMAT_FIXED);
 }
 
 static const JSCFunctionListEntry js_number_proto_funcs[] = {
@@ -39805,10 +42518,7 @@ static int js_string_get_own_property(JSContext *ctx,
             idx = __JS_AtomToUInt32(prop);
             if (idx < p1->len) {
                 if (desc) {
-                    if (p1->is_wide_char)
-                        ch = p1->u.str16[idx];
-                    else
-                        ch = p1->u.str8[idx];
+                    ch = string_get(p1, idx);
                     desc->flags = JS_PROP_ENUMERABLE;
                     desc->value = js_new_string_char(ctx, ch);
                     desc->getter = JS_UNDEFINED;
@@ -39830,7 +42540,7 @@ static int js_string_define_own_property(JSContext *ctx,
     uint32_t idx;
     JSObject *p;
     JSString *p1, *p2;
-    
+
     if (__JS_AtomIsTaggedInt(prop)) {
         idx = __JS_AtomToUInt32(prop);
         p = JS_VALUE_GET_OBJ(this_obj);
@@ -39901,7 +42611,9 @@ static JSValue js_string_constructor(JSContext *ctx, JSValueConst new_target,
         JSString *p1 = JS_VALUE_GET_STRING(val);
 
         obj = js_create_from_ctor(ctx, new_target, JS_CLASS_STRING);
-        if (!JS_IsException(obj)) {
+        if (JS_IsException(obj)) {
+            JS_FreeValue(ctx, val);
+        } else {
             JS_SetObjectData(ctx, obj, val);
             JS_DefinePropertyValue(ctx, obj, JS_ATOM_length, JS_NewInt32(ctx, p1->len), 0);
         }
@@ -39913,7 +42625,8 @@ static JSValue js_string_constructor(JSContext *ctx, JSValueConst new_target,
 
 static JSValue js_thisStringValue(JSContext *ctx, JSValueConst this_val)
 {
-    if (JS_VALUE_GET_TAG(this_val) == JS_TAG_STRING)
+    if (JS_VALUE_GET_TAG(this_val) == JS_TAG_STRING ||
+        JS_VALUE_GET_TAG(this_val) == JS_TAG_STRING_ROPE)
         return JS_DupValue(ctx, this_val);
 
     if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
@@ -39963,7 +42676,7 @@ static JSValue js_string_fromCodePoint(JSContext *ctx, JSValueConst this_val,
         } else {
             if (JS_ToFloat64(ctx, &d, argv[i]))
                 goto fail;
-            if (d < 0 || d > 0x10ffff || (c = (int)d) != d)
+            if (isnan(d) || d < 0 || d > 0x10ffff || (c = (int)d) != d)
                 goto range_error;
         }
         if (string_buffer_putc(b, c))
@@ -39996,7 +42709,7 @@ static JSValue js_string_raw(JSContext *ctx, JSValueConst this_val,
         goto exception;
     if (js_get_length64(ctx, &n, raw) < 0)
         goto exception;
-        
+
     for (i = 0; i < n; i++) {
         val = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, raw, i));
         if (JS_IsException(val))
@@ -40074,10 +42787,7 @@ static JSValue js_string_charCodeAt(JSContext *ctx, JSValueConst this_val,
     if (idx < 0 || idx >= p->len) {
         ret = JS_NAN;
     } else {
-        if (p->is_wide_char)
-            c = p->u.str16[idx];
-        else
-            c = p->u.str8[idx];
+        c = string_get(p, idx);
         ret = JS_NewInt32(ctx, c);
     }
     JS_FreeValue(ctx, val);
@@ -40105,12 +42815,9 @@ static JSValue js_string_charAt(JSContext *ctx, JSValueConst this_val,
         if (is_at)
             ret = JS_UNDEFINED;
         else
-            ret = js_new_string8(ctx, NULL, 0);
+            ret = JS_AtomToString(ctx, JS_ATOM_empty_string);
     } else {
-        if (p->is_wide_char)
-            c = p->u.str16[idx];
-        else
-            c = p->u.str8[idx];
+        c = string_get(p, idx);
         ret = js_new_string_char(ctx, c);
     }
     JS_FreeValue(ctx, val);
@@ -40218,6 +42925,80 @@ static int64_t string_advance_index(JSString *p, int64_t index, BOOL unicode)
     return index;
 }
 
+/* return the position of the first invalid character in the string or
+   -1 if none */
+static int js_string_find_invalid_codepoint(JSString *p)
+{
+    int i;
+    if (!p->is_wide_char)
+        return -1;
+    for(i = 0; i < p->len; i++) {
+        uint32_t c = p->u.str16[i];
+        if (is_surrogate(c)) {
+            if (is_hi_surrogate(c) && (i + 1) < p->len
+            &&  is_lo_surrogate(p->u.str16[i + 1])) {
+                i++;
+            } else {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+static JSValue js_string_isWellFormed(JSContext *ctx, JSValueConst this_val,
+                                      int argc, JSValueConst *argv)
+{
+    JSValue str;
+    JSString *p;
+    BOOL ret;
+
+    str = JS_ToStringCheckObject(ctx, this_val);
+    if (JS_IsException(str))
+        return JS_EXCEPTION;
+    p = JS_VALUE_GET_STRING(str);
+    ret = (js_string_find_invalid_codepoint(p) < 0);
+    JS_FreeValue(ctx, str);
+    return JS_NewBool(ctx, ret);
+}
+
+static JSValue js_string_toWellFormed(JSContext *ctx, JSValueConst this_val,
+                                      int argc, JSValueConst *argv)
+{
+    JSValue str, ret;
+    JSString *p;
+    int i;
+
+    str = JS_ToStringCheckObject(ctx, this_val);
+    if (JS_IsException(str))
+        return JS_EXCEPTION;
+
+    p = JS_VALUE_GET_STRING(str);
+    /* avoid reallocating the string if it is well-formed */
+    i = js_string_find_invalid_codepoint(p);
+    if (i < 0)
+        return str;
+
+    ret = js_new_string16_len(ctx, p->u.str16, p->len);
+    JS_FreeValue(ctx, str);
+    if (JS_IsException(ret))
+        return JS_EXCEPTION;
+
+    p = JS_VALUE_GET_STRING(ret);
+    for (; i < p->len; i++) {
+        uint32_t c = p->u.str16[i];
+        if (is_surrogate(c)) {
+            if (is_hi_surrogate(c) && (i + 1) < p->len
+            &&  is_lo_surrogate(p->u.str16[i + 1])) {
+                i++;
+            } else {
+                p->u.str16[i] = 0xFFFD;
+            }
+        }
+    }
+    return ret;
+}
+
 static JSValue js_string_indexOf(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv, int lastIndexOf)
 {
@@ -40300,7 +43081,7 @@ static JSValue js_string_includes(JSContext *ctx, JSValueConst this_val,
     ret = js_is_regexp(ctx, argv[0]);
     if (ret) {
         if (ret > 0)
-            JS_ThrowTypeError(ctx, "regex not supported");
+            JS_ThrowTypeError(ctx, "regexp not supported");
         goto fail;
     }
     v = JS_ToString(ctx, argv[0]);
@@ -40354,7 +43135,7 @@ static int check_regexp_g_flag(JSContext *ctx, JSValueConst regexp)
 {
     int ret;
     JSValue flags;
-    
+
     ret = js_is_regexp(ctx, regexp);
     if (ret < 0)
         return -1;
@@ -40412,7 +43193,7 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
     args[0] = regexp;
     str = JS_UNDEFINED;
     if (atom == JS_ATOM_Symbol_matchAll) {
-        str = JS_NewString(ctx, "g");
+        str = js_new_string8(ctx, "g");
         if (JS_IsException(str))
             goto fail;
         args[args_len++] = (JSValueConst)str;
@@ -40628,7 +43409,7 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
         }
         if (JS_IsException(repl_str))
             goto exception;
-        
+
         string_buffer_concat(b, sp, endOfLastMatch, pos);
         string_buffer_concat_value_free(b, repl_str);
         endOfLastMatch = pos + searchp->len;
@@ -40862,8 +43643,8 @@ static JSValue js_string_pad(JSContext *ctx, JSValueConst this_val,
         }
     }
     if (n > JS_STRING_LEN_MAX) {
-        JS_ThrowInternalError(ctx, "string too long");
-        goto fail2;
+        JS_ThrowRangeError(ctx, "invalid string length");
+        goto fail3;
     }
     if (string_buffer_init(ctx, b, n))
         goto fail3;
@@ -40924,8 +43705,9 @@ static JSValue js_string_repeat(JSContext *ctx, JSValueConst this_val,
     len = p->len;
     if (len == 0 || n == 1)
         return str;
+    // XXX: potential arithmetic overflow
     if (val * len > JS_STRING_LEN_MAX) {
-        JS_ThrowInternalError(ctx, "string too long");
+        JS_ThrowRangeError(ctx, "invalid string length");
         goto fail;
     }
     if (string_buffer_init2(ctx, b, n * len, p->is_wide_char))
@@ -40988,10 +43770,10 @@ static int string_prevc(JSString *p, int *pidx)
     idx--;
     if (p->is_wide_char) {
         c = p->u.str16[idx];
-        if (c >= 0xdc00 && c < 0xe000 && idx > 0) {
+        if (is_lo_surrogate(c) && idx > 0) {
             c1 = p->u.str16[idx - 1];
-            if (c1 >= 0xd800 && c1 <= 0xdc00) {
-                c = (((c1 & 0x3ff) << 10) | (c & 0x3ff)) + 0x10000;
+            if (is_hi_surrogate(c1)) {
+                c = from_surrogate(c1, c);
                 idx--;
             }
         }
@@ -41030,26 +43812,6 @@ static BOOL test_final_sigma(JSString *p, int sigma_pos)
     return !lre_is_cased(c1);
 }
 
-static JSValue js_string_localeCompare(JSContext *ctx, JSValueConst this_val,
-                                       int argc, JSValueConst *argv)
-{
-    JSValue a, b;
-    int cmp;
-
-    a = JS_ToStringCheckObject(ctx, this_val);
-    if (JS_IsException(a))
-        return JS_EXCEPTION;
-    b = JS_ToString(ctx, argv[0]);
-    if (JS_IsException(b)) {
-        JS_FreeValue(ctx, a);
-        return JS_EXCEPTION;
-    }
-    cmp = js_string_compare(ctx, JS_VALUE_GET_STRING(a), JS_VALUE_GET_STRING(b));
-    JS_FreeValue(ctx, a);
-    JS_FreeValue(ctx, b);
-    return JS_NewInt32(ctx, cmp);
-}
-
 static JSValue js_string_toLowerCase(JSContext *ctx, JSValueConst this_val,
                                      int argc, JSValueConst *argv, int to_lower)
 {
@@ -41135,23 +43897,38 @@ static JSValue JS_NewUTF32String(JSContext *ctx, const uint32_t *buf, int len)
     return JS_EXCEPTION;
 }
 
+static int js_string_normalize1(JSContext *ctx, uint32_t **pout_buf,
+                                JSValueConst val,
+                                UnicodeNormalizationEnum n_type)
+{
+    int buf_len, out_len;
+    uint32_t *buf, *out_buf;
+
+    buf_len = JS_ToUTF32String(ctx, &buf, val);
+    if (buf_len < 0)
+        return -1;
+    out_len = unicode_normalize(&out_buf, buf, buf_len, n_type,
+                                ctx->rt, (DynBufReallocFunc *)js_realloc_rt);
+    js_free(ctx, buf);
+    if (out_len < 0)
+        return -1;
+    *pout_buf = out_buf;
+    return out_len;
+}
+
 static JSValue js_string_normalize(JSContext *ctx, JSValueConst this_val,
                                    int argc, JSValueConst *argv)
 {
     const char *form, *p;
     size_t form_len;
-    int is_compat, buf_len, out_len;
+    int is_compat, out_len;
     UnicodeNormalizationEnum n_type;
     JSValue val;
-    uint32_t *buf, *out_buf;
+    uint32_t *out_buf;
 
     val = JS_ToStringCheckObject(ctx, this_val);
     if (JS_IsException(val))
         return val;
-    buf_len = JS_ToUTF32String(ctx, &buf, val);
-    JS_FreeValue(ctx, val);
-    if (buf_len < 0)
-        return JS_EXCEPTION;
 
     if (argc == 0 || JS_IsUndefined(argv[0])) {
         n_type = UNICODE_NFC;
@@ -41177,22 +43954,96 @@ static JSValue js_string_normalize(JSContext *ctx, JSValueConst this_val,
             JS_FreeCString(ctx, form);
             JS_ThrowRangeError(ctx, "bad normalization form");
         fail1:
-            js_free(ctx, buf);
+            JS_FreeValue(ctx, val);
             return JS_EXCEPTION;
         }
         JS_FreeCString(ctx, form);
     }
 
-    out_len = unicode_normalize(&out_buf, buf, buf_len, n_type,
-                                ctx->rt, (DynBufReallocFunc *)js_realloc_rt);
-    js_free(ctx, buf);
+    out_len = js_string_normalize1(ctx, &out_buf, val, n_type);
+    JS_FreeValue(ctx, val);
     if (out_len < 0)
         return JS_EXCEPTION;
     val = JS_NewUTF32String(ctx, out_buf, out_len);
     js_free(ctx, out_buf);
     return val;
 }
-#endif /* CONFIG_ALL_UNICODE */
+
+/* return < 0, 0 or > 0 */
+static int js_UTF32_compare(const uint32_t *buf1, int buf1_len,
+                            const uint32_t *buf2, int buf2_len)
+{
+    int i, len, c, res;
+    len = min_int(buf1_len, buf2_len);
+    for(i = 0; i < len; i++) {
+        /* Note: range is limited so a subtraction is valid */
+        c = buf1[i] - buf2[i];
+        if (c != 0)
+            return c;
+    }
+    if (buf1_len == buf2_len)
+        res = 0;
+    else if (buf1_len < buf2_len)
+        res = -1;
+    else
+        res = 1;
+    return res;
+}
+
+static JSValue js_string_localeCompare(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JSValue a, b;
+    int cmp, a_len, b_len;
+    uint32_t *a_buf, *b_buf;
+
+    a = JS_ToStringCheckObject(ctx, this_val);
+    if (JS_IsException(a))
+        return JS_EXCEPTION;
+    b = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(b)) {
+        JS_FreeValue(ctx, a);
+        return JS_EXCEPTION;
+    }
+    a_len = js_string_normalize1(ctx, &a_buf, a, UNICODE_NFC);
+    JS_FreeValue(ctx, a);
+    if (a_len < 0) {
+        JS_FreeValue(ctx, b);
+        return JS_EXCEPTION;
+    }
+
+    b_len = js_string_normalize1(ctx, &b_buf, b, UNICODE_NFC);
+    JS_FreeValue(ctx, b);
+    if (b_len < 0) {
+        js_free(ctx, a_buf);
+        return JS_EXCEPTION;
+    }
+    cmp = js_UTF32_compare(a_buf, a_len, b_buf, b_len);
+    js_free(ctx, a_buf);
+    js_free(ctx, b_buf);
+    return JS_NewInt32(ctx, cmp);
+}
+#else /* CONFIG_ALL_UNICODE */
+static JSValue js_string_localeCompare(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JSValue a, b;
+    int cmp;
+
+    a = JS_ToStringCheckObject(ctx, this_val);
+    if (JS_IsException(a))
+        return JS_EXCEPTION;
+    b = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(b)) {
+        JS_FreeValue(ctx, a);
+        return JS_EXCEPTION;
+    }
+    cmp = js_string_compare(ctx, JS_VALUE_GET_STRING(a), JS_VALUE_GET_STRING(b));
+    JS_FreeValue(ctx, a);
+    JS_FreeValue(ctx, b);
+    return JS_NewInt32(ctx, cmp);
+}
+#endif /* !CONFIG_ALL_UNICODE */
 
 /* also used for String.prototype.valueOf */
 static JSValue js_string_toString(JSContext *ctx, JSValueConst this_val,
@@ -41276,7 +44127,7 @@ static JSValue js_string_iterator_next(JSContext *ctx, JSValueConst this_val,
     if (c <= 0xffff) {
         return js_new_string_char(ctx, c);
     } else {
-        return js_new_string16(ctx, p->u.str16 + start, 2);
+        return js_new_string16_len(ctx, p->u.str16 + start, 2);
     }
 }
 
@@ -41306,7 +44157,7 @@ static JSValue js_string_CreateHTML(JSContext *ctx, JSValueConst this_val,
     static struct { const char *tag, *attr; } const defs[] = {
         { "a", "name" }, { "big", NULL }, { "blink", NULL }, { "b", NULL },
         { "tt", NULL }, { "font", "color" }, { "font", "size" }, { "i", NULL },
-        { "a", "href" }, { "small", NULL }, { "strike", NULL }, 
+        { "a", "href" }, { "small", NULL }, { "strike", NULL },
         { "sub", NULL }, { "sup", NULL },
     };
 
@@ -41369,6 +44220,8 @@ static const JSCFunctionListEntry js_string_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("charAt", 1, js_string_charAt, 0 ),
     JS_CFUNC_DEF("concat", 1, js_string_concat ),
     JS_CFUNC_DEF("codePointAt", 1, js_string_codePointAt ),
+    JS_CFUNC_DEF("isWellFormed", 0, js_string_isWellFormed ),
+    JS_CFUNC_DEF("toWellFormed", 0, js_string_toWellFormed ),
     JS_CFUNC_MAGIC_DEF("indexOf", 1, js_string_indexOf, 0 ),
     JS_CFUNC_MAGIC_DEF("lastIndexOf", 1, js_string_indexOf, 1 ),
     JS_CFUNC_MAGIC_DEF("includes", 1, js_string_includes, 0 ),
@@ -41394,7 +44247,6 @@ static const JSCFunctionListEntry js_string_proto_funcs[] = {
     JS_CFUNC_DEF("toString", 0, js_string_toString ),
     JS_CFUNC_DEF("valueOf", 0, js_string_toString ),
     JS_CFUNC_DEF("__quote", 1, js_string___quote ),
-    JS_CFUNC_DEF("localeCompare", 1, js_string_localeCompare ),
     JS_CFUNC_MAGIC_DEF("toLowerCase", 0, js_string_toLowerCase, 1 ),
     JS_CFUNC_MAGIC_DEF("toUpperCase", 0, js_string_toLowerCase, 0 ),
     JS_CFUNC_MAGIC_DEF("toLocaleLowerCase", 0, js_string_toLowerCase, 1 ),
@@ -41421,18 +44273,17 @@ static const JSCFunctionListEntry js_string_iterator_proto_funcs[] = {
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "String Iterator", JS_PROP_CONFIGURABLE ),
 };
 
-#ifdef CONFIG_ALL_UNICODE
 static const JSCFunctionListEntry js_string_proto_normalize[] = {
+#ifdef CONFIG_ALL_UNICODE
     JS_CFUNC_DEF("normalize", 0, js_string_normalize ),
-};
 #endif
+    JS_CFUNC_DEF("localeCompare", 1, js_string_localeCompare ),
+};
 
 void JS_AddIntrinsicStringNormalize(JSContext *ctx)
 {
-#ifdef CONFIG_ALL_UNICODE
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_STRING], js_string_proto_normalize,
                                countof(js_string_proto_normalize));
-#endif
 }
 
 /* Math */
@@ -41580,6 +44431,11 @@ static JSValue js_math_hypot(JSContext *ctx, JSValueConst this_val,
     return JS_NewFloat64(ctx, r);
 }
 
+static double js_math_f16round(double a)
+{
+    return fromfp16(tofp16(a));
+}
+
 static double js_math_fround(double a)
 {
     return (float)a;
@@ -41588,14 +44444,16 @@ static double js_math_fround(double a)
 static JSValue js_math_imul(JSContext *ctx, JSValueConst this_val,
                             int argc, JSValueConst *argv)
 {
-    int a, b;
+    uint32_t a, b, c;
+    int32_t d;
 
-    if (JS_ToInt32(ctx, &a, argv[0]))
+    if (JS_ToUint32(ctx, &a, argv[0]))
         return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &b, argv[1]))
+    if (JS_ToUint32(ctx, &b, argv[1]))
         return JS_EXCEPTION;
-    /* purposely ignoring overflow */
-    return JS_NewInt32(ctx, a * b);
+    c = a * b;
+    memcpy(&d, &c, sizeof(d));
+    return JS_NewInt32(ctx, d);
 }
 
 static JSValue js_math_clz32(JSContext *ctx, JSValueConst this_val,
@@ -41681,6 +44539,7 @@ static const JSCFunctionListEntry js_math_funcs[] = {
     JS_CFUNC_SPECIAL_DEF("cbrt", 1, f_f, cbrt ),
     JS_CFUNC_DEF("hypot", 2, js_math_hypot ),
     JS_CFUNC_DEF("random", 0, js_math_random ),
+    JS_CFUNC_SPECIAL_DEF("f16round", 1, f_f, js_math_f16round ),
     JS_CFUNC_SPECIAL_DEF("fround", 1, f_f, js_math_fround ),
     JS_CFUNC_DEF("imul", 2, js_math_imul ),
     JS_CFUNC_DEF("clz32", 1, js_math_clz32 ),
@@ -41701,39 +44560,12 @@ static const JSCFunctionListEntry js_math_obj[] = {
 
 /* Date */
 
-#if 0
-/* OS dependent: return the UTC time in ms since 1970. */
-static JSValue js___date_now(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv)
-{
-    int64_t d;
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    d = (int64_t)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
-    return JS_NewInt64(ctx, d);
-}
-#endif
-
-/* OS dependent: return the UTC time in microseconds since 1970. */
-static JSValue js___date_clock(JSContext *ctx, JSValueConst this_val,
-                               int argc, JSValueConst *argv)
-{
-    int64_t d;
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    d = (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
-    return JS_NewInt64(ctx, d);
-}
-
 /* OS dependent. d = argv[0] is in ms from 1970. Return the difference
    between UTC time and local time 'd' in minutes */
-static int getTimezoneOffset(int64_t time) {
-#if defined(_WIN32)
-    /* XXX: TODO */
-    return 0;
-#else
+static int getTimezoneOffset(int64_t time)
+{
     time_t ti;
-    struct tm tm;
+    int res;
 
     time /= 1000; /* convert to seconds */
     if (sizeof(time_t) == 4) {
@@ -41757,9 +44589,31 @@ static int getTimezoneOffset(int64_t time) {
         }
     }
     ti = time;
-    localtime_r(&ti, &tm);
-    return -tm.tm_gmtoff / 60;
+#if defined(_WIN32)
+    {
+        struct tm *tm;
+        time_t gm_ti, loc_ti;
+
+        tm = gmtime(&ti);
+        if (!tm)
+            return 0;
+        gm_ti = mktime(tm);
+
+        tm = localtime(&ti);
+        if (!tm)
+            return 0;
+        loc_ti = mktime(tm);
+
+        res = (gm_ti - loc_ti) / 60;
+    }
+#else
+    {
+        struct tm tm;
+        localtime_r(&ti, &tm);
+        res = -tm.tm_gmtoff / 60;
+    }
 #endif
+    return res;
 }
 
 #if 0
@@ -41836,6 +44690,9 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
         /* XXX: re_flags = LRE_FLAG_OCTAL unless strict mode? */
         for (i = 0; i < len; i++) {
             switch(str[i]) {
+            case 'd':
+                mask = LRE_FLAG_INDICES;
+                break;
             case 'g':
                 mask = LRE_FLAG_GLOBAL;
                 break;
@@ -41849,7 +44706,10 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
                 mask = LRE_FLAG_DOTALL;
                 break;
             case 'u':
-                mask = LRE_FLAG_UTF16;
+                mask = LRE_FLAG_UNICODE;
+                break;
+            case 'v':
+                mask = LRE_FLAG_UNICODE_SETS;
                 break;
             case 'y':
                 mask = LRE_FLAG_STICKY;
@@ -41860,14 +44720,20 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
             if ((re_flags & mask) != 0) {
             bad_flags:
                 JS_FreeCString(ctx, str);
-                return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
+                goto bad_flags1;
             }
             re_flags |= mask;
         }
         JS_FreeCString(ctx, str);
     }
 
-    str = JS_ToCStringLen2(ctx, &len, pattern, !(re_flags & LRE_FLAG_UTF16));
+    /* 'u' and 'v' cannot be both set */
+    if ((re_flags & LRE_FLAG_UNICODE_SETS) && (re_flags & LRE_FLAG_UNICODE)) {
+    bad_flags1:
+        return JS_ThrowSyntaxError(ctx, "invalid regular expression flags");
+    }
+    
+    str = JS_ToCStringLen2(ctx, &len, pattern, !(re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)));
     if (!str)
         return JS_EXCEPTION;
     re_bytecode_buf = lre_compile(&re_bytecode_len, error_msg,
@@ -41878,7 +44744,7 @@ static JSValue js_compile_regexp(JSContext *ctx, JSValueConst pattern,
         return JS_EXCEPTION;
     }
 
-    ret = js_new_string8(ctx, re_bytecode_buf, re_bytecode_len);
+    ret = js_new_string8_len(ctx, (const char *)re_bytecode_buf, re_bytecode_len);
     js_free(ctx, re_bytecode_buf);
     return ret;
 }
@@ -42106,8 +44972,8 @@ static JSValue js_regexp_get_source(JSContext *ctx, JSValueConst this_val)
 
     if (p->len == 0) {
     empty_regex:
-        return JS_NewString(ctx, "(?:)");
-    }    
+        return js_new_string8(ctx, "(?:)");
+    }
     string_buffer_init2(ctx, b, p->len, p->is_wide_char);
 
     /* Escape '/' and newline sequences as needed */
@@ -42166,49 +45032,39 @@ static JSValue js_regexp_get_flag(JSContext *ctx, JSValueConst this_val, int mas
         else
             return JS_ThrowTypeErrorInvalidClass(ctx, JS_CLASS_REGEXP);
     }
-    
+
     flags = lre_get_flags(re->bytecode->u.str8);
-    return JS_NewBool(ctx, (flags & mask) != 0);
+    return JS_NewBool(ctx, flags & mask);
 }
 
+#define RE_FLAG_COUNT 8
+
 static JSValue js_regexp_get_flags(JSContext *ctx, JSValueConst this_val)
 {
-    char str[8], *p = str;
-    int res;
-
+    char str[RE_FLAG_COUNT], *p = str;
+    int res, i;
+    static const int flag_atom[RE_FLAG_COUNT] = {
+        JS_ATOM_hasIndices,
+        JS_ATOM_global,
+        JS_ATOM_ignoreCase,
+        JS_ATOM_multiline,
+        JS_ATOM_dotAll,
+        JS_ATOM_unicode,
+        JS_ATOM_unicodeSets,
+        JS_ATOM_sticky,
+    };
+    static const char flag_char[RE_FLAG_COUNT] = { 'd', 'g', 'i', 'm', 's', 'u', 'v', 'y' };
+    
     if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
-    res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_global));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 'g';
-    res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "ignoreCase"));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 'i';
-    res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "multiline"));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 'm';
-    res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "dotAll"));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 's';
-    res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_unicode));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 'u';
-    res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "sticky"));
-    if (res < 0)
-        goto exception;
-    if (res)
-        *p++ = 'y';
+    for(i = 0; i < RE_FLAG_COUNT; i++) {
+        res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, flag_atom[i]));
+        if (res < 0)
+            goto exception;
+        if (res)
+            *p++ = flag_char[i];
+    }
     return JS_NewStringLen(ctx, str, p - str);
 
 exception:
@@ -42240,12 +45096,20 @@ static JSValue js_regexp_toString(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
-BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size)
+int lre_check_stack_overflow(void *opaque, size_t alloca_size)
 {
     JSContext *ctx = opaque;
     return js_check_stack_overflow(ctx->rt, alloca_size);
 }
 
+int lre_check_timeout(void *opaque)
+{
+    JSContext *ctx = opaque;
+    JSRuntime *rt = ctx->rt;
+    return (rt->interrupt_handler && 
+            rt->interrupt_handler(rt, rt->interrupt_opaque));
+}
+
 void *lre_realloc(void *opaque, void *ptr, size_t size)
 {
     JSContext *ctx = opaque;
@@ -42253,30 +45117,89 @@ void *lre_realloc(void *opaque, void *ptr, size_t size)
     return js_realloc_rt(ctx->rt, ptr, size);
 }
 
+static JSValue js_regexp_escape(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv)
+{
+    JSValue str;
+    StringBuffer b_s, *b = &b_s;
+    JSString *p;
+    uint32_t c, i;
+    char s[16];
+
+    if (!JS_IsString(argv[0]))
+        return JS_ThrowTypeError(ctx, "not a string");
+    str = JS_ToString(ctx, argv[0]); /* must call it to linearlize ropes */
+    if (JS_IsException(str))
+        return JS_EXCEPTION;
+    p = JS_VALUE_GET_STRING(str);
+    string_buffer_init2(ctx, b, 0, p->is_wide_char);
+    for (i = 0; i < p->len; i++) {
+        c = string_get(p, i);
+        if (c < 33) {
+            if (c >= 9 && c <= 13) {
+                string_buffer_putc8(b, '\\');
+                string_buffer_putc8(b, "tnvfr"[c - 9]);
+            } else {
+                goto hex2;
+            }
+        } else if (c < 128) {
+            if ((c >= '0' && c <= '9')
+             || (c >= 'A' && c <= 'Z')
+             || (c >= 'a' && c <= 'z')) {
+                if (i == 0)
+                    goto hex2;
+            } else if (strchr(",-=<>#&!%:;@~'`\"", c)) {
+                goto hex2;
+            } else if (c != '_') {
+                string_buffer_putc8(b, '\\');
+            }
+            string_buffer_putc8(b, c);
+        } else if (c < 256) {
+        hex2:
+            snprintf(s, sizeof(s), "\\x%02x", c);
+            string_buffer_puts8(b, s);
+        } else if (is_surrogate(c) || lre_is_space(c)) {
+            snprintf(s, sizeof(s), "\\u%04x", c);
+            string_buffer_puts8(b, s);
+        } else {
+            string_buffer_putc16(b, c);
+        }
+    }
+    JS_FreeValue(ctx, str);
+    return string_buffer_end(b);
+}
+
 static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
                               int argc, JSValueConst *argv)
 {
     JSRegExp *re = js_get_regexp(ctx, this_val, TRUE);
     JSString *str;
-    JSValue str_val, obj, val, groups = JS_UNDEFINED;
+    JSValue t, ret, str_val, obj, val, groups;
+    JSValue indices, indices_groups;
     uint8_t *re_bytecode;
-    int ret;
     uint8_t **capture, *str_buf;
-    int capture_count, shift, i, re_flags;
+    int rc, capture_count, shift, i, re_flags;
     int64_t last_index;
     const char *group_name_ptr;
 
     if (!re)
         return JS_EXCEPTION;
+
     str_val = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str_val))
-        return str_val;
-    val = JS_GetProperty(ctx, this_val, JS_ATOM_lastIndex);
-    if (JS_IsException(val) ||
-        JS_ToLengthFree(ctx, &last_index, val)) {
-        JS_FreeValue(ctx, str_val);
         return JS_EXCEPTION;
-    }
+
+    ret = JS_EXCEPTION;
+    obj = JS_NULL;
+    groups = JS_UNDEFINED;
+    indices = JS_UNDEFINED;
+    indices_groups = JS_UNDEFINED;
+    capture = NULL;
+
+    val = JS_GetProperty(ctx, this_val, JS_ATOM_lastIndex);
+    if (JS_IsException(val) || JS_ToLengthFree(ctx, &last_index, val))
+        goto fail;
+
     re_bytecode = re->bytecode->u.str8;
     re_flags = lre_get_flags(re_bytecode);
     if ((re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) == 0) {
@@ -42284,36 +45207,35 @@ static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
     }
     str = JS_VALUE_GET_STRING(str_val);
     capture_count = lre_get_capture_count(re_bytecode);
-    capture = NULL;
     if (capture_count > 0) {
         capture = js_malloc(ctx, sizeof(capture[0]) * capture_count * 2);
-        if (!capture) {
-            JS_FreeValue(ctx, str_val);
-            return JS_EXCEPTION;
-        }
+        if (!capture)
+            goto fail;
     }
     shift = str->is_wide_char;
     str_buf = str->u.str8;
     if (last_index > str->len) {
-        ret = 2;
+        rc = 2;
     } else {
-        ret = lre_exec(capture, re_bytecode,
-                       str_buf, last_index, str->len,
-                       shift, ctx);
+        rc = lre_exec(capture, re_bytecode,
+                      str_buf, last_index, str->len,
+                      shift, ctx);
     }
-    obj = JS_NULL;
-    if (ret != 1) {
-        if (ret >= 0) {
-            if (ret == 2 || (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY))) {
+    if (rc != 1) {
+        if (rc >= 0) {
+            if (rc == 2 || (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY))) {
                 if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
                                    JS_NewInt32(ctx, 0)) < 0)
                     goto fail;
             }
         } else {
-            JS_ThrowInternalError(ctx, "out of memory in regexp execution");
+            if (rc == LRE_RET_TIMEOUT) {
+                JS_ThrowInterrupted(ctx);
+            } else {
+                JS_ThrowInternalError(ctx, "out of memory in regexp execution");
+            }
             goto fail;
         }
-        JS_FreeValue(ctx, str_val);
     } else {
         int prop_flags;
         if (re_flags & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
@@ -42331,52 +45253,124 @@ static JSValue js_regexp_exec(JSContext *ctx, JSValueConst this_val,
             if (JS_IsException(groups))
                 goto fail;
         }
+        if (re_flags & LRE_FLAG_INDICES) {
+            indices = JS_NewArray(ctx);
+            if (JS_IsException(indices))
+                goto fail;
+            if (group_name_ptr) {
+                indices_groups = JS_NewObjectProto(ctx, JS_NULL);
+                if (JS_IsException(indices_groups))
+                    goto fail;
+            }
+        }
 
         for(i = 0; i < capture_count; i++) {
-            int start, end;
+            const char *name = NULL;
+            uint8_t **match = &capture[2 * i];
+            int start = -1;
+            int end = -1;
             JSValue val;
-            if (capture[2 * i] == NULL ||
-                capture[2 * i + 1] == NULL) {
+
+            if (group_name_ptr && i > 0) {
+                if (*group_name_ptr) name = group_name_ptr;
+                group_name_ptr += strlen(group_name_ptr) + 1;
+            }
+
+            if (match[0] && match[1]) {
+                start = (match[0] - str_buf) >> shift;
+                end = (match[1] - str_buf) >> shift;
+            }
+
+            if (!JS_IsUndefined(indices)) {
                 val = JS_UNDEFINED;
-            } else {
-                start = (capture[2 * i] - str_buf) >> shift;
-                end = (capture[2 * i + 1] - str_buf) >> shift;
+                if (start != -1) {
+                    val = JS_NewArray(ctx);
+                    if (JS_IsException(val))
+                        goto fail;
+                    if (JS_DefinePropertyValueUint32(ctx, val, 0,
+                                                     JS_NewInt32(ctx, start),
+                                                     prop_flags) < 0) {
+                        JS_FreeValue(ctx, val);
+                        goto fail;
+                    }
+                    if (JS_DefinePropertyValueUint32(ctx, val, 1,
+                                                     JS_NewInt32(ctx, end),
+                                                     prop_flags) < 0) {
+                        JS_FreeValue(ctx, val);
+                        goto fail;
+                    }
+                }
+                if (name && !JS_IsUndefined(indices_groups)) {
+                    val = JS_DupValue(ctx, val);
+                    if (JS_DefinePropertyValueStr(ctx, indices_groups,
+                                                  name, val, prop_flags) < 0) {
+                        JS_FreeValue(ctx, val);
+                        goto fail;
+                    }
+                }
+                if (JS_DefinePropertyValueUint32(ctx, indices, i, val,
+                                                 prop_flags) < 0) {
+                    goto fail;
+                }
+            }
+
+            val = JS_UNDEFINED;
+            if (start != -1) {
                 val = js_sub_string(ctx, str, start, end);
                 if (JS_IsException(val))
                     goto fail;
             }
-            if (group_name_ptr && i > 0) {
-                if (*group_name_ptr) {
-                    if (JS_DefinePropertyValueStr(ctx, groups, group_name_ptr,
-                                                  JS_DupValue(ctx, val),
-                                                  prop_flags) < 0) {
-                        JS_FreeValue(ctx, val);
-                        goto fail;
-                    }
+
+            if (name) {
+                if (JS_DefinePropertyValueStr(ctx, groups, name,
+                                              JS_DupValue(ctx, val),
+                                              prop_flags) < 0) {
+                    JS_FreeValue(ctx, val);
+                    goto fail;
                 }
-                group_name_ptr += strlen(group_name_ptr) + 1;
             }
+
             if (JS_DefinePropertyValueUint32(ctx, obj, i, val, prop_flags) < 0)
                 goto fail;
         }
-        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_groups,
-                                   groups, prop_flags) < 0)
+
+        t = JS_NewInt32(ctx, (capture[0] - str_buf) >> shift);
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_index, t, prop_flags) < 0)
+            goto fail;
+
+        t = str_val, str_val = JS_UNDEFINED;
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_input, t, prop_flags) < 0)
             goto fail;
-        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_index,
-                                   JS_NewInt32(ctx, (capture[0] - str_buf) >> shift), prop_flags) < 0)
+
+        t = groups, groups = JS_UNDEFINED;
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_groups,
+                                   t, prop_flags) < 0) {
             goto fail;
-        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_input, str_val, prop_flags) < 0)
-            goto fail1;
+        }
+
+        if (!JS_IsUndefined(indices)) {
+            t = indices_groups, indices_groups = JS_UNDEFINED;
+            if (JS_DefinePropertyValue(ctx, indices, JS_ATOM_groups,
+                                       t, prop_flags) < 0) {
+                goto fail;
+            }
+            t = indices, indices = JS_UNDEFINED;
+            if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_indices,
+                                       t, prop_flags) < 0) {
+                goto fail;
+            }
+        }
     }
-    js_free(ctx, capture);
-    return obj;
+    ret = obj;
+    obj = JS_UNDEFINED;
 fail:
-    JS_FreeValue(ctx, groups);
+    JS_FreeValue(ctx, indices_groups);
+    JS_FreeValue(ctx, indices);
     JS_FreeValue(ctx, str_val);
-fail1:
+    JS_FreeValue(ctx, groups);
     JS_FreeValue(ctx, obj);
     js_free(ctx, capture);
-    return JS_EXCEPTION;
+    return ret;
 }
 
 /* delete portions of a string that match a given regex */
@@ -42435,7 +45429,11 @@ static JSValue JS_RegExpDelete(JSContext *ctx, JSValueConst this_val, JSValueCon
                         goto fail;
                 }
             } else {
-                JS_ThrowInternalError(ctx, "out of memory in regexp execution");
+                if (ret == LRE_RET_TIMEOUT) {
+                    JS_ThrowInterrupted(ctx);
+                } else {
+                    JS_ThrowInternalError(ctx, "out of memory in regexp execution");
+                }
                 goto fail;
             }
             break;
@@ -42455,7 +45453,7 @@ static JSValue JS_RegExpDelete(JSContext *ctx, JSValueConst this_val, JSValueCon
             break;
         }
         if (end == start) {
-            if (!(re_flags & LRE_FLAG_UTF16) || (unsigned)end >= str->len || !str->is_wide_char) {
+            if (!(re_flags & LRE_FLAG_UNICODE) || (unsigned)end >= str->len || !str->is_wide_char) {
                 end++;
             } else {
                 string_getc(str, &end);
@@ -42551,14 +45549,12 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
         goto exception;
     p = JS_VALUE_GET_STRING(flags);
 
-    // TODO(bnoordhuis) query 'u' flag the same way?
     global = (-1 != string_indexof_char(p, 'g', 0));
     if (!global) {
         A = JS_RegExpExec(ctx, rx, S);
     } else {
-        fullUnicode = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_unicode));
-        if (fullUnicode < 0)
-            goto exception;
+        fullUnicode = (string_indexof_char(p, 'u', 0) >= 0 ||
+                       string_indexof_char(p, 'v', 0) >= 0);
 
         if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, JS_NewInt32(ctx, 0)) < 0)
             goto exception;
@@ -42577,7 +45573,7 @@ static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValueConst this_val,
             if (JS_IsException(matchStr))
                 goto exception;
             isEmpty = JS_IsEmptyString(matchStr);
-            if (JS_SetPropertyInt64(ctx, A, n++, matchStr) < 0)
+            if (JS_DefinePropertyValueInt64(ctx, A, n++, matchStr, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
                 goto exception;
             if (isEmpty) {
                 int64_t thisIndex, nextIndex;
@@ -42702,7 +45698,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     JSString *strp;
     int64_t lastIndex;
     JSRegExpStringIteratorData *it;
-    
+
     if (!JS_IsObject(R))
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
@@ -42710,7 +45706,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     flags = JS_UNDEFINED;
     matcher = JS_UNDEFINED;
     iter = JS_UNDEFINED;
-    
+
     S = JS_ToString(ctx, argv[0]);
     if (JS_IsException(S))
         goto exception;
@@ -42731,7 +45727,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex,
                        JS_NewInt64(ctx, lastIndex)) < 0)
         goto exception;
-    
+
     iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
     if (JS_IsException(iter))
         goto exception;
@@ -42742,7 +45738,8 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     it->iterated_string = S;
     strp = JS_VALUE_GET_STRING(flags);
     it->global = string_indexof_char(strp, 'g', 0) >= 0;
-    it->unicode = string_indexof_char(strp, 'u', 0) >= 0;
+    it->unicode = (string_indexof_char(strp, 'u', 0) >= 0 ||
+                   string_indexof_char(strp, 'v', 0) >= 0);
     it->done = FALSE;
     JS_SetOpaque(iter, it);
 
@@ -42870,7 +45867,7 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
     str = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str))
         goto exception;
-        
+
     sp = JS_VALUE_GET_STRING(str);
     rp = NULL;
     functionalReplace = JS_IsFunction(ctx, rep);
@@ -42889,13 +45886,11 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
         goto exception;
     p = JS_VALUE_GET_STRING(flags);
 
-    // TODO(bnoordhuis) query 'u' flag the same way?
     fullUnicode = 0;
     is_global = (-1 != string_indexof_char(p, 'g', 0));
     if (is_global) {
-        fullUnicode = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_unicode));
-        if (fullUnicode < 0)
-            goto exception;
+        fullUnicode = (string_indexof_char(p, 'u', 0) >= 0 ||
+                       string_indexof_char(p, 'v', 0) >= 0);
         if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, JS_NewInt32(ctx, 0)) < 0)
             goto exception;
     }
@@ -43121,7 +46116,8 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     if (JS_IsException(flags))
         goto exception;
     strp = JS_VALUE_GET_STRING(flags);
-    unicodeMatching = string_indexof_char(strp, 'u', 0) >= 0;
+    unicodeMatching = (string_indexof_char(strp, 'u', 0) >= 0 ||
+                       string_indexof_char(strp, 'v', 0) >= 0);
     if (string_indexof_char(strp, 'y', 0) < 0) {
         flags = JS_ConcatString3(ctx, "", flags, "y");
         if (JS_IsException(flags))
@@ -43158,7 +46154,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     while (q < size) {
         if (JS_SetProperty(ctx, splitter, JS_ATOM_lastIndex, JS_NewInt32(ctx, q)) < 0)
             goto exception;
-        JS_FreeValue(ctx, z);    
+        JS_FreeValue(ctx, z);
         z = JS_RegExpExec(ctx, splitter, str);
         if (JS_IsException(z))
             goto exception;
@@ -43184,7 +46180,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
                 if (js_get_length64(ctx, &numberOfCaptures, z))
                     goto exception;
                 for(i = 1; i < numberOfCaptures; i++) {
-                    sub = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, z, i));
+                    sub = JS_GetPropertyInt64(ctx, z, i);
                     if (JS_IsException(sub))
                         goto exception;
                     if (JS_DefinePropertyValueInt64(ctx, A, lengthA++, sub, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
@@ -43213,11 +46209,12 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     JS_FreeValue(ctx, ctor);
     JS_FreeValue(ctx, splitter);
     JS_FreeValue(ctx, flags);
-    JS_FreeValue(ctx, z);    
+    JS_FreeValue(ctx, z);
     return A;
 }
 
 static const JSCFunctionListEntry js_regexp_funcs[] = {
+    JS_CFUNC_DEF("escape", 1, js_regexp_escape ),
     JS_CGETSET_DEF("[Symbol.species]", js_get_this, NULL ),
     //JS_CFUNC_DEF("__RegExpExec", 2, js_regexp___RegExpExec ),
     //JS_CFUNC_DEF("__RegExpDelete", 2, js_regexp___RegExpDelete ),
@@ -43226,12 +46223,14 @@ static const JSCFunctionListEntry js_regexp_funcs[] = {
 static const JSCFunctionListEntry js_regexp_proto_funcs[] = {
     JS_CGETSET_DEF("flags", js_regexp_get_flags, NULL ),
     JS_CGETSET_DEF("source", js_regexp_get_source, NULL ),
-    JS_CGETSET_MAGIC_DEF("global", js_regexp_get_flag, NULL, 1 ),
-    JS_CGETSET_MAGIC_DEF("ignoreCase", js_regexp_get_flag, NULL, 2 ),
-    JS_CGETSET_MAGIC_DEF("multiline", js_regexp_get_flag, NULL, 4 ),
-    JS_CGETSET_MAGIC_DEF("dotAll", js_regexp_get_flag, NULL, 8 ),
-    JS_CGETSET_MAGIC_DEF("unicode", js_regexp_get_flag, NULL, 16 ),
-    JS_CGETSET_MAGIC_DEF("sticky", js_regexp_get_flag, NULL, 32 ),
+    JS_CGETSET_MAGIC_DEF("global", js_regexp_get_flag, NULL, LRE_FLAG_GLOBAL ),
+    JS_CGETSET_MAGIC_DEF("ignoreCase", js_regexp_get_flag, NULL, LRE_FLAG_IGNORECASE ),
+    JS_CGETSET_MAGIC_DEF("multiline", js_regexp_get_flag, NULL, LRE_FLAG_MULTILINE ),
+    JS_CGETSET_MAGIC_DEF("dotAll", js_regexp_get_flag, NULL, LRE_FLAG_DOTALL ),
+    JS_CGETSET_MAGIC_DEF("unicode", js_regexp_get_flag, NULL, LRE_FLAG_UNICODE ),
+    JS_CGETSET_MAGIC_DEF("unicodeSets", js_regexp_get_flag, NULL, LRE_FLAG_UNICODE_SETS ),
+    JS_CGETSET_MAGIC_DEF("sticky", js_regexp_get_flag, NULL, LRE_FLAG_STICKY ),
+    JS_CGETSET_MAGIC_DEF("hasIndices", js_regexp_get_flag, NULL, LRE_FLAG_INDICES ),
     JS_CFUNC_DEF("exec", 1, js_regexp_exec ),
     JS_CFUNC_DEF("compile", 2, js_regexp_compile ),
     JS_CFUNC_DEF("test", 1, js_regexp_test ),
@@ -43298,7 +46297,7 @@ static JSValue json_parse_value(JSParseState *s)
         {
             JSValue prop_val;
             JSAtom prop_name;
-            
+
             if (json_next_token(s))
                 goto fail;
             val = JS_NewObject(ctx);
@@ -43389,9 +46388,15 @@ static JSValue json_parse_value(JSParseState *s)
     case TOK_IDENT:
         if (s->token.u.ident.atom == JS_ATOM_false ||
             s->token.u.ident.atom == JS_ATOM_true) {
-            val = JS_NewBool(ctx, (s->token.u.ident.atom == JS_ATOM_true));
+            val = JS_NewBool(ctx, s->token.u.ident.atom == JS_ATOM_true);
         } else if (s->token.u.ident.atom == JS_ATOM_null) {
             val = JS_NULL;
+        } else if (s->token.u.ident.atom == JS_ATOM_NaN && s->ext_json) {
+            /* Note: json5 identifier handling is ambiguous e.g. is 
+               '{ NaN: 1 }' a valid JSON5 production ? */ 
+            val = JS_NewFloat64(s->ctx, NAN);
+        } else if (s->token.u.ident.atom == JS_ATOM_Infinity && s->ext_json) {
+            val = JS_NewFloat64(s->ctx, INFINITY);
         } else {
             goto def_token;
         }
@@ -43401,7 +46406,7 @@ static JSValue json_parse_value(JSParseState *s)
     default:
     def_token:
         if (s->token.val == TOK_EOF) {
-            js_parse_error(s, "unexpected end of input");
+            js_parse_error(s, "Unexpected end of JSON input");
         } else {
             js_parse_error(s, "unexpected token: '%.*s'",
                            (int)(s->buf_ptr - s->token.ptr), s->token.ptr);
@@ -43441,7 +46446,7 @@ JSValue JS_ParseJSON2(JSContext *ctx, const char *buf, size_t buf_len,
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
                      const char *filename)
 {
-    return JS_ParseJSON2(ctx, buf, buf_len, filename, 0); 
+    return JS_ParseJSON2(ctx, buf, buf_len, filename, 0);
 }
 
 static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
@@ -43496,7 +46501,7 @@ static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
                 goto fail;
         }
     }
-    js_free_prop_enum(ctx, atoms, len);
+    JS_FreePropertyEnum(ctx, atoms, len);
     atoms = NULL;
     name_val = JS_AtomToValue(ctx, name);
     if (JS_IsException(name_val))
@@ -43508,7 +46513,7 @@ static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
     JS_FreeValue(ctx, val);
     return res;
  fail:
-    js_free_prop_enum(ctx, atoms, len);
+    JS_FreePropertyEnum(ctx, atoms, len);
     JS_FreeValue(ctx, val);
     return JS_EXCEPTION;
 }
@@ -43568,22 +46573,22 @@ static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
     JSValue v;
     JSValueConst args[2];
 
-    if (JS_IsObject(val) ||
-        JS_IsBigInt(ctx, val)   /* XXX: probably useless */
-        ) {
-            JSValue f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
-            if (JS_IsException(f))
+    /* check for object.toJSON method */
+    /* ECMA specifies this is done only for Object and BigInt */
+    if (JS_IsObject(val) || JS_IsBigInt(ctx, val)) {
+        JSValue f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
+        if (JS_IsException(f))
+            goto exception;
+        if (JS_IsFunction(ctx, f)) {
+            v = JS_CallFree(ctx, f, val, 1, &key);
+            JS_FreeValue(ctx, val);
+            val = v;
+            if (JS_IsException(val))
                 goto exception;
-            if (JS_IsFunction(ctx, f)) {
-                v = JS_CallFree(ctx, f, val, 1, &key);
-                JS_FreeValue(ctx, val);
-                val = v;
-                if (JS_IsException(val))
-                    goto exception;
-            } else {
-                JS_FreeValue(ctx, f);
-            }
+        } else {
+            JS_FreeValue(ctx, f);
         }
+    }
 
     if (!JS_IsUndefined(jsc->replacer_func)) {
         args[0] = key;
@@ -43600,13 +46605,12 @@ static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
         if (JS_IsFunction(ctx, val))
             break;
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
     case JS_TAG_INT:
     case JS_TAG_FLOAT64:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif
     case JS_TAG_BOOL:
     case JS_TAG_NULL:
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
     case JS_TAG_EXCEPTION:
         return val;
@@ -43630,43 +46634,36 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
     int64_t i, len;
     int cl, ret;
     BOOL has_content;
-    
+
     indent1 = JS_UNDEFINED;
     sep = JS_UNDEFINED;
     sep1 = JS_UNDEFINED;
     tab = JS_UNDEFINED;
     prop = JS_UNDEFINED;
 
-    switch (JS_VALUE_GET_NORM_TAG(val)) {
-    case JS_TAG_OBJECT:
+    if (js_check_stack_overflow(ctx->rt, 0)) {
+        JS_ThrowStackOverflow(ctx);
+        goto exception;
+    }
+
+    if (JS_IsObject(val)) {
         p = JS_VALUE_GET_OBJ(val);
         cl = p->class_id;
         if (cl == JS_CLASS_STRING) {
             val = JS_ToStringFree(ctx, val);
             if (JS_IsException(val))
                 goto exception;
-            val = JS_ToQuotedStringFree(ctx, val);
-            if (JS_IsException(val))
-                goto exception;
-            return string_buffer_concat_value_free(jsc->b, val);
+            goto concat_primitive;
         } else if (cl == JS_CLASS_NUMBER) {
             val = JS_ToNumberFree(ctx, val);
             if (JS_IsException(val))
                 goto exception;
-            return string_buffer_concat_value_free(jsc->b, val);
-        } else if (cl == JS_CLASS_BOOLEAN) {
-            ret = string_buffer_concat_value(jsc->b, p->u.object_data);
-            JS_FreeValue(ctx, val);
-            return ret;
-        } else
-#ifdef CONFIG_BIGNUM
-        if (cl == JS_CLASS_BIG_FLOAT) {
-            return string_buffer_concat_value_free(jsc->b, val);
-        } else
-#endif
-        if (cl == JS_CLASS_BIG_INT) {
-            JS_ThrowTypeError(ctx, "bigint are forbidden in JSON.stringify");
-            goto exception;
+            goto concat_primitive;
+        } else if (cl == JS_CLASS_BOOLEAN || cl == JS_CLASS_BIG_INT)
+        {
+            /* This will thow the same error as for the primitive object */
+            set_value(ctx, &val, JS_DupValue(ctx, p->u.object_data));
+            goto concat_primitive;
         }
         v = js_array_includes(ctx, jsc->stack, 1, (JSValueConst *)&val);
         if (JS_IsException(v))
@@ -43682,7 +46679,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
             sep = JS_ConcatString3(ctx, "\n", JS_DupValue(ctx, indent1), "");
             if (JS_IsException(sep))
                 goto exception;
-            sep1 = JS_NewString(ctx, " ");
+            sep1 = js_new_string8(ctx, " ");
             if (JS_IsException(sep1))
                 goto exception;
         } else {
@@ -43764,7 +46761,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
                     has_content = TRUE;
                 }
             }
-            if (has_content && JS_VALUE_GET_STRING(jsc->gap)->len != 0) {
+            if (has_content && !JS_IsEmptyString(jsc->gap)) {
                 string_buffer_putc8(jsc->b, '\n');
                 string_buffer_concat_value(jsc->b, indent);
             }
@@ -43779,7 +46776,11 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         JS_FreeValue(ctx, indent1);
         JS_FreeValue(ctx, prop);
         return 0;
+    }
+ concat_primitive:
+    switch (JS_VALUE_GET_NORM_TAG(val)) {
     case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
         val = JS_ToQuotedStringFree(ctx, val);
         if (JS_IsException(val))
             goto exception;
@@ -43790,21 +46791,20 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         }
         goto concat_value;
     case JS_TAG_INT:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif
     case JS_TAG_BOOL:
     case JS_TAG_NULL:
     concat_value:
         return string_buffer_concat_value_free(jsc->b, val);
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
-        JS_ThrowTypeError(ctx, "bigint are forbidden in JSON.stringify");
+        /* reject big numbers: use toJSON method to override */
+        JS_ThrowTypeError(ctx, "Do not know how to serialize a BigInt");
         goto exception;
     default:
         JS_FreeValue(ctx, val);
         return 0;
     }
-    
+
 exception:
     JS_FreeValue(ctx, val);
     JS_FreeValue(ctx, tab);
@@ -43905,7 +46905,7 @@ JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
         int n;
         if (JS_ToInt32Clamp(ctx, &n, space, 0, 10, 0))
             goto exception;
-        jsc->gap = JS_NewStringLen(ctx, "          ", n);
+        jsc->gap = js_new_string8_len(ctx, "          ", n);
     } else if (JS_IsString(space)) {
         JSString *p = JS_VALUE_GET_STRING(space);
         jsc->gap = js_sub_string(ctx, p, 0, min_int(p->len, 10));
@@ -43922,7 +46922,7 @@ JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
                                JS_DupValue(ctx, obj), JS_PROP_C_W_E) < 0)
         goto exception;
     val = JS_DupValue(ctx, obj);
-                           
+
     val = js_json_check(ctx, jsc, wrapper, val, jsc->empty);
     if (JS_IsException(val))
         goto exception;
@@ -44178,7 +47178,7 @@ static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
         JS_ThrowStackOverflow(ctx);
         return NULL;
     }
-    
+
     /* 's' should never be NULL */
     if (s->is_revoked) {
         JS_ThrowTypeErrorRevokedProxy(ctx);
@@ -44193,7 +47193,7 @@ static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
     return s;
 }
 
-static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
+static JSValue js_proxy_get_prototype(JSContext *ctx, JSValueConst obj)
 {
     JSProxyData *s;
     JSValue method, ret, proto1;
@@ -44223,7 +47223,7 @@ static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
             JS_FreeValue(ctx, ret);
             return JS_EXCEPTION;
         }
-        if (JS_VALUE_GET_OBJ(proto1) != JS_VALUE_GET_OBJ(ret)) {
+        if (!js_same_value(ctx, proto1, ret)) {
             JS_FreeValue(ctx, proto1);
         fail:
             JS_FreeValue(ctx, ret);
@@ -44234,8 +47234,8 @@ static JSValue js_proxy_getPrototypeOf(JSContext *ctx, JSValueConst obj)
     return ret;
 }
 
-static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
-                                   JSValueConst proto_val, BOOL throw_flag)
+static int js_proxy_set_prototype(JSContext *ctx, JSValueConst obj,
+                                  JSValueConst proto_val)
 {
     JSProxyData *s;
     JSValue method, ret, proto1;
@@ -44247,21 +47247,15 @@ static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
     if (!s)
         return -1;
     if (JS_IsUndefined(method))
-        return JS_SetPrototypeInternal(ctx, s->target, proto_val, throw_flag);
+        return JS_SetPrototypeInternal(ctx, s->target, proto_val, FALSE);
     args[0] = s->target;
     args[1] = proto_val;
     ret = JS_CallFree(ctx, method, s->handler, 2, args);
     if (JS_IsException(ret))
         return -1;
     res = JS_ToBoolFree(ctx, ret);
-    if (!res) {
-        if (throw_flag) {
-            JS_ThrowTypeError(ctx, "proxy: bad prototype");
-            return -1;
-        } else {
-            return FALSE;
-        }
-    }
+    if (!res)
+        return FALSE;
     res2 = JS_IsExtensible(ctx, s->target);
     if (res2 < 0)
         return -1;
@@ -44269,7 +47263,7 @@ static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
         proto1 = JS_GetPrototype(ctx, s->target);
         if (JS_IsException(proto1))
             return -1;
-        if (JS_VALUE_GET_OBJ(proto_val) != JS_VALUE_GET_OBJ(proto1)) {
+        if (!js_same_value(ctx, proto_val, proto1)) {
             JS_FreeValue(ctx, proto1);
             JS_ThrowTypeError(ctx, "proxy: inconsistent prototype");
             return -1;
@@ -44279,7 +47273,7 @@ static int js_proxy_setPrototypeOf(JSContext *ctx, JSValueConst obj,
     return TRUE;
 }
 
-static int js_proxy_isExtensible(JSContext *ctx, JSValueConst obj)
+static int js_proxy_is_extensible(JSContext *ctx, JSValueConst obj)
 {
     JSProxyData *s;
     JSValue method, ret;
@@ -44305,7 +47299,7 @@ static int js_proxy_isExtensible(JSContext *ctx, JSValueConst obj)
     return res;
 }
 
-static int js_proxy_preventExtensions(JSContext *ctx, JSValueConst obj)
+static int js_proxy_prevent_extensions(JSContext *ctx, JSValueConst obj)
 {
     JSProxyData *s;
     JSValue method, ret;
@@ -44405,8 +47399,10 @@ static JSValue js_proxy_get(JSContext *ctx, JSValueConst obj, JSAtom atom,
     if (JS_IsException(ret))
         return JS_EXCEPTION;
     res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
-    if (res < 0)
+    if (res < 0) {
+        JS_FreeValue(ctx, ret);
         return JS_EXCEPTION;
+    }
     if (res) {
         if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0) {
             if (!js_same_value(ctx, desc.value, ret)) {
@@ -44505,17 +47501,17 @@ static JSValue js_create_desc(JSContext *ctx, JSValueConst val,
     }
     if (flags & JS_PROP_HAS_WRITABLE) {
         JS_DefinePropertyValue(ctx, ret, JS_ATOM_writable,
-                               JS_NewBool(ctx, (flags & JS_PROP_WRITABLE) != 0),
+                               JS_NewBool(ctx, flags & JS_PROP_WRITABLE),
                                JS_PROP_C_W_E);
     }
     if (flags & JS_PROP_HAS_ENUMERABLE) {
         JS_DefinePropertyValue(ctx, ret, JS_ATOM_enumerable,
-                               JS_NewBool(ctx, (flags & JS_PROP_ENUMERABLE) != 0),
+                               JS_NewBool(ctx, flags & JS_PROP_ENUMERABLE),
                                JS_PROP_C_W_E);
     }
     if (flags & JS_PROP_HAS_CONFIGURABLE) {
         JS_DefinePropertyValue(ctx, ret, JS_ATOM_configurable,
-                               JS_NewBool(ctx, (flags & JS_PROP_CONFIGURABLE) != 0),
+                               JS_NewBool(ctx, flags & JS_PROP_CONFIGURABLE),
                                JS_PROP_C_W_E);
     }
     return ret;
@@ -44577,6 +47573,14 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
         JS_FreeValue(ctx, trap_result_obj);
         if (res < 0)
             return -1;
+
+        /* convert the result_desc.flags to property flags */
+        if (result_desc.flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
+            result_desc.flags |= JS_PROP_GETSET;
+        } else {
+            result_desc.flags |= JS_PROP_NORMAL;
+        }
+        result_desc.flags &= (JS_PROP_C_W_E | JS_PROP_TMASK);
         
         if (target_desc_ret) {
             /* convert result_desc.flags to defineProperty flags */
@@ -44676,13 +47680,11 @@ static int js_proxy_define_own_property(JSContext *ctx, JSValueConst obj,
         if (!p->extensible || setting_not_configurable)
             goto fail;
     } else {
-        if (!check_define_prop_flags(desc.flags, flags) ||
-            ((desc.flags & JS_PROP_CONFIGURABLE) && setting_not_configurable)) {
+        if (!check_define_prop_flags(desc.flags, flags))
             goto fail1;
-        }
-        if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
-            if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE)) ==
-                JS_PROP_GETSET) {
+        /* do the missing check from check_define_prop_flags() */
+        if (!(desc.flags & JS_PROP_CONFIGURABLE)) {
+            if ((desc.flags & JS_PROP_TMASK) == JS_PROP_GETSET) {
                 if ((flags & JS_PROP_HAS_GET) &&
                     !js_same_value(ctx, getter, desc.getter)) {
                     goto fail1;
@@ -44691,27 +47693,26 @@ static int js_proxy_define_own_property(JSContext *ctx, JSValueConst obj,
                     !js_same_value(ctx, setter, desc.setter)) {
                     goto fail1;
                 }
-            }
-        } else if (flags & JS_PROP_HAS_VALUE) {
-            if ((desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) ==
-                JS_PROP_WRITABLE && !(flags & JS_PROP_WRITABLE)) {
-                /* missing-proxy-check feature */
-                goto fail1;
-            } else if ((desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0 &&
-                !js_same_value(ctx, val, desc.value)) {
-                goto fail1;
+            } else if (!(desc.flags & JS_PROP_WRITABLE)) {
+                if ((flags & JS_PROP_HAS_VALUE) &&
+                    !js_same_value(ctx, val, desc.value)) {
+                    goto fail1;
+                }
             }
         }
-        if (flags & JS_PROP_HAS_WRITABLE) {
-            if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE |
-                               JS_PROP_WRITABLE)) == JS_PROP_WRITABLE) {
-                /* proxy-missing-checks */
-            fail1:
-                js_free_desc(ctx, &desc);
-            fail:
-                JS_ThrowTypeError(ctx, "proxy: inconsistent defineProperty");
-                return -1;
-            }
+
+        /* additional checks */
+        if ((desc.flags & JS_PROP_CONFIGURABLE) && setting_not_configurable)
+            goto fail1;
+
+        if ((desc.flags & JS_PROP_TMASK) != JS_PROP_GETSET &&
+            (desc.flags & (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == JS_PROP_WRITABLE &&
+            (flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) == JS_PROP_HAS_WRITABLE) {
+        fail1:
+            js_free_desc(ctx, &desc);
+        fail:
+            JS_ThrowTypeError(ctx, "proxy: inconsistent defineProperty");
+            return -1;
         }
         js_free_desc(ctx, &desc);
     }
@@ -44886,14 +47887,14 @@ static int js_proxy_get_own_property_names(JSContext *ctx,
         }
     }
 
-    js_free_prop_enum(ctx, tab2, len2);
+    JS_FreePropertyEnum(ctx, tab2, len2);
     JS_FreeValue(ctx, prop_array);
     *ptab = tab;
     *plen = len;
     return 0;
  fail:
-    js_free_prop_enum(ctx, tab2, len2);
-    js_free_prop_enum(ctx, tab, len);
+    JS_FreePropertyEnum(ctx, tab2, len2);
+    JS_FreePropertyEnum(ctx, tab, len);
     JS_FreeValue(ctx, prop_array);
     return -1;
 }
@@ -44942,7 +47943,7 @@ static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
 
     if (flags & JS_CALL_FLAG_CONSTRUCTOR)
         return js_proxy_call_constructor(ctx, func_obj, this_obj, argc, argv);
-    
+
     s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
     if (!s)
         return JS_EXCEPTION;
@@ -44967,20 +47968,35 @@ static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
     return ret;
 }
 
-static int js_proxy_isArray(JSContext *ctx, JSValueConst obj)
-{
-    JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
-    if (!s)
-        return FALSE;
-    if (js_check_stack_overflow(ctx->rt, 0)) {
-        JS_ThrowStackOverflow(ctx);
-        return -1;
-    }
-    if (s->is_revoked) {
-        JS_ThrowTypeErrorRevokedProxy(ctx);
-        return -1;
+/* `js_resolve_proxy`: resolve the proxy chain
+   `*pval` is updated with to ultimate proxy target
+   `throw_exception` controls whether exceptions are thown or not
+   - return -1 in case of error
+   - otherwise return 0
+ */
+static int js_resolve_proxy(JSContext *ctx, JSValueConst *pval, BOOL throw_exception) {
+    int depth = 0;
+    JSObject *p;
+    JSProxyData *s;
+
+    while (JS_VALUE_GET_TAG(*pval) == JS_TAG_OBJECT) {
+        p = JS_VALUE_GET_OBJ(*pval);
+        if (p->class_id != JS_CLASS_PROXY)
+            break;
+        if (depth++ > 1000) {
+            if (throw_exception)
+                JS_ThrowStackOverflow(ctx);
+            return -1;
+        }
+        s = p->u.opaque;
+        if (s->is_revoked) {
+            if (throw_exception)
+                JS_ThrowTypeErrorRevokedProxy(ctx);
+            return -1;
+        }
+        *pval = s->target;
     }
-    return JS_IsArray(ctx, s->target);
+    return 0;
 }
 
 static const JSClassExoticMethods js_proxy_exotic_methods = {
@@ -44991,6 +48007,10 @@ static const JSClassExoticMethods js_proxy_exotic_methods = {
     .has_property = js_proxy_has,
     .get_property = js_proxy_get,
     .set_property = js_proxy_set,
+    .get_prototype = js_proxy_get_prototype,
+    .set_prototype = js_proxy_set_prototype,
+    .is_extensible = js_proxy_is_extensible,
+    .prevent_extensions = js_proxy_prevent_extensions,
 };
 
 static JSValue js_proxy_constructor(JSContext *ctx, JSValueConst this_val,
@@ -45210,26 +48230,78 @@ static const JSCFunctionListEntry js_symbol_funcs[] = {
 
 /* Set/Map/WeakSet/WeakMap */
 
-typedef struct JSMapRecord {
-    int ref_count; /* used during enumeration to avoid freeing the record */
-    BOOL empty; /* TRUE if the record is deleted */
-    struct JSMapState *map;
-    struct JSMapRecord *next_weak_ref;
-    struct list_head link;
-    struct list_head hash_link;
-    JSValue key;
-    JSValue value;
-} JSMapRecord;
+static BOOL js_weakref_is_target(JSValueConst val)
+{
+    switch (JS_VALUE_GET_TAG(val)) {
+    case JS_TAG_OBJECT:
+        return TRUE;
+    case JS_TAG_SYMBOL:
+        {
+            JSAtomStruct *p = JS_VALUE_GET_PTR(val);
+            if (p->atom_type == JS_ATOM_TYPE_SYMBOL &&
+                p->hash != JS_ATOM_HASH_PRIVATE)
+                return TRUE;
+        }
+        break;
+    default:
+        break;
+    }
+    return FALSE;
+}
 
-typedef struct JSMapState {
-    BOOL is_weak; /* TRUE if WeakSet/WeakMap */
-    struct list_head records; /* list of JSMapRecord.link */
-    uint32_t record_count;
-    struct list_head *hash_table;
-    uint32_t hash_size; /* must be a power of two */
-    uint32_t record_count_threshold; /* count at which a hash table
-                                        resize is needed */
-} JSMapState;
+/* JS_UNDEFINED is considered as a live weakref */
+/* XXX: add a specific JSWeakRef value type ? */
+static BOOL js_weakref_is_live(JSValueConst val)
+{
+    int *pref_count;
+    if (JS_IsUndefined(val))
+        return TRUE;
+    pref_count = JS_VALUE_GET_PTR(val);
+    return (*pref_count != 0);
+}
+
+/* 'val' can be JS_UNDEFINED */
+static void js_weakref_free(JSRuntime *rt, JSValue val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(val);
+        assert(p->weakref_count >= 1);
+        p->weakref_count--;
+        /* 'mark' is tested to avoid freeing the object structure when
+           it is about to be freed in a cycle or in
+           free_zero_refcount() */
+        if (p->weakref_count == 0 && p->header.ref_count == 0 &&
+            p->header.mark == 0) {
+            js_free_rt(rt, p);
+        }
+    } else if (JS_VALUE_GET_TAG(val) == JS_TAG_SYMBOL) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        assert(p->hash >= 1);
+        p->hash--;
+        if (p->hash == 0 && p->header.ref_count == 0) {
+            /* can remove the dummy structure */
+            js_free_rt(rt, p);
+        }
+    }
+}
+
+/* val must be an object, a symbol or undefined (see
+   js_weakref_is_target). */
+static JSValue js_weakref_new(JSContext *ctx, JSValueConst val)
+{
+    if (JS_VALUE_GET_TAG(val) == JS_TAG_OBJECT) {
+        JSObject *p = JS_VALUE_GET_OBJ(val);
+        p->weakref_count++;
+    } else if (JS_VALUE_GET_TAG(val) == JS_TAG_SYMBOL) {
+        JSString *p = JS_VALUE_GET_STRING(val);
+        /* XXX: could return an exception if too many references */
+        assert(p->hash < JS_ATOM_HASH_MASK - 2);
+        p->hash++;
+    } else {
+        assert(JS_IsUndefined(val));
+    }
+    return (JSValue)val;
+}
 
 #define MAGIC_SET (1 << 0)
 #define MAGIC_WEAK (1 << 1)
@@ -45252,12 +48324,16 @@ static JSValue js_map_constructor(JSContext *ctx, JSValueConst new_target,
         goto fail;
     init_list_head(&s->records);
     s->is_weak = is_weak;
+    if (is_weak) {
+        s->weakref_header.weakref_type = JS_WEAKREF_TYPE_MAP;
+        list_add_tail(&s->weakref_header.link, &ctx->rt->weakref_list);
+    }
     JS_SetOpaque(obj, s);
-    s->hash_size = 1;
-    s->hash_table = js_malloc(ctx, sizeof(s->hash_table[0]) * s->hash_size);
+    s->hash_bits = 1;
+    s->hash_size = 1U << s->hash_bits;
+    s->hash_table = js_mallocz(ctx, sizeof(s->hash_table[0]) * s->hash_size);
     if (!s->hash_table)
         goto fail;
-    init_list_head(&s->hash_table[0]);
     s->record_count_threshold = 4;
 
     arr = JS_UNDEFINED;
@@ -45286,15 +48362,13 @@ static JSValue js_map_constructor(JSContext *ctx, JSValueConst new_target,
             item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
             if (JS_IsException(item))
                 goto fail;
-            if (done) {
-                JS_FreeValue(ctx, item);
+            if (done)
                 break;
-            }
             if (is_set) {
                 ret = JS_Call(ctx, adder, obj, 1, (JSValueConst *)&item);
                 if (JS_IsException(ret)) {
                     JS_FreeValue(ctx, item);
-                    goto fail;
+                    goto fail_close;
                 }
             } else {
                 JSValue key, value;
@@ -45319,7 +48393,7 @@ static JSValue js_map_constructor(JSContext *ctx, JSValueConst new_target,
                     JS_FreeValue(ctx, item);
                     JS_FreeValue(ctx, key);
                     JS_FreeValue(ctx, value);
-                    goto fail;
+                    goto fail_close;
                 }
                 JS_FreeValue(ctx, key);
                 JS_FreeValue(ctx, value);
@@ -45332,11 +48406,10 @@ static JSValue js_map_constructor(JSContext *ctx, JSValueConst new_target,
         JS_FreeValue(ctx, adder);
     }
     return obj;
+ fail_close:
+    /* close the iterator object, preserving pending exception */
+    JS_IteratorClose(ctx, iter, TRUE);
  fail:
-    if (JS_IsObject(iter)) {
-        /* close the iterator object, preserving pending exception */
-        JS_IteratorClose(ctx, iter, TRUE);
-    }
     JS_FreeValue(ctx, next_method);
     JS_FreeValue(ctx, iter);
     JS_FreeValue(ctx, adder);
@@ -45355,27 +48428,56 @@ static JSValueConst map_normalize_key(JSContext *ctx, JSValueConst key)
     return key;
 }
 
+/* hash multipliers, same as the Linux kernel (see Knuth vol 3,
+   section 6.4, exercise 9) */
+#define HASH_MUL32 0x61C88647
+#define HASH_MUL64 UINT64_C(0x61C8864680B583EB)
+
+static uint32_t map_hash32(uint32_t a, int hash_bits)
+{
+    return (a * HASH_MUL32) >> (32 - hash_bits);
+}
+
+static uint32_t map_hash64(uint64_t a, int hash_bits)
+{
+    return (a * HASH_MUL64) >> (64 - hash_bits);
+}
+
+static uint32_t map_hash_pointer(uintptr_t a, int hash_bits)
+{
+#ifdef JS_PTR64
+    return map_hash64(a, hash_bits);
+#else
+    return map_hash32(a, hash_bits);
+#endif
+}
+
 /* XXX: better hash ? */
-static uint32_t map_hash_key(JSContext *ctx, JSValueConst key)
+/* precondition: 1 <= hash_bits <= 32 */
+static uint32_t map_hash_key(JSValueConst key, int hash_bits)
 {
     uint32_t tag = JS_VALUE_GET_NORM_TAG(key);
     uint32_t h;
     double d;
-    JSFloat64Union u;
-
+    JSBigInt *p;
+    JSBigIntBuf buf;
+    
     switch(tag) {
     case JS_TAG_BOOL:
-        h = JS_VALUE_GET_INT(key);
+        h = map_hash32(JS_VALUE_GET_INT(key) ^ JS_TAG_BOOL, hash_bits);
         break;
     case JS_TAG_STRING:
-        h = hash_string(JS_VALUE_GET_STRING(key), 0);
+        h = map_hash32(hash_string(JS_VALUE_GET_STRING(key), 0) ^ JS_TAG_STRING, hash_bits);
+        break;
+    case JS_TAG_STRING_ROPE:
+        h = map_hash32(hash_string_rope(key, 0) ^ JS_TAG_STRING, hash_bits);
         break;
     case JS_TAG_OBJECT:
     case JS_TAG_SYMBOL:
-        h = (uintptr_t)JS_VALUE_GET_PTR(key) * 3163;
+        h = map_hash_pointer((uintptr_t)JS_VALUE_GET_PTR(key) ^ tag, hash_bits);
         break;
     case JS_TAG_INT:
-        d = JS_VALUE_GET_INT(key) * 3163;
+        d = JS_VALUE_GET_INT(key);
         goto hash_float64;
     case JS_TAG_FLOAT64:
         d = JS_VALUE_GET_FLOAT64(key);
@@ -45383,61 +48485,77 @@ static uint32_t map_hash_key(JSContext *ctx, JSValueConst key)
         if (isnan(d))
             d = JS_FLOAT64_NAN;
     hash_float64:
-        u.d = d;
-        h = (u.u32[0] ^ u.u32[1]) * 3163;
+        h = map_hash64(float64_as_uint64(d) ^ JS_TAG_FLOAT64, hash_bits);
+        break;
+    case JS_TAG_SHORT_BIG_INT:
+        p = js_bigint_set_short(&buf, key);
+        goto hash_bigint;
+    case JS_TAG_BIG_INT:
+        p = JS_VALUE_GET_PTR(key);
+    hash_bigint:
+        {
+            int i;
+            h = 1;
+            for(i = p->len - 1; i >= 0; i--) {
+                h = h * 263 + p->tab[i];
+            }
+            /* the final step is necessary otherwise h mod n only
+               depends of p->tab[i] mod n */
+            h = map_hash32(h ^ JS_TAG_BIG_INT, hash_bits);
+        }
         break;
     default:
-        h = 0; /* XXX: bignum support */
+        h = 0;
         break;
     }
-    h ^= tag;
     return h;
 }
 
 static JSMapRecord *map_find_record(JSContext *ctx, JSMapState *s,
                                     JSValueConst key)
 {
-    struct list_head *el;
     JSMapRecord *mr;
     uint32_t h;
-    h = map_hash_key(ctx, key) & (s->hash_size - 1);
-    list_for_each(el, &s->hash_table[h]) {
-        mr = list_entry(el, JSMapRecord, hash_link);
-        if (js_same_value_zero(ctx, mr->key, key))
-            return mr;
+    h = map_hash_key(key, s->hash_bits);
+    for(mr = s->hash_table[h]; mr != NULL; mr = mr->hash_next) {
+        if (mr->empty || (s->is_weak && !js_weakref_is_live(mr->key))) {
+            /* cannot match */
+        } else {
+            if (js_same_value_zero(ctx, mr->key, key))
+                return mr;
+        }
     }
     return NULL;
 }
 
 static void map_hash_resize(JSContext *ctx, JSMapState *s)
 {
-    uint32_t new_hash_size, i, h;
-    size_t slack;
-    struct list_head *new_hash_table, *el;
-    JSMapRecord *mr;
+    uint32_t new_hash_size, h;
+    int new_hash_bits;
+    struct list_head *el;
+    JSMapRecord *mr, **new_hash_table;
 
     /* XXX: no reporting of memory allocation failure */
-    if (s->hash_size == 1)
-        new_hash_size = 4;
-    else
-        new_hash_size = s->hash_size * 2;
-    new_hash_table = js_realloc2(ctx, s->hash_table,
-                                 sizeof(new_hash_table[0]) * new_hash_size, &slack);
+    new_hash_bits = min_int(s->hash_bits + 1, 31);
+    new_hash_size = 1U << new_hash_bits;
+    new_hash_table = js_realloc(ctx, s->hash_table,
+                                sizeof(new_hash_table[0]) * new_hash_size);
     if (!new_hash_table)
         return;
-    new_hash_size += slack / sizeof(*new_hash_table);
 
-    for(i = 0; i < new_hash_size; i++)
-        init_list_head(&new_hash_table[i]);
+    memset(new_hash_table, 0, sizeof(new_hash_table[0]) * new_hash_size);
 
     list_for_each(el, &s->records) {
         mr = list_entry(el, JSMapRecord, link);
-        if (!mr->empty) {
-            h = map_hash_key(ctx, mr->key) & (new_hash_size - 1);
-            list_add_tail(&mr->hash_link, &new_hash_table[h]);
+        if (mr->empty || (s->is_weak && !js_weakref_is_live(mr->key))) {
+        } else {
+            h = map_hash_key(mr->key, new_hash_bits);
+            mr->hash_next = new_hash_table[h];
+            new_hash_table[h] = mr;
         }
     }
     s->hash_table = new_hash_table;
+    s->hash_bits = new_hash_bits;
     s->hash_size = new_hash_size;
     s->record_count_threshold = new_hash_size * 2;
 }
@@ -45452,19 +48570,15 @@ static JSMapRecord *map_add_record(JSContext *ctx, JSMapState *s,
     if (!mr)
         return NULL;
     mr->ref_count = 1;
-    mr->map = s;
     mr->empty = FALSE;
     if (s->is_weak) {
-        JSObject *p = JS_VALUE_GET_OBJ(key);
-        /* Add the weak reference */
-        mr->next_weak_ref = p->first_weak_ref;
-        p->first_weak_ref = mr;
+        mr->key = js_weakref_new(ctx, key);
     } else {
-        JS_DupValue(ctx, key);
+        mr->key = JS_DupValue(ctx, key);
     }
-    mr->key = (JSValue)key;
-    h = map_hash_key(ctx, key) & (s->hash_size - 1);
-    list_add_tail(&mr->hash_link, &s->hash_table[h]);
+    h = map_hash_key(key, s->hash_bits);
+    mr->hash_next = s->hash_table[h];
+    s->hash_table[h] = mr;
     list_add_tail(&mr->link, &s->records);
     s->record_count++;
     if (s->record_count >= s->record_count_threshold) {
@@ -45473,34 +48587,14 @@ static JSMapRecord *map_add_record(JSContext *ctx, JSMapState *s,
     return mr;
 }
 
-/* Remove the weak reference from the object weak
-   reference list. we don't use a doubly linked list to
-   save space, assuming a given object has few weak
-       references to it */
-static void delete_weak_ref(JSRuntime *rt, JSMapRecord *mr)
-{
-    JSMapRecord **pmr, *mr1;
-    JSObject *p;
-
-    p = JS_VALUE_GET_OBJ(mr->key);
-    pmr = &p->first_weak_ref;
-    for(;;) {
-        mr1 = *pmr;
-        assert(mr1 != NULL);
-        if (mr1 == mr)
-            break;
-        pmr = &mr1->next_weak_ref;
-    }
-    *pmr = mr1->next_weak_ref;
-}
-
+/* warning: the record must be removed from the hash table before */
 static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
 {
     if (mr->empty)
         return;
-    list_del(&mr->hash_link);
+    
     if (s->is_weak) {
-        delete_weak_ref(rt, mr);
+        js_weakref_free(rt, mr->key);
     } else {
         JS_FreeValueRT(rt, mr->key);
     }
@@ -45527,30 +48621,36 @@ static void map_decref_record(JSRuntime *rt, JSMapRecord *mr)
     }
 }
 
-static void reset_weak_ref(JSRuntime *rt, JSObject *p)
+static void map_delete_weakrefs(JSRuntime *rt, JSWeakRefHeader *wh)
 {
-    JSMapRecord *mr, *mr_next;
-    JSMapState *s;
-    
-    /* first pass to remove the records from the WeakMap/WeakSet
-       lists */
-    for(mr = p->first_weak_ref; mr != NULL; mr = mr->next_weak_ref) {
-        s = mr->map;
-        assert(s->is_weak);
-        assert(!mr->empty); /* no iterator on WeakMap/WeakSet */
-        list_del(&mr->hash_link);
-        list_del(&mr->link);
-    }
-    
-    /* second pass to free the values to avoid modifying the weak
-       reference list while traversing it. */
-    for(mr = p->first_weak_ref; mr != NULL; mr = mr_next) {
-        mr_next = mr->next_weak_ref;
-        JS_FreeValueRT(rt, mr->value);
-        js_free_rt(rt, mr);
-    }
+    JSMapState *s = container_of(wh, JSMapState, weakref_header);
+    struct list_head *el, *el1;
+    JSMapRecord *mr1, **pmr;
+    uint32_t h;
 
-    p->first_weak_ref = NULL; /* fail safe */
+    list_for_each_safe(el, el1, &s->records) {
+        JSMapRecord *mr = list_entry(el, JSMapRecord, link);
+        if (!js_weakref_is_live(mr->key)) {
+
+            /* even if key is not live it can be hashed as a pointer */
+            h = map_hash_key(mr->key, s->hash_bits);
+            pmr = &s->hash_table[h];
+            for(;;) {
+                mr1 = *pmr;
+                /* the entry may already be removed from the hash
+                   table if the map was resized */
+                if (mr1 == NULL)
+                    goto done; 
+                if (mr1 == mr)
+                    break;
+                pmr = &mr1->hash_next;
+            }
+            /* remove from the hash table */
+            *pmr = mr1->hash_next;
+        done:
+            map_delete_record(rt, s, mr);
+        }
+    }
 }
 
 static JSValue js_map_set(JSContext *ctx, JSValueConst this_val,
@@ -45563,8 +48663,8 @@ static JSValue js_map_set(JSContext *ctx, JSValueConst this_val,
     if (!s)
         return JS_EXCEPTION;
     key = map_normalize_key(ctx, argv[0]);
-    if (s->is_weak && !JS_IsObject(key))
-        return JS_ThrowTypeErrorNotAnObject(ctx);
+    if (s->is_weak && !js_weakref_is_target(key))
+        return JS_ThrowTypeError(ctx, "invalid value used as %s key", (magic & MAGIC_SET) ? "WeakSet" : "WeakMap");
     if (magic & MAGIC_SET)
         value = JS_UNDEFINED;
     else
@@ -45609,22 +48709,39 @@ static JSValue js_map_has(JSContext *ctx, JSValueConst this_val,
         return JS_EXCEPTION;
     key = map_normalize_key(ctx, argv[0]);
     mr = map_find_record(ctx, s, key);
-    return JS_NewBool(ctx, (mr != NULL));
+    return JS_NewBool(ctx, mr != NULL);
 }
 
 static JSValue js_map_delete(JSContext *ctx, JSValueConst this_val,
                              int argc, JSValueConst *argv, int magic)
 {
     JSMapState *s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
-    JSMapRecord *mr;
+    JSMapRecord *mr, **pmr;
     JSValueConst key;
+    uint32_t h;
 
     if (!s)
         return JS_EXCEPTION;
     key = map_normalize_key(ctx, argv[0]);
-    mr = map_find_record(ctx, s, key);
-    if (!mr)
-        return JS_FALSE;
+    
+    h = map_hash_key(key, s->hash_bits);
+    pmr = &s->hash_table[h];
+    for(;;) {
+        mr = *pmr;
+        if (mr == NULL)
+            return JS_FALSE;
+        if (mr->empty || (s->is_weak && !js_weakref_is_live(mr->key))) {
+            /* not valid */
+        } else {
+            if (js_same_value_zero(ctx, mr->key, key))
+                break;
+        }
+        pmr = &mr->hash_next;
+    }
+
+    /* remove from the hash table */
+    *pmr = mr->hash_next;
+    
     map_delete_record(ctx->rt, s, mr);
     return JS_TRUE;
 }
@@ -45638,6 +48755,10 @@ static JSValue js_map_clear(JSContext *ctx, JSValueConst this_val,
 
     if (!s)
         return JS_EXCEPTION;
+
+    /* remove from the hash table */
+    memset(s->hash_table, 0, sizeof(s->hash_table[0]) * s->hash_size);
+    
     list_for_each_safe(el, el1, &s->records) {
         mr = list_entry(el, JSMapRecord, link);
         map_delete_record(ctx->rt, s, mr);
@@ -45701,6 +48822,123 @@ static JSValue js_map_forEach(JSContext *ctx, JSValueConst this_val,
     return JS_UNDEFINED;
 }
 
+static JSValue js_object_groupBy(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv, int is_map)
+{
+    JSValueConst cb, args[2];
+    JSValue res, iter, next, groups, key, v, prop;
+    JSAtom key_atom = JS_ATOM_NULL;
+    int64_t idx;
+    BOOL done;
+
+    // "is function?" check must be observed before argv[0] is accessed
+    cb = argv[1];
+    if (check_function(ctx, cb))
+        return JS_EXCEPTION;
+
+    iter = JS_GetIterator(ctx, argv[0], /*is_async*/FALSE);
+    if (JS_IsException(iter))
+        return JS_EXCEPTION;
+
+    key = JS_UNDEFINED;
+    key_atom = JS_ATOM_NULL;
+    v = JS_UNDEFINED;
+    prop = JS_UNDEFINED;
+    groups = JS_UNDEFINED;
+
+    next = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next))
+        goto exception;
+
+    if (is_map) {
+        groups = js_map_constructor(ctx, JS_UNDEFINED, 0, NULL, 0);
+    } else {
+        groups = JS_NewObjectProto(ctx, JS_NULL);
+    }
+    if (JS_IsException(groups))
+        goto exception;
+
+    for (idx = 0; ; idx++) {
+        if (idx >= MAX_SAFE_INTEGER) {
+            JS_ThrowTypeError(ctx, "too many elements");
+            goto iterator_close_exception;
+        }
+        v = JS_IteratorNext(ctx, iter, next, 0, NULL, &done);
+        if (JS_IsException(v))
+            goto exception;
+        if (done)
+            break; // v is JS_UNDEFINED
+
+        args[0] = v;
+        args[1] = JS_NewInt64(ctx, idx);
+        key = JS_Call(ctx, cb, ctx->global_obj, 2, args);
+        if (JS_IsException(key))
+            goto iterator_close_exception;
+
+        if (is_map) {
+            prop = js_map_get(ctx, groups, 1, (JSValueConst *)&key, 0);
+        } else {
+            key_atom = JS_ValueToAtom(ctx, key);
+            JS_FreeValue(ctx, key);
+            key = JS_UNDEFINED;
+            if (key_atom == JS_ATOM_NULL)
+                goto iterator_close_exception;
+            prop = JS_GetProperty(ctx, groups, key_atom);
+        }
+        if (JS_IsException(prop))
+            goto exception;
+
+        if (JS_IsUndefined(prop)) {
+            prop = JS_NewArray(ctx);
+            if (JS_IsException(prop))
+                goto exception;
+            if (is_map) {
+                args[0] = key;
+                args[1] = prop;
+                res = js_map_set(ctx, groups, 2, args, 0);
+                if (JS_IsException(res))
+                    goto exception;
+                JS_FreeValue(ctx, res);
+            } else {
+                prop = JS_DupValue(ctx, prop);
+                if (JS_DefinePropertyValue(ctx, groups, key_atom, prop,
+                                           JS_PROP_C_W_E) < 0) {
+                    goto exception;
+                }
+            }
+        }
+        res = js_array_push(ctx, prop, 1, (JSValueConst *)&v, /*unshift*/0);
+        if (JS_IsException(res))
+            goto exception;
+        // res is an int64
+
+        JS_FreeValue(ctx, prop);
+        JS_FreeValue(ctx, key);
+        JS_FreeAtom(ctx, key_atom);
+        JS_FreeValue(ctx, v);
+        prop = JS_UNDEFINED;
+        key = JS_UNDEFINED;
+        key_atom = JS_ATOM_NULL;
+        v = JS_UNDEFINED;
+    }
+
+    JS_FreeValue(ctx, iter);
+    JS_FreeValue(ctx, next);
+    return groups;
+
+ iterator_close_exception:
+    JS_IteratorClose(ctx, iter, TRUE);
+ exception:
+    JS_FreeAtom(ctx, key_atom);
+    JS_FreeValue(ctx, prop);
+    JS_FreeValue(ctx, key);
+    JS_FreeValue(ctx, v);
+    JS_FreeValue(ctx, groups);
+    JS_FreeValue(ctx, iter);
+    JS_FreeValue(ctx, next);
+    return JS_EXCEPTION;
+}
+
 static void js_map_finalizer(JSRuntime *rt, JSValue val)
 {
     JSObject *p;
@@ -45717,7 +48955,7 @@ static void js_map_finalizer(JSRuntime *rt, JSValue val)
             mr = list_entry(el, JSMapRecord, link);
             if (!mr->empty) {
                 if (s->is_weak)
-                    delete_weak_ref(rt, mr);
+                    js_weakref_free(rt, mr->key);
                 else
                     JS_FreeValueRT(rt, mr->key);
                 JS_FreeValueRT(rt, mr->value);
@@ -45725,6 +48963,9 @@ static void js_map_finalizer(JSRuntime *rt, JSValue val)
             js_free_rt(rt, mr);
         }
         js_free_rt(rt, s->hash_table);
+        if (s->is_weak) {
+            list_del(&s->weakref_header.link);
+        }
         js_free_rt(rt, s);
     }
 }
@@ -45881,6 +49122,7 @@ static JSValue js_map_iterator_next(JSContext *ctx, JSValueConst this_val,
 }
 
 static const JSCFunctionListEntry js_map_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("groupBy", 2, js_object_groupBy, 1 ),
     JS_CGETSET_DEF("[Symbol.species]", js_get_this, NULL ),
 };
 
@@ -46001,12 +49243,6 @@ static const JSCFunctionListEntry js_generator_proto_funcs[] = {
 
 /* Promise */
 
-typedef enum JSPromiseStateEnum {
-    JS_PROMISE_PENDING,
-    JS_PROMISE_FULFILLED,
-    JS_PROMISE_REJECTED,
-} JSPromiseStateEnum;
-
 typedef struct JSPromiseData {
     JSPromiseStateEnum promise_state;
     /* 0=fulfill, 1=reject, list of JSPromiseReactionData.link */
@@ -46032,6 +49268,22 @@ typedef struct JSPromiseReactionData {
     JSValue handler;
 } JSPromiseReactionData;
 
+JSPromiseStateEnum JS_PromiseState(JSContext *ctx, JSValue promise)
+{
+    JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
+    if (!s)
+        return -1;
+    return s->promise_state;
+}
+
+JSValue JS_PromiseResult(JSContext *ctx, JSValue promise)
+{
+    JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
+    if (!s)
+        return JS_UNDEFINED;
+    return JS_DupValue(ctx, s->promise_result);
+}
+
 static int js_create_resolving_functions(JSContext *ctx, JSValue *args,
                                          JSValueConst promise);
 
@@ -46267,8 +49519,8 @@ static JSValue js_promise_resolve_function_call(JSContext *ctx,
     else
         resolution = JS_UNDEFINED;
 #ifdef DUMP_PROMISE
-    printf("js_promise_resolving_function_call: is_reject=%d resolution=", is_reject);
-    JS_DumpValue(ctx, resolution);
+    printf("js_promise_resolving_function_call: is_reject=%d ", is_reject);
+    JS_DumpValue(ctx, "resolution", resolution);
     printf("\n");
 #endif
     if (is_reject || !JS_IsObject(resolution)) {
@@ -46494,17 +49746,14 @@ static JSValue js_promise_resolve(JSContext *ctx, JSValueConst this_val,
     return result_promise;
 }
 
-#if 0
-static JSValue js_promise___newPromiseCapability(JSContext *ctx,
-                                                 JSValueConst this_val,
-                                                 int argc, JSValueConst *argv)
+static JSValue js_promise_withResolvers(JSContext *ctx,
+                                        JSValueConst this_val,
+                                        int argc, JSValueConst *argv)
 {
     JSValue result_promise, resolving_funcs[2], obj;
-    JSValueConst ctor;
-    ctor = argv[0];
-    if (!JS_IsObject(ctor))
+    if (!JS_IsObject(this_val))
         return JS_ThrowTypeErrorNotAnObject(ctx);
-    result_promise = js_new_promise_capability(ctx, resolving_funcs, ctor);
+    result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
     if (JS_IsException(result_promise))
         return result_promise;
     obj = JS_NewObject(ctx);
@@ -46519,7 +49768,34 @@ static JSValue js_promise___newPromiseCapability(JSContext *ctx,
     JS_DefinePropertyValue(ctx, obj, JS_ATOM_reject, resolving_funcs[1], JS_PROP_C_W_E);
     return obj;
 }
-#endif
+
+static JSValue js_promise_try(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    JSValue result_promise, resolving_funcs[2], ret, ret2;
+    BOOL is_reject = 0;
+
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    ret = JS_Call(ctx, argv[0], JS_UNDEFINED, argc - 1, argv + 1);
+    if (JS_IsException(ret)) {
+        is_reject = 1;
+        ret = JS_GetException(ctx);
+    }
+    ret2 = JS_Call(ctx, resolving_funcs[is_reject], JS_UNDEFINED, 1, (JSValueConst *)&ret);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+    JS_FreeValue(ctx, ret);
+    if (JS_IsException(ret2)) {
+        JS_FreeValue(ctx, result_promise);
+        return ret2;
+    }
+    JS_FreeValue(ctx, ret2);
+    return result_promise;
+}
 
 static __exception int remainingElementsCount_add(JSContext *ctx,
                                                   JSValueConst resolve_element_env,
@@ -46558,7 +49834,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     JSValueConst resolve_element_env = func_data[4];
     JSValue ret, obj;
     int is_zero, index;
-    
+
     if (JS_ToInt32(ctx, &index, func_data[1]))
         return JS_EXCEPTION;
     if (alreadyCalled)
@@ -46567,11 +49843,11 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
 
     if (resolve_type == PROMISE_MAGIC_allSettled) {
         JSValue str;
-        
+
         obj = JS_NewObject(ctx);
         if (JS_IsException(obj))
             return JS_EXCEPTION;
-        str = JS_NewString(ctx, is_reject ? "rejected" : "fulfilled");
+        str = js_new_string8(ctx, is_reject ? "rejected" : "fulfilled");
         if (JS_IsException(str))
             goto fail1;
         if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_status,
@@ -46592,7 +49868,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     if (JS_DefinePropertyValueUint32(ctx, values, index,
                                      obj, JS_PROP_C_W_E) < 0)
         return JS_EXCEPTION;
-    
+
     is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
     if (is_zero < 0)
         return JS_EXCEPTION;
@@ -46625,7 +49901,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
     JSValueConst then_args[2], resolve_element_data[5];
     BOOL done;
     int index, is_zero, is_promise_any = (magic == PROMISE_MAGIC_any);
-    
+
     if (!JS_IsObject(this_val))
         return JS_ThrowTypeErrorNotAnObject(ctx);
     result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
@@ -46661,7 +49937,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                                          JS_NewInt32(ctx, 1),
                                          JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
             goto fail_reject;
-        
+
         index = 0;
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
@@ -46671,7 +49947,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             if (done)
                 break;
-            next_promise = JS_Call(ctx, promise_resolve, 
+            next_promise = JS_Call(ctx, promise_resolve,
                                    this_val, 1, (JSValueConst *)&item);
             JS_FreeValue(ctx, item);
             if (JS_IsException(next_promise)) {
@@ -46691,7 +49967,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 JS_FreeValue(ctx, next_promise);
                 goto fail_reject1;
             }
-            
+
             if (magic == PROMISE_MAGIC_allSettled) {
                 reject_element =
                     JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
@@ -47008,8 +50284,9 @@ static const JSCFunctionListEntry js_promise_funcs[] = {
     JS_CFUNC_MAGIC_DEF("all", 1, js_promise_all, PROMISE_MAGIC_all ),
     JS_CFUNC_MAGIC_DEF("allSettled", 1, js_promise_all, PROMISE_MAGIC_allSettled ),
     JS_CFUNC_MAGIC_DEF("any", 1, js_promise_all, PROMISE_MAGIC_any ),
+    JS_CFUNC_DEF("try", 1, js_promise_try ),
     JS_CFUNC_DEF("race", 1, js_promise_race ),
-    //JS_CFUNC_DEF("__newPromiseCapability", 1, js_promise___newPromiseCapability ),
+    JS_CFUNC_DEF("withResolvers", 0, js_promise_withResolvers ),
     JS_CGETSET_DEF("[Symbol.species]", js_get_this, NULL),
 };
 
@@ -47025,25 +50302,6 @@ static const JSCFunctionListEntry js_async_function_proto_funcs[] = {
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "AsyncFunction", JS_PROP_CONFIGURABLE ),
 };
 
-static JSValue js_async_from_sync_iterator_unwrap(JSContext *ctx,
-                                                  JSValueConst this_val,
-                                                  int argc, JSValueConst *argv,
-                                                  int magic, JSValue *func_data)
-{
-    return js_create_iterator_result(ctx, JS_DupValue(ctx, argv[0]),
-                                     JS_ToBool(ctx, func_data[0]));
-}
-
-static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
-                                                              BOOL done)
-{
-    JSValueConst func_data[1];
-
-    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
-    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
-                               1, 0, 1, func_data);
-}
-
 /* AsyncIteratorPrototype */
 
 static const JSCFunctionListEntry js_async_iterator_proto_funcs[] = {
@@ -47105,6 +50363,41 @@ static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
     return async_iter;
 }
 
+static JSValue js_async_from_sync_iterator_unwrap(JSContext *ctx,
+                                                  JSValueConst this_val,
+                                                  int argc, JSValueConst *argv,
+                                                  int magic, JSValue *func_data)
+{
+    return js_create_iterator_result(ctx, JS_DupValue(ctx, argv[0]),
+                                     JS_ToBool(ctx, func_data[0]));
+}
+
+static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
+                                                              BOOL done)
+{
+    JSValueConst func_data[1];
+
+    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
+    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
+                               1, 0, 1, func_data);
+}
+
+static JSValue js_async_from_sync_iterator_close_wrap(JSContext *ctx,
+                                                      JSValueConst this_val,
+                                                      int argc, JSValueConst *argv,
+                                                      int magic, JSValue *func_data)
+{
+    JS_Throw(ctx, JS_DupValue(ctx, argv[0]));
+    JS_IteratorClose(ctx, func_data[0], TRUE);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_async_from_sync_iterator_close_wrap_func_create(JSContext *ctx, JSValueConst sync_iter)
+{
+    return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_close_wrap,
+                               1, 0, 1, &sync_iter);
+}
+
 static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst this_val,
                                                 int argc, JSValueConst *argv,
                                                 int magic)
@@ -47135,11 +50428,13 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
             if (magic == GEN_MAGIC_RETURN) {
                 err = js_create_iterator_result(ctx, JS_DupValue(ctx, argv[0]), TRUE);
                 is_reject = 0;
+                goto done_resolve;
             } else {
-                err = JS_DupValue(ctx, argv[0]);
-                is_reject = 1;
+                if (JS_IteratorClose(ctx, s->sync_iter, FALSE))
+                    goto reject;
+                JS_ThrowTypeError(ctx, "throw is not a method");
+                goto reject;
             }
-            goto done_resolve;
         }
     }
     value = JS_IteratorNext2(ctx, s->sync_iter, method,
@@ -47154,21 +50449,9 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
         if (JS_IsException(value))
             goto reject;
     }
-
-    if (JS_IsException(value)) {
-        JSValue res2;
-    reject:
-        err = JS_GetException(ctx);
-        is_reject = 1;
-    done_resolve:
-        res2 = JS_Call(ctx, resolving_funcs[is_reject], JS_UNDEFINED,
-                       1, (JSValueConst *)&err);
-        JS_FreeValue(ctx, err);
-        JS_FreeValue(ctx, res2);
-        JS_FreeValue(ctx, resolving_funcs[0]);
-        JS_FreeValue(ctx, resolving_funcs[1]);
-        return promise;
-    }
+    
+    if (JS_IsException(value))
+        goto reject;
     {
         JSValue value_wrapper_promise, resolve_reject[2];
         int res;
@@ -47176,8 +50459,22 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
         value_wrapper_promise = js_promise_resolve(ctx, ctx->promise_ctor,
                                                    1, (JSValueConst *)&value, 0);
         if (JS_IsException(value_wrapper_promise)) {
+            JSValue res2;
             JS_FreeValue(ctx, value);
-            goto reject;
+            if (magic != GEN_MAGIC_RETURN && !done) {
+                JS_IteratorClose(ctx, s->sync_iter, TRUE);
+            }
+        reject:
+            err = JS_GetException(ctx);
+            is_reject = 1;
+        done_resolve:
+            res2 = JS_Call(ctx, resolving_funcs[is_reject], JS_UNDEFINED,
+                           1, (JSValueConst *)&err);
+            JS_FreeValue(ctx, err);
+            JS_FreeValue(ctx, res2);
+            JS_FreeValue(ctx, resolving_funcs[0]);
+            JS_FreeValue(ctx, resolving_funcs[1]);
+            return promise;
         }
 
         resolve_reject[0] =
@@ -47186,13 +50483,23 @@ static JSValue js_async_from_sync_iterator_next(JSContext *ctx, JSValueConst thi
             JS_FreeValue(ctx, value_wrapper_promise);
             goto fail;
         }
+        if (done || magic == GEN_MAGIC_RETURN) {
+            resolve_reject[1] = JS_UNDEFINED;
+        } else {
+            resolve_reject[1] =
+                js_async_from_sync_iterator_close_wrap_func_create(ctx, s->sync_iter);
+            if (JS_IsException(resolve_reject[1])) {
+                JS_FreeValue(ctx, value_wrapper_promise);
+                JS_FreeValue(ctx, resolve_reject[0]);
+                goto fail;
+            }
+        }
         JS_FreeValue(ctx, value);
-        resolve_reject[1] = JS_UNDEFINED;
-
         res = perform_promise_then(ctx, value_wrapper_promise,
                                    (JSValueConst *)resolve_reject,
                                    (JSValueConst *)resolving_funcs);
         JS_FreeValue(ctx, resolve_reject[0]);
+        JS_FreeValue(ctx, resolve_reject[1]);
         JS_FreeValue(ctx, value_wrapper_promise);
         JS_FreeValue(ctx, resolving_funcs[0]);
         JS_FreeValue(ctx, resolving_funcs[1]);
@@ -47422,8 +50729,7 @@ static JSValue js_global_decodeURI(JSContext *ctx, JSValueConst this_val,
                     }
                     c = (c << 6) | (c1 & 0x3f);
                 }
-                if (c < c_min || c > 0x10FFFF ||
-                    (c >= 0xd800 && c < 0xe000)) {
+                if (c < c_min || c > 0x10FFFF || is_surrogate(c)) {
                     js_throw_URIError(ctx, "malformed UTF-8");
                     goto fail;
                 }
@@ -47498,21 +50804,21 @@ static JSValue js_global_encodeURI(JSContext *ctx, JSValueConst this_val,
         if (isURIUnescaped(c, isComponent)) {
             string_buffer_putc16(b, c);
         } else {
-            if (c >= 0xdc00 && c <= 0xdfff) {
+            if (is_lo_surrogate(c)) {
                 js_throw_URIError(ctx, "invalid character");
                 goto fail;
-            } else if (c >= 0xd800 && c <= 0xdbff) {
+            } else if (is_hi_surrogate(c)) {
                 if (k >= p->len) {
                     js_throw_URIError(ctx, "expecting surrogate pair");
                     goto fail;
                 }
                 c1 = string_get(p, k);
                 k++;
-                if (c1 < 0xdc00 || c1 > 0xdfff) {
+                if (!is_lo_surrogate(c1)) {
                     js_throw_URIError(ctx, "expecting surrogate pair");
                     goto fail;
                 }
-                c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+                c = from_surrogate(c, c1);
             }
             if (c < 0x80) {
                 encodeURI_hex(b, c);
@@ -47620,12 +50926,7 @@ static const JSCFunctionListEntry js_global_funcs[] = {
     JS_PROP_DOUBLE_DEF("Infinity", 1.0 / 0.0, 0 ),
     JS_PROP_DOUBLE_DEF("NaN", NAN, 0 ),
     JS_PROP_UNDEFINED_DEF("undefined", 0 ),
-
-    /* for the 'Date' implementation */
-    JS_CFUNC_DEF("__date_clock", 0, js___date_clock ),
-    //JS_CFUNC_DEF("__date_now", 0, js___date_now ),
-    //JS_CFUNC_DEF("__date_getTimezoneOffset", 1, js___date_getTimezoneOffset ),
-    //JS_CFUNC_DEF("__date_create", 3, js___date_create ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "global", JS_PROP_CONFIGURABLE ),
 };
 
 /* Date */
@@ -47706,7 +51007,7 @@ static char const month_names[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
 static char const day_names[] = "SunMonTueWedThuFriSat";
 
 static __exception int get_date_fields(JSContext *ctx, JSValueConst obj,
-                                       double fields[9], int is_local, int force)
+                                       double fields[minimum_length(9)], int is_local, int force)
 {
     double dval;
     int64_t d, days, wd, y, i, md, h, m, s, ms, tz = 0;
@@ -47719,7 +51020,7 @@ static __exception int get_date_fields(JSContext *ctx, JSValueConst obj,
             return FALSE; /* NaN */
         d = 0;        /* initialize all fields to 0 */
     } else {
-        d = dval;
+        d = dval;     /* assuming -8.64e15 <= dval <= -8.64e15 */
         if (is_local) {
             tz = -getTimezoneOffset(d);
             d += tz * 60000;
@@ -47765,33 +51066,63 @@ static double time_clip(double t) {
         return NAN;
 }
 
-/* The spec mandates the use of 'double' and it fixes the order
+/* The spec mandates the use of 'double' and it specifies the order
    of the operations */
-static double set_date_fields(double fields[], int is_local) {
-    int64_t y;
-    double days, d, h, m1;
-    int i, m, md;
-    
-    m1 = fields[1];
-    m = fmod(m1, 12);
-    if (m < 0)
-        m += 12;
-    y = (int64_t)(fields[0] + floor(m1 / 12));
-    days = days_from_year(y);
-
-    for(i = 0; i < m; i++) {
-        md = month_days[i];
+static double set_date_fields(double fields[minimum_length(7)], int is_local) {
+    double y, m, dt, ym, mn, day, h, s, milli, time, tv;
+    int yi, mi, i;
+    int64_t days;
+    volatile double temp;  /* enforce evaluation order */
+
+    /* emulate 21.4.1.15 MakeDay ( year, month, date ) */
+    y = fields[0];
+    m = fields[1];
+    dt = fields[2];
+    ym = y + floor(m / 12);
+    mn = fmod(m, 12);
+    if (mn < 0)
+        mn += 12;
+    if (ym < -271821 || ym > 275760)
+        return NAN;
+
+    yi = ym;
+    mi = mn;
+    days = days_from_year(yi);
+    for(i = 0; i < mi; i++) {
+        days += month_days[i];
         if (i == 1)
-            md += days_in_year(y) - 365;
-        days += md;
+            days += days_in_year(yi) - 365;
     }
-    days += fields[2] - 1;
-    h = fields[3] * 3600000 + fields[4] * 60000 + 
-        fields[5] * 1000 + fields[6];
-    d = days * 86400000 + h;
-    if (is_local)
-        d += getTimezoneOffset(d) * 60000;
-    return time_clip(d);
+    day = days + dt - 1;
+
+    /* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
+    h = fields[3];
+    m = fields[4];
+    s = fields[5];
+    milli = fields[6];
+    /* Use a volatile intermediary variable to ensure order of evaluation
+     * as specified in ECMA. This fixes a test262 error on
+     * test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
+     * Without the volatile qualifier, the compile can generate code
+     * that performs the computation in a different order or with instructions
+     * that produce a different result such as FMA (float multiply and add).
+     */
+    time = h * 3600000;
+    time += (temp = m * 60000);
+    time += (temp = s * 1000);
+    time += milli;
+
+    /* emulate 21.4.1.16 MakeDate ( day, time ) */
+    tv = (temp = day * 86400000) + time;   /* prevent generation of FMA */
+    if (!isfinite(tv))
+        return NAN;
+
+    /* adjust for local time and clip */
+    if (is_local) {
+        int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
+        tv += getTimezoneOffset(ti) * 60000;
+    }
+    return time_clip(tv);
 }
 
 static JSValue get_date_field(JSContext *ctx, JSValueConst this_val,
@@ -47820,7 +51151,7 @@ static JSValue set_date_field(JSContext *ctx, JSValueConst this_val,
 {
     // _field(obj, first_field, end_field, args, is_local)
     double fields[9];
-    int res, first_field, end_field, is_local, i, n;
+    int res, first_field, end_field, is_local, i, n, res1;
     double d, a;
 
     d = NAN;
@@ -47831,7 +51162,8 @@ static JSValue set_date_field(JSContext *ctx, JSValueConst this_val,
     res = get_date_fields(ctx, this_val, fields, is_local, first_field == 0);
     if (res < 0)
         return JS_EXCEPTION;
-
+    res1 = res;
+    
     // Argument coercion is observable and must be done unconditionally.
     n = min_int(argc, end_field - first_field);
     for(i = 0; i < n; i++) {
@@ -47841,9 +51173,13 @@ static JSValue set_date_field(JSContext *ctx, JSValueConst this_val,
             res = FALSE;
         fields[first_field + i] = trunc(a);
     }
-    if (res && argc > 0) {
+
+    if (!res1)
+        return JS_NAN; /* thisTimeValue is NaN */
+
+    if (res && argc > 0)
         d = set_date_fields(fields, is_local);
-    }
+
     return JS_SetThisTimeValue(ctx, this_val, d);
 }
 
@@ -47874,7 +51210,7 @@ static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
         if (fmt == 2)
             return JS_ThrowRangeError(ctx, "Date value is NaN");
         else
-            return JS_NewString(ctx, "Invalid Date");
+            return js_new_string8(ctx, "Invalid Date");
     }
 
     y = fields[0];
@@ -47953,7 +51289,7 @@ static JSValue get_date_string(JSContext *ctx, JSValueConst this_val,
             break;
         case 3:
             pos += snprintf(buf + pos, sizeof(buf) - pos,
-                            "%02d:%02d:%02d %cM", (h + 1) % 12 - 1, m, s,
+                            "%02d:%02d:%02d %cM", (h + 11) % 12 + 1, m, s,
                             (h < 12) ? 'A' : 'P');
             break;
         }
@@ -48029,2484 +51365,813 @@ static JSValue js_date_constructor(JSContext *ctx, JSValueConst new_target,
     args[1] = ctx->class_proto[JS_CLASS_DATE];
     args[2] = JS_NewFloat64(ctx, val);
     rv = js___date_create(ctx, JS_UNDEFINED, 3, args);
-#else
-    rv = js_create_from_ctor(ctx, new_target, JS_CLASS_DATE);
-    if (!JS_IsException(rv))
-        JS_SetObjectData(ctx, rv, JS_NewFloat64(ctx, val));
-#endif
-    if (!JS_IsException(rv) && JS_IsUndefined(new_target)) {
-        /* invoked as a function, return (new Date()).toString(); */
-        JSValue s;
-        s = get_date_string(ctx, rv, 0, NULL, 0x13);
-        JS_FreeValue(ctx, rv);
-        rv = s;
-    }
-    return rv;
-}
-
-static JSValue js_Date_UTC(JSContext *ctx, JSValueConst this_val,
-                           int argc, JSValueConst *argv)
-{
-    // UTC(y, mon, d, h, m, s, ms)
-    double fields[] = { 0, 0, 1, 0, 0, 0, 0 };
-    int i, n;
-    double a;
-
-    n = argc;
-    if (n == 0)
-        return JS_NAN;
-    if (n > 7)
-        n = 7;
-    for(i = 0; i < n; i++) {
-        if (JS_ToFloat64(ctx, &a, argv[i]))
-            return JS_EXCEPTION;
-        if (!isfinite(a))
-            return JS_NAN;
-        fields[i] = trunc(a);
-        if (i == 0 && fields[0] >= 0 && fields[0] < 100)
-            fields[0] += 1900;
-    }
-    return JS_NewFloat64(ctx, set_date_fields(fields, 0));
-}
-
-static void string_skip_spaces(JSString *sp, int *pp) {
-    while (*pp < sp->len && string_get(sp, *pp) == ' ')
-        *pp += 1;
-}
-
-static void string_skip_non_spaces(JSString *sp, int *pp) {
-    while (*pp < sp->len && string_get(sp, *pp) != ' ')
-        *pp += 1;
-}
-
-/* parse a numeric field with an optional sign if accept_sign is TRUE */
-static int string_get_digits(JSString *sp, int *pp, int64_t *pval) {
-    int64_t v = 0;
-    int c, p = *pp, p_start;
-    
-    if (p >= sp->len)
-        return -1;
-    p_start = p;
-    while (p < sp->len) {
-        c = string_get(sp, p);
-        if (!(c >= '0' && c <= '9')) {
-            if (p == p_start)
-                return -1;
-            else
-                break;
-        }
-        v = v * 10 + c - '0';
-        p++;
-    }
-    *pval = v;
-    *pp = p;
-    return 0;
-}
-
-static int string_get_signed_digits(JSString *sp, int *pp, int64_t *pval) {
-    int res, sgn, p = *pp;
-    
-    if (p >= sp->len)
-        return -1;
-
-    sgn = string_get(sp, p);
-    if (sgn == '-' || sgn == '+')
-        p++;
- 
-    res = string_get_digits(sp, &p, pval);
-    if (res == 0 && sgn == '-') {
-        if (*pval == 0)
-            return -1; // reject negative zero
-        *pval = -*pval;
-    }
-    *pp = p;
-    return res;
-}
-
-/* parse a fixed width numeric field */
-static int string_get_fixed_width_digits(JSString *sp, int *pp, int n, int64_t *pval) {
-    int64_t v = 0;
-    int i, c, p = *pp;
-
-    for(i = 0; i < n; i++) {
-        if (p >= sp->len)
-            return -1;
-        c = string_get(sp, p);
-        if (!(c >= '0' && c <= '9'))
-            return -1;
-        v = v * 10 + c - '0';
-        p++;
-    }
-    *pval = v;
-    *pp = p;
-    return 0;
-}
-
-static int string_get_milliseconds(JSString *sp, int *pp, int64_t *pval) {
-    /* parse milliseconds as a fractional part, round to nearest */
-    /* XXX: the spec does not indicate which rounding should be used */
-    int mul = 1000, ms = 0, p = *pp, c, p_start;
-    if (p >= sp->len)
-        return -1;
-    p_start = p;
-    while (p < sp->len) {
-        c = string_get(sp, p);
-        if (!(c >= '0' && c <= '9')) {
-            if (p == p_start)
-                return -1;
-            else
-                break;
-        }
-        if (mul == 1 && c >= '5')
-            ms += 1;
-        ms += (c - '0') * (mul /= 10);
-        p++;
-    }
-    *pval = ms;
-    *pp = p;
-    return 0;
-}
-
-
-static int find_abbrev(JSString *sp, int p, const char *list, int count) {
-    int n, i;
-
-    if (p + 3 <= sp->len) {
-        for (n = 0; n < count; n++) {
-            for (i = 0; i < 3; i++) {
-                if (string_get(sp, p + i) != month_names[n * 3 + i])
-                    goto next;
-            }
-            return n;
-        next:;
-        }
-    }
-    return -1;
-}
-
-static int string_get_month(JSString *sp, int *pp, int64_t *pval) {
-    int n;
-
-    string_skip_spaces(sp, pp);
-    n = find_abbrev(sp, *pp, month_names, 12);
-    if (n < 0)
-        return -1;
-
-    *pval = n;
-    *pp += 3;
-    return 0;
-}
-
-static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
-                             int argc, JSValueConst *argv)
-{
-    // parse(s)
-    JSValue s, rv;
-    int64_t fields[] = { 0, 1, 1, 0, 0, 0, 0 };
-    double fields1[7];
-    int64_t tz, hh, mm;
-    double d;
-    int p, i, c, sgn, l;
-    JSString *sp;
-    BOOL is_local;
-    
-    rv = JS_NAN;
-
-    s = JS_ToString(ctx, argv[0]);
-    if (JS_IsException(s))
-        return JS_EXCEPTION;
-    
-    sp = JS_VALUE_GET_STRING(s);
-    p = 0;
-    if (p < sp->len && (((c = string_get(sp, p)) >= '0' && c <= '9') || c == '+' || c == '-')) {
-        /* ISO format */
-        /* year field can be negative */
-        if (string_get_signed_digits(sp, &p, &fields[0]))
-            goto done;
-
-        for (i = 1; i < 7; i++) {
-            if (p >= sp->len)
-                break;
-            switch(i) {
-            case 1:
-            case 2:
-                c = '-';
-                break;
-            case 3:
-                c = 'T';
-                break;
-            case 4:
-            case 5:
-                c = ':';
-                break;
-            case 6:
-                c = '.';
-                break;
-            }
-            if (string_get(sp, p) != c)
-                break;
-            p++;
-            if (i == 6) {
-                if (string_get_milliseconds(sp, &p, &fields[i]))
-                    goto done;
-            } else {
-                if (string_get_digits(sp, &p, &fields[i]))
-                    goto done;
-            }
-        }
-        /* no time: UTC by default */
-        is_local = (i > 3);
-        fields[1] -= 1;
-
-        /* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
-        tz = 0;
-        if (p < sp->len) {
-            sgn = string_get(sp, p);
-            if (sgn == '+' || sgn == '-') {
-                p++;
-                l = sp->len - p;
-                if (l != 4 && l != 5)
-                    goto done;
-                if (string_get_fixed_width_digits(sp, &p, 2, &hh))
-                    goto done;
-                if (l == 5) {
-                    if (string_get(sp, p) != ':')
-                        goto done;
-                    p++;
-                }
-                if (string_get_fixed_width_digits(sp, &p, 2, &mm))
-                    goto done;
-                tz = hh * 60 + mm;
-                if (sgn == '-')
-                    tz = -tz;
-                is_local = FALSE;
-            } else if (sgn == 'Z') {
-                p++;
-                is_local = FALSE;
-            } else {
-                goto done;
-            }
-            /* error if extraneous characters */
-            if (p != sp->len)
-                goto done;
-        }
-    } else {
-        /* toString or toUTCString format */
-        /* skip the day of the week */
-        string_skip_non_spaces(sp, &p);
-        string_skip_spaces(sp, &p);
-        if (p >= sp->len)
-            goto done;
-        c = string_get(sp, p);
-        if (c >= '0' && c <= '9') {
-            /* day of month first */
-            if (string_get_digits(sp, &p, &fields[2]))
-                goto done;
-            if (string_get_month(sp, &p, &fields[1]))
-                goto done;
-        } else {
-            /* month first */
-            if (string_get_month(sp, &p, &fields[1]))
-                goto done;
-            string_skip_spaces(sp, &p);
-            if (string_get_digits(sp, &p, &fields[2]))
-                goto done;
-        }
-        /* year */
-        string_skip_spaces(sp, &p);
-        if (string_get_signed_digits(sp, &p, &fields[0]))
-            goto done;
-
-        /* hour, min, seconds */
-        string_skip_spaces(sp, &p);
-        for(i = 0; i < 3; i++) {
-            if (i == 1 || i == 2) {
-                if (p >= sp->len)
-                    goto done;
-                if (string_get(sp, p) != ':')
-                    goto done;
-                p++;
-            }
-            if (string_get_digits(sp, &p, &fields[3 + i]))
-                goto done;
-        }
-        // XXX: parse optional milliseconds?
-
-        /* parse the time zone offset if present: [+-]HHmm */
-        is_local = FALSE;
-        tz = 0;
-        for (tz = 0; p < sp->len; p++) {
-            sgn = string_get(sp, p);
-            if (sgn == '+' || sgn == '-') {
-                p++;
-                if (string_get_fixed_width_digits(sp, &p, 2, &hh))
-                    goto done;
-                if (string_get_fixed_width_digits(sp, &p, 2, &mm))
-                    goto done;
-                tz = hh * 60 + mm;
-                if (sgn == '-')
-                    tz = -tz;
-                break;
-            }
-        }
-    }
-    for(i = 0; i < 7; i++)
-        fields1[i] = fields[i];
-    d = set_date_fields(fields1, is_local) - tz * 60000;
-    rv = JS_NewFloat64(ctx, d);
-
-done:
-    JS_FreeValue(ctx, s);
-    return rv;
-}
-
-static JSValue js_Date_now(JSContext *ctx, JSValueConst this_val,
-                           int argc, JSValueConst *argv)
-{
-    // now()
-    return JS_NewInt64(ctx, date_now());
-}
-
-static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValueConst this_val,
-                                          int argc, JSValueConst *argv)
-{
-    // Symbol_toPrimitive(hint)
-    JSValueConst obj = this_val;
-    JSAtom hint = JS_ATOM_NULL;
-    int hint_num;
-
-    if (!JS_IsObject(obj))
-        return JS_ThrowTypeErrorNotAnObject(ctx);
-
-    if (JS_IsString(argv[0])) {
-        hint = JS_ValueToAtom(ctx, argv[0]);
-        if (hint == JS_ATOM_NULL)
-            return JS_EXCEPTION;
-        JS_FreeAtom(ctx, hint);
-    }
-    switch (hint) {
-    case JS_ATOM_number:
-#ifdef CONFIG_BIGNUM
-    case JS_ATOM_integer:
-#endif
-        hint_num = HINT_NUMBER;
-        break;
-    case JS_ATOM_string:
-    case JS_ATOM_default:
-        hint_num = HINT_STRING;
-        break;
-    default:
-        return JS_ThrowTypeError(ctx, "invalid hint");
-    }
-    return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
-}
-
-static JSValue js_date_getTimezoneOffset(JSContext *ctx, JSValueConst this_val,
-                                         int argc, JSValueConst *argv)
-{
-    // getTimezoneOffset()
-    double v;
-
-    if (JS_ThisTimeValue(ctx, &v, this_val))
-        return JS_EXCEPTION;
-    if (isnan(v))
-        return JS_NAN;
-    else
-        return JS_NewInt64(ctx, getTimezoneOffset((int64_t)trunc(v)));
-}
-
-static JSValue js_date_getTime(JSContext *ctx, JSValueConst this_val,
-                               int argc, JSValueConst *argv)
-{
-    // getTime()
-    double v;
-
-    if (JS_ThisTimeValue(ctx, &v, this_val))
-        return JS_EXCEPTION;
-    return JS_NewFloat64(ctx, v);
-}
-
-static JSValue js_date_setTime(JSContext *ctx, JSValueConst this_val,
-                               int argc, JSValueConst *argv)
-{
-    // setTime(v)
-    double v;
-
-    if (JS_ThisTimeValue(ctx, &v, this_val) || JS_ToFloat64(ctx, &v, argv[0]))
-        return JS_EXCEPTION;
-    return JS_SetThisTimeValue(ctx, this_val, time_clip(v));
-}
-
-static JSValue js_date_setYear(JSContext *ctx, JSValueConst this_val,
-                               int argc, JSValueConst *argv)
-{
-    // setYear(y)
-    double y;
-    JSValueConst args[1];
-
-    if (JS_ThisTimeValue(ctx, &y, this_val) || JS_ToFloat64(ctx, &y, argv[0]))
-        return JS_EXCEPTION;
-    y = +y;
-    if (isfinite(y)) {
-        y = trunc(y);
-        if (y >= 0 && y < 100)
-            y += 1900;
-    }
-    args[0] = JS_NewFloat64(ctx, y);
-    return set_date_field(ctx, this_val, 1, args, 0x011);
-}
-
-static JSValue js_date_toJSON(JSContext *ctx, JSValueConst this_val,
-                              int argc, JSValueConst *argv)
-{
-    // toJSON(key)
-    JSValue obj, tv, method, rv;
-    double d;
-
-    rv = JS_EXCEPTION;
-    tv = JS_UNDEFINED;
-
-    obj = JS_ToObject(ctx, this_val);
-    tv = JS_ToPrimitive(ctx, obj, HINT_NUMBER);
-    if (JS_IsException(tv))
-        goto exception;
-    if (JS_IsNumber(tv)) {
-        if (JS_ToFloat64(ctx, &d, tv) < 0)
-            goto exception;
-        if (!isfinite(d)) {
-            rv = JS_NULL;
-            goto done;
-        }
-    }
-    method = JS_GetPropertyStr(ctx, obj, "toISOString");
-    if (JS_IsException(method))
-        goto exception;
-    if (!JS_IsFunction(ctx, method)) {
-        JS_ThrowTypeError(ctx, "object needs toISOString method");
-        JS_FreeValue(ctx, method);
-        goto exception;
-    }
-    rv = JS_CallFree(ctx, method, obj, 0, NULL);
-exception:
-done:
-    JS_FreeValue(ctx, obj);
-    JS_FreeValue(ctx, tv);
-    return rv;
-}
-
-static const JSCFunctionListEntry js_date_funcs[] = {
-    JS_CFUNC_DEF("now", 0, js_Date_now ),
-    JS_CFUNC_DEF("parse", 1, js_Date_parse ),
-    JS_CFUNC_DEF("UTC", 7, js_Date_UTC ),
-};
-
-static const JSCFunctionListEntry js_date_proto_funcs[] = {
-    JS_CFUNC_DEF("valueOf", 0, js_date_getTime ),
-    JS_CFUNC_MAGIC_DEF("toString", 0, get_date_string, 0x13 ),
-    JS_CFUNC_DEF("[Symbol.toPrimitive]", 1, js_date_Symbol_toPrimitive ),
-    JS_CFUNC_MAGIC_DEF("toUTCString", 0, get_date_string, 0x03 ),
-    JS_ALIAS_DEF("toGMTString", "toUTCString" ),
-    JS_CFUNC_MAGIC_DEF("toISOString", 0, get_date_string, 0x23 ),
-    JS_CFUNC_MAGIC_DEF("toDateString", 0, get_date_string, 0x11 ),
-    JS_CFUNC_MAGIC_DEF("toTimeString", 0, get_date_string, 0x12 ),
-    JS_CFUNC_MAGIC_DEF("toLocaleString", 0, get_date_string, 0x33 ),
-    JS_CFUNC_MAGIC_DEF("toLocaleDateString", 0, get_date_string, 0x31 ),
-    JS_CFUNC_MAGIC_DEF("toLocaleTimeString", 0, get_date_string, 0x32 ),
-    JS_CFUNC_DEF("getTimezoneOffset", 0, js_date_getTimezoneOffset ),
-    JS_CFUNC_DEF("getTime", 0, js_date_getTime ),
-    JS_CFUNC_MAGIC_DEF("getYear", 0, get_date_field, 0x101 ),
-    JS_CFUNC_MAGIC_DEF("getFullYear", 0, get_date_field, 0x01 ),
-    JS_CFUNC_MAGIC_DEF("getUTCFullYear", 0, get_date_field, 0x00 ),
-    JS_CFUNC_MAGIC_DEF("getMonth", 0, get_date_field, 0x11 ),
-    JS_CFUNC_MAGIC_DEF("getUTCMonth", 0, get_date_field, 0x10 ),
-    JS_CFUNC_MAGIC_DEF("getDate", 0, get_date_field, 0x21 ),
-    JS_CFUNC_MAGIC_DEF("getUTCDate", 0, get_date_field, 0x20 ),
-    JS_CFUNC_MAGIC_DEF("getHours", 0, get_date_field, 0x31 ),
-    JS_CFUNC_MAGIC_DEF("getUTCHours", 0, get_date_field, 0x30 ),
-    JS_CFUNC_MAGIC_DEF("getMinutes", 0, get_date_field, 0x41 ),
-    JS_CFUNC_MAGIC_DEF("getUTCMinutes", 0, get_date_field, 0x40 ),
-    JS_CFUNC_MAGIC_DEF("getSeconds", 0, get_date_field, 0x51 ),
-    JS_CFUNC_MAGIC_DEF("getUTCSeconds", 0, get_date_field, 0x50 ),
-    JS_CFUNC_MAGIC_DEF("getMilliseconds", 0, get_date_field, 0x61 ),
-    JS_CFUNC_MAGIC_DEF("getUTCMilliseconds", 0, get_date_field, 0x60 ),
-    JS_CFUNC_MAGIC_DEF("getDay", 0, get_date_field, 0x71 ),
-    JS_CFUNC_MAGIC_DEF("getUTCDay", 0, get_date_field, 0x70 ),
-    JS_CFUNC_DEF("setTime", 1, js_date_setTime ),
-    JS_CFUNC_MAGIC_DEF("setMilliseconds", 1, set_date_field, 0x671 ),
-    JS_CFUNC_MAGIC_DEF("setUTCMilliseconds", 1, set_date_field, 0x670 ),
-    JS_CFUNC_MAGIC_DEF("setSeconds", 2, set_date_field, 0x571 ),
-    JS_CFUNC_MAGIC_DEF("setUTCSeconds", 2, set_date_field, 0x570 ),
-    JS_CFUNC_MAGIC_DEF("setMinutes", 3, set_date_field, 0x471 ),
-    JS_CFUNC_MAGIC_DEF("setUTCMinutes", 3, set_date_field, 0x470 ),
-    JS_CFUNC_MAGIC_DEF("setHours", 4, set_date_field, 0x371 ),
-    JS_CFUNC_MAGIC_DEF("setUTCHours", 4, set_date_field, 0x370 ),
-    JS_CFUNC_MAGIC_DEF("setDate", 1, set_date_field, 0x231 ),
-    JS_CFUNC_MAGIC_DEF("setUTCDate", 1, set_date_field, 0x230 ),
-    JS_CFUNC_MAGIC_DEF("setMonth", 2, set_date_field, 0x131 ),
-    JS_CFUNC_MAGIC_DEF("setUTCMonth", 2, set_date_field, 0x130 ),
-    JS_CFUNC_DEF("setYear", 1, js_date_setYear ),
-    JS_CFUNC_MAGIC_DEF("setFullYear", 3, set_date_field, 0x031 ),
-    JS_CFUNC_MAGIC_DEF("setUTCFullYear", 3, set_date_field, 0x030 ),
-    JS_CFUNC_DEF("toJSON", 1, js_date_toJSON ),
-};
-
-void JS_AddIntrinsicDate(JSContext *ctx)
-{
-    JSValueConst obj;
-
-    /* Date */
-    ctx->class_proto[JS_CLASS_DATE] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_DATE], js_date_proto_funcs,
-                               countof(js_date_proto_funcs));
-    obj = JS_NewGlobalCConstructor(ctx, "Date", js_date_constructor, 7,
-                                   ctx->class_proto[JS_CLASS_DATE]);
-    JS_SetPropertyFunctionList(ctx, obj, js_date_funcs, countof(js_date_funcs));
-}
-
-/* eval */
-
-void JS_AddIntrinsicEval(JSContext *ctx)
-{
-    ctx->eval_internal = __JS_EvalInternal;
-}
-
-#ifdef CONFIG_BIGNUM
-
-/* Operators */
-
-static void js_operator_set_finalizer(JSRuntime *rt, JSValue val)
-{
-    JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
-    int i, j;
-    JSBinaryOperatorDefEntry *ent;
-    
-    if (opset) {
-        for(i = 0; i < JS_OVOP_COUNT; i++) {
-            if (opset->self_ops[i])
-                JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]));
-        }
-        for(j = 0; j < opset->left.count; j++) {
-            ent = &opset->left.tab[j];
-            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
-                if (ent->ops[i])
-                    JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
-            }
-        }
-        js_free_rt(rt, opset->left.tab);
-        for(j = 0; j < opset->right.count; j++) {
-            ent = &opset->right.tab[j];
-            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
-                if (ent->ops[i])
-                    JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]));
-            }
-        }
-        js_free_rt(rt, opset->right.tab);
-        js_free_rt(rt, opset);
-    }
-}
-
-static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
-                                 JS_MarkFunc *mark_func)
-{
-    JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
-    int i, j;
-    JSBinaryOperatorDefEntry *ent;
-    
-    if (opset) {
-        for(i = 0; i < JS_OVOP_COUNT; i++) {
-            if (opset->self_ops[i])
-                JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[i]),
-                             mark_func);
-        }
-        for(j = 0; j < opset->left.count; j++) {
-            ent = &opset->left.tab[j];
-            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
-                if (ent->ops[i])
-                    JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
-                                 mark_func);
-            }
-        }
-        for(j = 0; j < opset->right.count; j++) {
-            ent = &opset->right.tab[j];
-            for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
-                if (ent->ops[i])
-                    JS_MarkValue(rt, JS_MKPTR(JS_TAG_OBJECT, ent->ops[i]),
-                                 mark_func);
-            }
-        }
-    }
-}
-
-
-/* create an OperatorSet object */
-static JSValue js_operators_create_internal(JSContext *ctx,
-                                            int argc, JSValueConst *argv,
-                                            BOOL is_primitive)
-{
-    JSValue opset_obj, prop, obj;
-    JSOperatorSetData *opset, *opset1;
-    JSBinaryOperatorDef *def;
-    JSValueConst arg;
-    int i, j;
-    JSBinaryOperatorDefEntry *new_tab;
-    JSBinaryOperatorDefEntry *ent;
-    uint32_t op_count;
-
-    if (ctx->rt->operator_count == UINT32_MAX) {
-        return JS_ThrowTypeError(ctx, "too many operators");
-    }
-    opset_obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_OPERATOR_SET);
-    if (JS_IsException(opset_obj))
-        goto fail;
-    opset = js_mallocz(ctx, sizeof(*opset));
-    if (!opset)
-        goto fail;
-    JS_SetOpaque(opset_obj, opset);
-    if (argc >= 1) {
-        arg = argv[0];
-        /* self operators */
-        for(i = 0; i < JS_OVOP_COUNT; i++) {
-            prop = JS_GetPropertyStr(ctx, arg, js_overloadable_operator_names[i]);
-            if (JS_IsException(prop))
-                goto fail;
-            if (!JS_IsUndefined(prop)) {
-                if (check_function(ctx, prop)) {
-                    JS_FreeValue(ctx, prop);
-                    goto fail;
-                }
-                opset->self_ops[i] = JS_VALUE_GET_OBJ(prop);
-            }
-        }
-    }
-    /* left & right operators */
-    for(j = 1; j < argc; j++) {
-        arg = argv[j];
-        prop = JS_GetPropertyStr(ctx, arg, "left");
-        if (JS_IsException(prop))
-            goto fail;
-        def = &opset->right;
-        if (JS_IsUndefined(prop)) {
-            prop = JS_GetPropertyStr(ctx, arg, "right");
-            if (JS_IsException(prop))
-                goto fail;
-            if (JS_IsUndefined(prop)) {
-                JS_ThrowTypeError(ctx, "left or right property must be present");
-                goto fail;
-            }
-            def = &opset->left;
-        }
-        /* get the operator set */
-        obj = JS_GetProperty(ctx, prop, JS_ATOM_prototype);
-        JS_FreeValue(ctx, prop);
-        if (JS_IsException(obj))
-            goto fail;
-        prop = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_operatorSet);
-        JS_FreeValue(ctx, obj);
-        if (JS_IsException(prop))
-            goto fail;
-        opset1 = JS_GetOpaque2(ctx, prop, JS_CLASS_OPERATOR_SET);
-        if (!opset1) {
-            JS_FreeValue(ctx, prop);
-            goto fail;
-        }
-        op_count = opset1->operator_counter;
-        JS_FreeValue(ctx, prop);
-        
-        /* we assume there are few entries */
-        new_tab = js_realloc(ctx, def->tab,
-                             (def->count + 1) * sizeof(def->tab[0]));
-        if (!new_tab)
-            goto fail;
-        def->tab = new_tab;
-        def->count++;
-        ent = def->tab + def->count - 1;
-        memset(ent, 0, sizeof(def->tab[0]));
-        ent->operator_index = op_count;
-        
-        for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
-            prop = JS_GetPropertyStr(ctx, arg,
-                                     js_overloadable_operator_names[i]);
-            if (JS_IsException(prop))
-                goto fail;
-            if (!JS_IsUndefined(prop)) {
-                if (check_function(ctx, prop)) {
-                    JS_FreeValue(ctx, prop);
-                    goto fail;
-                }
-                ent->ops[i] = JS_VALUE_GET_OBJ(prop);
-            }
-        }
-    }
-    opset->is_primitive = is_primitive;
-    opset->operator_counter = ctx->rt->operator_count++;
-    return opset_obj;
- fail:
-    JS_FreeValue(ctx, opset_obj);
-    return JS_EXCEPTION;
-}
-
-static JSValue js_operators_create(JSContext *ctx, JSValueConst this_val,
-                                int argc, JSValueConst *argv)
-{
-    return js_operators_create_internal(ctx, argc, argv, FALSE);
-}
-
-static JSValue js_operators_updateBigIntOperators(JSContext *ctx, JSValueConst this_val,
-                                                  int argc, JSValueConst *argv)
-{
-    JSValue opset_obj, prop;
-    JSOperatorSetData *opset;
-    const JSOverloadableOperatorEnum ops[2] = { JS_OVOP_DIV, JS_OVOP_POW };
-    JSOverloadableOperatorEnum op;
-    int i;
-    
-    opset_obj = JS_GetProperty(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
-                               JS_ATOM_Symbol_operatorSet);
-    if (JS_IsException(opset_obj))
-        goto fail;
-    opset = JS_GetOpaque2(ctx, opset_obj, JS_CLASS_OPERATOR_SET);
-    if (!opset)
-        goto fail;
-    for(i = 0; i < countof(ops); i++) {
-        op = ops[i];
-        prop = JS_GetPropertyStr(ctx, argv[0],
-                                 js_overloadable_operator_names[op]);
-        if (JS_IsException(prop))
-            goto fail;
-        if (!JS_IsUndefined(prop)) {
-            if (!JS_IsNull(prop) && check_function(ctx, prop)) {
-                JS_FreeValue(ctx, prop);
-                goto fail;
-            }
-            if (opset->self_ops[op])
-                JS_FreeValue(ctx, JS_MKPTR(JS_TAG_OBJECT, opset->self_ops[op]));
-            if (JS_IsNull(prop)) {
-                opset->self_ops[op] = NULL;
-            } else {
-                opset->self_ops[op] = JS_VALUE_GET_PTR(prop);
-            }
-        }
-    }
-    JS_FreeValue(ctx, opset_obj);
-    return JS_UNDEFINED;
- fail:
-    JS_FreeValue(ctx, opset_obj);
-    return JS_EXCEPTION;
-}
-
-static int js_operators_set_default(JSContext *ctx, JSValueConst obj)
-{
-    JSValue opset_obj;
-
-    if (!JS_IsObject(obj)) /* in case the prototype is not defined */
-        return 0;
-    opset_obj = js_operators_create_internal(ctx, 0, NULL, TRUE);
-    if (JS_IsException(opset_obj))
-        return -1;
-    /* cannot be modified by the user */
-    JS_DefinePropertyValue(ctx, obj, JS_ATOM_Symbol_operatorSet,
-                           opset_obj, 0);
-    return 0;
-}
-
-static JSValue js_dummy_operators_ctor(JSContext *ctx, JSValueConst new_target,
-                                       int argc, JSValueConst *argv)
-{
-    return js_create_from_ctor(ctx, new_target, JS_CLASS_OBJECT);
-}
-
-static JSValue js_global_operators(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv)
-{
-    JSValue func_obj, proto, opset_obj;
-
-    func_obj = JS_UNDEFINED;
-    proto = JS_NewObject(ctx);
-    if (JS_IsException(proto))
-        return JS_EXCEPTION;
-    opset_obj = js_operators_create_internal(ctx, argc, argv, FALSE);
-    if (JS_IsException(opset_obj))
-        goto fail;
-    JS_DefinePropertyValue(ctx, proto, JS_ATOM_Symbol_operatorSet,
-                           opset_obj, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    func_obj = JS_NewCFunction2(ctx, js_dummy_operators_ctor, "Operators",
-                                0, JS_CFUNC_constructor, 0);
-    if (JS_IsException(func_obj))
-        goto fail;
-    JS_SetConstructor2(ctx, func_obj, proto,
-                       0, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    JS_FreeValue(ctx, proto);
-    return func_obj;
- fail:
-    JS_FreeValue(ctx, proto);
-    JS_FreeValue(ctx, func_obj);
-    return JS_EXCEPTION;
-}
-
-static const JSCFunctionListEntry js_operators_funcs[] = {
-    JS_CFUNC_DEF("create", 1, js_operators_create ),
-    JS_CFUNC_DEF("updateBigIntOperators", 2, js_operators_updateBigIntOperators ),
-};
-
-/* must be called after all overloadable base types are initialized */
-void JS_AddIntrinsicOperators(JSContext *ctx)
-{
-    JSValue obj;
-
-    ctx->allow_operator_overloading = TRUE;
-    obj = JS_NewCFunction(ctx, js_global_operators, "Operators", 1);
-    JS_SetPropertyFunctionList(ctx, obj,
-                               js_operators_funcs,
-                               countof(js_operators_funcs));
-    JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_Operators,
-                           obj,
-                           JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
-    /* add default operatorSets */
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BOOLEAN]);
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_NUMBER]);
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_STRING]);
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_INT]);
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT]);
-    js_operators_set_default(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
-}
-#endif /* CONFIG_BIGNUM */
-
-/* BigInt */
-
-static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
-{
-    uint32_t tag;
-
- redo:
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_INT:
-    case JS_TAG_BOOL:
-        val = JS_NewBigInt64(ctx, JS_VALUE_GET_INT(val));
-        break;
-    case JS_TAG_BIG_INT:
-        break;
-    case JS_TAG_FLOAT64:
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_FLOAT:
-#endif        
-        {
-            bf_t *a, a_s;
-            
-            a = JS_ToBigFloat(ctx, &a_s, val);
-            if (!a) {
-                JS_FreeValue(ctx, val);
-                return JS_EXCEPTION;
-            }
-            if (!bf_is_finite(a)) {
-                JS_FreeValue(ctx, val);
-                val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to bigint");
-            } else {
-                JSValue val1 = JS_NewBigInt(ctx);
-                bf_t *r;
-                int ret;
-                if (JS_IsException(val1)) {
-                    JS_FreeValue(ctx, val);
-                    return JS_EXCEPTION;
-                }
-                r = JS_GetBigInt(val1);
-                ret = bf_set(r, a);
-                ret |= bf_rint(r, BF_RNDZ);
-                JS_FreeValue(ctx, val);
-                if (ret & BF_ST_MEM_ERROR) {
-                    JS_FreeValue(ctx, val1);
-                    val = JS_ThrowOutOfMemory(ctx);
-                } else if (ret & BF_ST_INEXACT) {
-                    JS_FreeValue(ctx, val1);
-                    val = JS_ThrowRangeError(ctx, "cannot convert to bigint: not an integer");
-                } else {
-                    val = JS_CompactBigInt(ctx, val1);
-                }
-            }
-            if (a == &a_s)
-                bf_delete(a);
-        }
-        break;
-#ifdef CONFIG_BIGNUM
-    case JS_TAG_BIG_DECIMAL:
-        val = JS_ToStringFree(ctx, val);
-         if (JS_IsException(val))
-            break;
-        goto redo;
-#endif        
-    case JS_TAG_STRING:
-        val = JS_StringToBigIntErr(ctx, val);
-        break;
-    case JS_TAG_OBJECT:
-        val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
-        if (JS_IsException(val))
-            break;
-        goto redo;
-    case JS_TAG_NULL:
-    case JS_TAG_UNDEFINED:
-    default:
-        JS_FreeValue(ctx, val);
-        return JS_ThrowTypeError(ctx, "cannot convert to bigint");
-    }
-    return val;
-}
-
-static JSValue js_bigint_constructor(JSContext *ctx,
-                                     JSValueConst new_target,
-                                     int argc, JSValueConst *argv)
-{
-    if (!JS_IsUndefined(new_target))
-        return JS_ThrowTypeError(ctx, "not a constructor");
-    return JS_ToBigIntCtorFree(ctx, JS_DupValue(ctx, argv[0]));
-}
-
-static JSValue js_thisBigIntValue(JSContext *ctx, JSValueConst this_val)
-{
-    if (JS_IsBigInt(ctx, this_val))
-        return JS_DupValue(ctx, this_val);
-
-    if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
-        JSObject *p = JS_VALUE_GET_OBJ(this_val);
-        if (p->class_id == JS_CLASS_BIG_INT) {
-            if (JS_IsBigInt(ctx, p->u.object_data))
-                return JS_DupValue(ctx, p->u.object_data);
-        }
-    }
-    return JS_ThrowTypeError(ctx, "not a bigint");
-}
-
-static JSValue js_bigint_toString(JSContext *ctx, JSValueConst this_val,
-                                  int argc, JSValueConst *argv)
-{
-    JSValue val;
-    int base;
-    JSValue ret;
-
-    val = js_thisBigIntValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (argc == 0 || JS_IsUndefined(argv[0])) {
-        base = 10;
-    } else {
-        base = js_get_radix(ctx, argv[0]);
-        if (base < 0)
-            goto fail;
-    }
-    ret = js_bigint_to_string1(ctx, val, base);
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
-
-static JSValue js_bigint_valueOf(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
-{
-    return js_thisBigIntValue(ctx, this_val);
-}
-
-#ifdef CONFIG_BIGNUM
-static JSValue js_bigint_div(JSContext *ctx,
-                              JSValueConst this_val,
-                              int argc, JSValueConst *argv, int magic)
-{
-    bf_t a_s, b_s, *a, *b, *r, *q;
-    int status;
-    JSValue q_val, r_val;
-    
-    q_val = JS_NewBigInt(ctx);
-    if (JS_IsException(q_val))
-        return JS_EXCEPTION;
-    r_val = JS_NewBigInt(ctx);
-    if (JS_IsException(r_val))
-        goto fail;
-    b = NULL;
-    a = JS_ToBigInt(ctx, &a_s, argv[0]);
-    if (!a)
-        goto fail;
-    b = JS_ToBigInt(ctx, &b_s, argv[1]);
-    if (!b) {
-        JS_FreeBigInt(ctx, a, &a_s);
-        goto fail;
-    }
-    q = JS_GetBigInt(q_val);
-    r = JS_GetBigInt(r_val);
-    status = bf_divrem(q, r, a, b, BF_PREC_INF, BF_RNDZ, magic & 0xf);
-    JS_FreeBigInt(ctx, a, &a_s);
-    JS_FreeBigInt(ctx, b, &b_s);
-    if (unlikely(status)) {
-        throw_bf_exception(ctx, status);
-        goto fail;
-    }
-    q_val = JS_CompactBigInt(ctx, q_val);
-    if (magic & 0x10) {
-        JSValue ret;
-        ret = JS_NewArray(ctx);
-        if (JS_IsException(ret))
-            goto fail;
-        JS_SetPropertyUint32(ctx, ret, 0, q_val);
-        JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, r_val));
-        return ret;
-    } else {
-        JS_FreeValue(ctx, r_val);
-        return q_val;
+#else
+    rv = js_create_from_ctor(ctx, new_target, JS_CLASS_DATE);
+    if (!JS_IsException(rv))
+        JS_SetObjectData(ctx, rv, JS_NewFloat64(ctx, val));
+#endif
+    if (!JS_IsException(rv) && JS_IsUndefined(new_target)) {
+        /* invoked as a function, return (new Date()).toString(); */
+        JSValue s;
+        s = get_date_string(ctx, rv, 0, NULL, 0x13);
+        JS_FreeValue(ctx, rv);
+        rv = s;
     }
- fail:
-    JS_FreeValue(ctx, q_val);
-    JS_FreeValue(ctx, r_val);
-    return JS_EXCEPTION;
+    return rv;
 }
 
-static JSValue js_bigint_sqrt(JSContext *ctx,
-                               JSValueConst this_val,
-                               int argc, JSValueConst *argv, int magic)
+static JSValue js_Date_UTC(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
 {
-    bf_t a_s, *a, *r, *rem;
-    int status;
-    JSValue r_val, rem_val;
-    
-    r_val = JS_NewBigInt(ctx);
-    if (JS_IsException(r_val))
-        return JS_EXCEPTION;
-    rem_val = JS_NewBigInt(ctx);
-    if (JS_IsException(rem_val))
-        return JS_EXCEPTION;
-    r = JS_GetBigInt(r_val);
-    rem = JS_GetBigInt(rem_val);
+    // UTC(y, mon, d, h, m, s, ms)
+    double fields[] = { 0, 0, 1, 0, 0, 0, 0 };
+    int i, n;
+    double a;
 
-    a = JS_ToBigInt(ctx, &a_s, argv[0]);
-    if (!a)
-        goto fail;
-    status = bf_sqrtrem(r, rem, a);
-    JS_FreeBigInt(ctx, a, &a_s);
-    if (unlikely(status & ~BF_ST_INEXACT)) {
-        throw_bf_exception(ctx, status);
-        goto fail;
-    }
-    r_val = JS_CompactBigInt(ctx, r_val);
-    if (magic) {
-        JSValue ret;
-        ret = JS_NewArray(ctx);
-        if (JS_IsException(ret))
-            goto fail;
-        JS_SetPropertyUint32(ctx, ret, 0, r_val);
-        JS_SetPropertyUint32(ctx, ret, 1, JS_CompactBigInt(ctx, rem_val));
-        return ret;
-    } else {
-        JS_FreeValue(ctx, rem_val);
-        return r_val;
+    n = argc;
+    if (n == 0)
+        return JS_NAN;
+    if (n > 7)
+        n = 7;
+    for(i = 0; i < n; i++) {
+        if (JS_ToFloat64(ctx, &a, argv[i]))
+            return JS_EXCEPTION;
+        if (!isfinite(a))
+            return JS_NAN;
+        fields[i] = trunc(a);
+        if (i == 0 && fields[0] >= 0 && fields[0] < 100)
+            fields[0] += 1900;
     }
- fail:
-    JS_FreeValue(ctx, r_val);
-    JS_FreeValue(ctx, rem_val);
-    return JS_EXCEPTION;
+    return JS_NewFloat64(ctx, set_date_fields(fields, 0));
 }
 
-static JSValue js_bigint_op1(JSContext *ctx,
-                              JSValueConst this_val,
-                              int argc, JSValueConst *argv,
-                              int magic)
-{
-    bf_t a_s, *a;
-    int64_t res;
+/* Date string parsing */
 
-    a = JS_ToBigInt(ctx, &a_s, argv[0]);
-    if (!a)
-        return JS_EXCEPTION;
-    switch(magic) {
-    case 0: /* floorLog2 */
-        if (a->sign || a->expn <= 0) {
-            res = -1;
-        } else {
-            res = a->expn - 1;
-        }
-        break;
-    case 1: /* ctz */
-        if (bf_is_zero(a)) {
-            res = -1;
-        } else {
-            res = bf_get_exp_min(a);
-        }
-        break;
-    default:
-        abort();
+static BOOL string_skip_char(const uint8_t *sp, int *pp, int c) {
+    if (sp[*pp] == c) {
+        *pp += 1;
+        return TRUE;
+    } else {
+        return FALSE;
     }
-    JS_FreeBigInt(ctx, a, &a_s);
-    return JS_NewBigInt64(ctx, res);
 }
-#endif
 
-static JSValue js_bigint_asUintN(JSContext *ctx,
-                                  JSValueConst this_val,
-                                  int argc, JSValueConst *argv, int asIntN)
-{
-    uint64_t bits;
-    bf_t a_s, *a = &a_s, *r, mask_s, *mask = &mask_s;
-    JSValue res;
-    
-    if (JS_ToIndex(ctx, &bits, argv[0]))
-        return JS_EXCEPTION;
-    res = JS_NewBigInt(ctx);
-    if (JS_IsException(res))
-        return JS_EXCEPTION;
-    r = JS_GetBigInt(res);
-    a = JS_ToBigInt(ctx, &a_s, argv[1]);
-    if (!a) {
-        JS_FreeValue(ctx, res);
-        return JS_EXCEPTION;
-    }
-    /* XXX: optimize */
-    r = JS_GetBigInt(res);
-    bf_init(ctx->bf_ctx, mask);
-    bf_set_ui(mask, 1);
-    bf_mul_2exp(mask, bits, BF_PREC_INF, BF_RNDZ);
-    bf_add_si(mask, mask, -1, BF_PREC_INF, BF_RNDZ);
-    bf_logic_and(r, a, mask);
-    if (asIntN && bits != 0) {
-        bf_set_ui(mask, 1);
-        bf_mul_2exp(mask, bits - 1, BF_PREC_INF, BF_RNDZ);
-        if (bf_cmpu(r, mask) >= 0) {
-            bf_set_ui(mask, 1);
-            bf_mul_2exp(mask, bits, BF_PREC_INF, BF_RNDZ);
-            bf_sub(r, r, mask, BF_PREC_INF, BF_RNDZ);
-        }
-    }
-    bf_delete(mask);
-    JS_FreeBigInt(ctx, a, &a_s);
-    return JS_CompactBigInt(ctx, res);
+/* skip spaces, update offset, return next char */
+static int string_skip_spaces(const uint8_t *sp, int *pp) {
+    int c;
+    while ((c = sp[*pp]) == ' ')
+        *pp += 1;
+    return c;
 }
 
-static const JSCFunctionListEntry js_bigint_funcs[] = {
-    JS_CFUNC_MAGIC_DEF("asUintN", 2, js_bigint_asUintN, 0 ),
-    JS_CFUNC_MAGIC_DEF("asIntN", 2, js_bigint_asUintN, 1 ),
-#ifdef CONFIG_BIGNUM
-    /* QuickJS extensions */
-    JS_CFUNC_MAGIC_DEF("tdiv", 2, js_bigint_div, BF_RNDZ ),
-    JS_CFUNC_MAGIC_DEF("fdiv", 2, js_bigint_div, BF_RNDD ),
-    JS_CFUNC_MAGIC_DEF("cdiv", 2, js_bigint_div, BF_RNDU ),
-    JS_CFUNC_MAGIC_DEF("ediv", 2, js_bigint_div, BF_DIVREM_EUCLIDIAN ),
-    JS_CFUNC_MAGIC_DEF("tdivrem", 2, js_bigint_div, BF_RNDZ | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("fdivrem", 2, js_bigint_div, BF_RNDD | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("cdivrem", 2, js_bigint_div, BF_RNDU | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("edivrem", 2, js_bigint_div, BF_DIVREM_EUCLIDIAN | 0x10 ),
-    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigint_sqrt, 0 ),
-    JS_CFUNC_MAGIC_DEF("sqrtrem", 1, js_bigint_sqrt, 1 ),
-    JS_CFUNC_MAGIC_DEF("floorLog2", 1, js_bigint_op1, 0 ),
-    JS_CFUNC_MAGIC_DEF("ctz", 1, js_bigint_op1, 1 ),
-#endif    
-};
-
-static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
-    JS_CFUNC_DEF("toString", 0, js_bigint_toString ),
-    JS_CFUNC_DEF("valueOf", 0, js_bigint_valueOf ),
-    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "BigInt", JS_PROP_CONFIGURABLE ),
-};
-
-void JS_AddIntrinsicBigInt(JSContext *ctx)
-{
-    JSRuntime *rt = ctx->rt;
-    JSValueConst obj1;
-
-    rt->bigint_ops.to_string = js_bigint_to_string;
-    rt->bigint_ops.from_string = js_string_to_bigint;
-    rt->bigint_ops.unary_arith = js_unary_arith_bigint;
-    rt->bigint_ops.binary_arith = js_binary_arith_bigint;
-    rt->bigint_ops.compare = js_compare_bigfloat;
-
-    ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
-                               js_bigint_proto_funcs,
-                               countof(js_bigint_proto_funcs));
-    obj1 = JS_NewGlobalCConstructor(ctx, "BigInt", js_bigint_constructor, 1,
-                                    ctx->class_proto[JS_CLASS_BIG_INT]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_bigint_funcs,
-                               countof(js_bigint_funcs));
+/* skip dashes dots and commas */
+static int string_skip_separators(const uint8_t *sp, int *pp) {
+    int c;
+    while ((c = sp[*pp]) == '-' || c == '/' || c == '.' || c == ',')
+        *pp += 1;
+    return c;
 }
 
-#ifdef CONFIG_BIGNUM
-
-/* BigFloat */
+/* skip a word, stop on spaces, digits and separators, update offset */
+static int string_skip_until(const uint8_t *sp, int *pp, const char *stoplist) {
+    int c;
+    while (!strchr(stoplist, c = sp[*pp]))
+        *pp += 1;
+    return c;
+}
 
-static JSValue js_thisBigFloatValue(JSContext *ctx, JSValueConst this_val)
+/* parse a numeric field (max_digits = 0 -> no maximum) */
+static BOOL string_get_digits(const uint8_t *sp, int *pp, int *pval,
+                              int min_digits, int max_digits)
 {
-    if (JS_IsBigFloat(this_val))
-        return JS_DupValue(ctx, this_val);
+    int v = 0;
+    int c, p = *pp, p_start;
 
-    if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
-        JSObject *p = JS_VALUE_GET_OBJ(this_val);
-        if (p->class_id == JS_CLASS_BIG_FLOAT) {
-            if (JS_IsBigFloat(p->u.object_data))
-                return JS_DupValue(ctx, p->u.object_data);
-        }
+    p_start = p;
+    while ((c = sp[p]) >= '0' && c <= '9') {
+        /* arbitrary limit to 9 digits */
+        if (v >= 100000000)
+            return FALSE;
+        v = v * 10 + c - '0';
+        p++;
+        if (p - p_start == max_digits)
+            break;
     }
-    return JS_ThrowTypeError(ctx, "not a bigfloat");
+    if (p - p_start < min_digits)
+        return FALSE;
+    *pval = v;
+    *pp = p;
+    return TRUE;
 }
 
-static JSValue js_bigfloat_toString(JSContext *ctx, JSValueConst this_val,
-                                    int argc, JSValueConst *argv)
-{
-    JSValue val;
-    int base;
-    JSValue ret;
+static BOOL string_get_milliseconds(const uint8_t *sp, int *pp, int *pval) {
+    /* parse optional fractional part as milliseconds and truncate. */
+    /* spec does not indicate which rounding should be used */
+    int mul = 100, ms = 0, c, p_start, p = *pp;
 
-    val = js_thisBigFloatValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (argc == 0 || JS_IsUndefined(argv[0])) {
-        base = 10;
-    } else {
-        base = js_get_radix(ctx, argv[0]);
-        if (base < 0)
-            goto fail;
+    c = sp[p];
+    if (c == '.' || c == ',') {
+        p++;
+        p_start = p;
+        while ((c = sp[p]) >= '0' && c <= '9') {
+            ms += (c - '0') * mul;
+            mul /= 10;
+            p++;
+            if (p - p_start == 9)
+                break;
+        }
+        if (p > p_start) {
+            /* only consume the separator if digits are present */
+            *pval = ms;
+            *pp = p;
+        }
     }
-    ret = js_ftoa(ctx, val, base, 0, BF_RNDN | BF_FTOA_FORMAT_FREE_MIN);
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
+    return TRUE;
 }
 
-static JSValue js_bigfloat_valueOf(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv)
-{
-    return js_thisBigFloatValue(ctx, this_val);
+static uint8_t upper_ascii(uint8_t c) {
+    return c >= 'a' && c <= 'z' ? c - 'a' + 'A' : c;
 }
 
-static int bigfloat_get_rnd_mode(JSContext *ctx, JSValueConst val)
-{
-    int rnd_mode;
-    if (JS_ToInt32Sat(ctx, &rnd_mode, val))
-        return -1;
-    if (rnd_mode < BF_RNDN || rnd_mode > BF_RNDF) {
-        JS_ThrowRangeError(ctx, "invalid rounding mode");
-        return -1;
+static BOOL string_get_tzoffset(const uint8_t *sp, int *pp, int *tzp, BOOL strict) {
+    int tz = 0, sgn, hh, mm, p = *pp;
+
+    sgn = sp[p++];
+    if (sgn == '+' || sgn == '-') {
+        int n = p;
+        if (!string_get_digits(sp, &p, &hh, 1, 0))
+            return FALSE;
+        n = p - n;
+        if (strict && n != 2 && n != 4)
+            return FALSE;
+        while (n > 4) {
+            n -= 2;
+            hh /= 100;
+        }
+        if (n > 2) {
+            mm = hh % 100;
+            hh = hh / 100;
+        } else {
+            mm = 0;
+            if (string_skip_char(sp, &p, ':')  /* optional separator */
+            &&  !string_get_digits(sp, &p, &mm, 2, 2))
+                return FALSE;
+        }
+        if (hh > 23 || mm > 59)
+            return FALSE;
+        tz = hh * 60 + mm;
+        if (sgn != '+')
+            tz = -tz;
+    } else
+    if (sgn != 'Z') {
+        return FALSE;
     }
-    return rnd_mode;
+    *pp = p;
+    *tzp = tz;
+    return TRUE;
 }
 
-static JSValue js_bigfloat_toFixed(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
-{
-    JSValue val, ret;
-    int64_t f;
-    int rnd_mode, radix;
-
-    val = js_thisBigFloatValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (f < 0 || f > BF_PREC_MAX) {
-        JS_ThrowRangeError(ctx, "invalid number of digits");
-        goto fail;
-    }
-    rnd_mode = BF_RNDNA;
-    radix = 10;
-    /* XXX: swap parameter order for rounding mode and radix */
-    if (argc > 1) {
-        rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
-        if (rnd_mode < 0)
-            goto fail;
-    }
-    if (argc > 2) {
-        radix = js_get_radix(ctx, argv[2]);
-        if (radix < 0)
-            goto fail;
+static BOOL string_match(const uint8_t *sp, int *pp, const char *s) {
+    int p = *pp;
+    while (*s != '\0') {
+        if (upper_ascii(sp[p]) != upper_ascii(*s++))
+            return FALSE;
+        p++;
     }
-    ret = js_ftoa(ctx, val, radix, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
+    *pp = p;
+    return TRUE;
 }
 
-static BOOL js_bigfloat_is_finite(JSContext *ctx, JSValueConst val)
-{
-    BOOL res;
-    uint32_t tag;
+static int find_abbrev(const uint8_t *sp, int p, const char *list, int count) {
+    int n, i;
 
-    tag = JS_VALUE_GET_NORM_TAG(val);
-    switch(tag) {
-    case JS_TAG_BIG_FLOAT:
-        {
-            JSBigFloat *p = JS_VALUE_GET_PTR(val);
-            res = bf_is_finite(&p->num);
+    for (n = 0; n < count; n++) {
+        for (i = 0;; i++) {
+            if (upper_ascii(sp[p + i]) != upper_ascii(list[n * 3 + i]))
+                break;
+            if (i == 2)
+                return n;
         }
-        break;
-    default:
-        res = FALSE;
-        break;
     }
-    return res;
+    return -1;
 }
 
-static JSValue js_bigfloat_toExponential(JSContext *ctx, JSValueConst this_val,
-                                       int argc, JSValueConst *argv)
-{
-    JSValue val, ret;
-    int64_t f;
-    int rnd_mode, radix;
+static BOOL string_get_month(const uint8_t *sp, int *pp, int *pval) {
+    int n;
 
-    val = js_thisBigFloatValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (!js_bigfloat_is_finite(ctx, val)) {
-        ret = JS_ToString(ctx, val);
-    } else if (JS_IsUndefined(argv[0])) {
-        ret = js_ftoa(ctx, val, 10, 0,
-                      BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
-    } else {
-        if (f < 0 || f > BF_PREC_MAX) {
-            JS_ThrowRangeError(ctx, "invalid number of digits");
-            goto fail;
-        }
-        rnd_mode = BF_RNDNA;
-        radix = 10;
-        if (argc > 1) {
-            rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
-            if (rnd_mode < 0)
-                goto fail;
-        }
-        if (argc > 2) {
-            radix = js_get_radix(ctx, argv[2]);
-            if (radix < 0)
-                goto fail;
-        }
-        ret = js_ftoa(ctx, val, radix, f + 1,
-                      rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
-    }
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
+    n = find_abbrev(sp, *pp, month_names, 12);
+    if (n < 0)
+        return FALSE;
+
+    *pval = n + 1;
+    *pp += 3;
+    return TRUE;
 }
 
-static JSValue js_bigfloat_toPrecision(JSContext *ctx, JSValueConst this_val,
-                                     int argc, JSValueConst *argv)
-{
-    JSValue val, ret;
-    int64_t p;
-    int rnd_mode, radix;
+/* parse toISOString format */
+static BOOL js_date_parse_isostring(const uint8_t *sp, int fields[9], BOOL *is_local) {
+    int sgn, i, p = 0;
 
-    val = js_thisBigFloatValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_IsUndefined(argv[0]))
-        goto to_string;
-    if (JS_ToInt64Sat(ctx, &p, argv[0]))
-        goto fail;
-    if (!js_bigfloat_is_finite(ctx, val)) {
-    to_string:
-        ret = JS_ToString(ctx, this_val);
+    /* initialize fields to the beginning of the Epoch */
+    for (i = 0; i < 9; i++) {
+        fields[i] = (i == 2);
+    }
+    *is_local = FALSE;
+
+    /* year is either yyyy digits or [+-]yyyyyy */
+    sgn = sp[p];
+    if (sgn == '-' || sgn == '+') {
+        p++;
+        if (!string_get_digits(sp, &p, &fields[0], 6, 6))
+            return FALSE;
+        if (sgn == '-') {
+            if (fields[0] == 0)
+                return FALSE; // reject -000000
+            fields[0] = -fields[0];
+        }
     } else {
-        if (p < 1 || p > BF_PREC_MAX) {
-            JS_ThrowRangeError(ctx, "invalid number of digits");
-            goto fail;
+        if (!string_get_digits(sp, &p, &fields[0], 4, 4))
+            return FALSE;
+    }
+    if (string_skip_char(sp, &p, '-')) {
+        if (!string_get_digits(sp, &p, &fields[1], 2, 2))  /* month */
+            return FALSE;
+        if (fields[1] < 1)
+            return FALSE;
+        fields[1] -= 1;
+        if (string_skip_char(sp, &p, '-')) {
+            if (!string_get_digits(sp, &p, &fields[2], 2, 2))  /* day */
+                return FALSE;
+            if (fields[2] < 1)
+                return FALSE;
         }
-        rnd_mode = BF_RNDNA;
-        radix = 10;
-        if (argc > 1) {
-            rnd_mode = bigfloat_get_rnd_mode(ctx, argv[1]);
-            if (rnd_mode < 0)
-                goto fail;
+    }
+    if (string_skip_char(sp, &p, 'T')) {
+        *is_local = TRUE;
+        if (!string_get_digits(sp, &p, &fields[3], 2, 2)  /* hour */
+        ||  !string_skip_char(sp, &p, ':')
+        ||  !string_get_digits(sp, &p, &fields[4], 2, 2)) {  /* minute */
+            fields[3] = 100;  // reject unconditionally
+            return TRUE;
         }
-        if (argc > 2) {
-            radix = js_get_radix(ctx, argv[2]);
-            if (radix < 0)
-                goto fail;
+        if (string_skip_char(sp, &p, ':')) {
+            if (!string_get_digits(sp, &p, &fields[5], 2, 2))  /* second */
+                return FALSE;
+            string_get_milliseconds(sp, &p, &fields[6]);
         }
-        ret = js_ftoa(ctx, val, radix, p, rnd_mode | BF_FTOA_FORMAT_FIXED);
     }
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
-
-static const JSCFunctionListEntry js_bigfloat_proto_funcs[] = {
-    JS_CFUNC_DEF("toString", 0, js_bigfloat_toString ),
-    JS_CFUNC_DEF("valueOf", 0, js_bigfloat_valueOf ),
-    JS_CFUNC_DEF("toPrecision", 1, js_bigfloat_toPrecision ),
-    JS_CFUNC_DEF("toFixed", 1, js_bigfloat_toFixed ),
-    JS_CFUNC_DEF("toExponential", 1, js_bigfloat_toExponential ),
+    /* parse the time zone offset if present: [+-]HH:mm or [+-]HHmm */
+    if (sp[p]) {
+        *is_local = FALSE;
+        if (!string_get_tzoffset(sp, &p, &fields[8], TRUE))
+            return FALSE;
+    }
+    /* error if extraneous characters */
+    return sp[p] == '\0';
+}
+
+static struct {
+    char name[6];
+    int16_t offset;
+} const js_tzabbr[] = {
+    { "GMT",   0 },         // Greenwich Mean Time
+    { "UTC",   0 },         // Coordinated Universal Time
+    { "UT",    0 },         // Universal Time
+    { "Z",     0 },         // Zulu Time
+    { "EDT",  -4 * 60 },    // Eastern Daylight Time
+    { "EST",  -5 * 60 },    // Eastern Standard Time
+    { "CDT",  -5 * 60 },    // Central Daylight Time
+    { "CST",  -6 * 60 },    // Central Standard Time
+    { "MDT",  -6 * 60 },    // Mountain Daylight Time
+    { "MST",  -7 * 60 },    // Mountain Standard Time
+    { "PDT",  -7 * 60 },    // Pacific Daylight Time
+    { "PST",  -8 * 60 },    // Pacific Standard Time
+    { "WET",  +0 * 60 },    // Western European Time
+    { "WEST", +1 * 60 },    // Western European Summer Time
+    { "CET",  +1 * 60 },    // Central European Time
+    { "CEST", +2 * 60 },    // Central European Summer Time
+    { "EET",  +2 * 60 },    // Eastern European Time
+    { "EEST", +3 * 60 },    // Eastern European Summer Time
 };
 
-static JSValue js_bigfloat_constructor(JSContext *ctx,
-                                       JSValueConst new_target,
-                                       int argc, JSValueConst *argv)
-{
-    JSValue val;
-    if (!JS_IsUndefined(new_target))
-        return JS_ThrowTypeError(ctx, "not a constructor");
-    if (argc == 0) {
-        bf_t *r;
-        val = JS_NewBigFloat(ctx);
-        if (JS_IsException(val))
-            return val;
-        r = JS_GetBigFloat(val);
-        bf_set_zero(r, 0);
-    } else {
-        val = JS_DupValue(ctx, argv[0]);
-    redo:
-        switch(JS_VALUE_GET_NORM_TAG(val)) {
-        case JS_TAG_BIG_FLOAT:
-            break;
-        case JS_TAG_FLOAT64:
-            {
-                bf_t *r;
-                double d = JS_VALUE_GET_FLOAT64(val);
-                val = JS_NewBigFloat(ctx);
-                if (JS_IsException(val))
-                    break;
-                r = JS_GetBigFloat(val);
-                if (bf_set_float64(r, d))
-                    goto fail;
-            }
-            break;
-        case JS_TAG_INT:
-            {
-                bf_t *r;
-                int32_t v = JS_VALUE_GET_INT(val);
-                val = JS_NewBigFloat(ctx);
-                if (JS_IsException(val))
-                    break;
-                r = JS_GetBigFloat(val);
-                if (bf_set_si(r, v))
-                    goto fail;
-            }
-            break;
-        case JS_TAG_BIG_INT:
-            /* We keep the full precision of the integer */
-            {
-                JSBigFloat *p = JS_VALUE_GET_PTR(val);
-                val = JS_MKPTR(JS_TAG_BIG_FLOAT, p);
-            }
-            break;
-        case JS_TAG_BIG_DECIMAL:
-            val = JS_ToStringFree(ctx, val);
-            if (JS_IsException(val))
-                break;
-            goto redo;
-        case JS_TAG_STRING:
-            {
-                const char *str, *p;
-                size_t len;
-                int err;
+static BOOL string_get_tzabbr(const uint8_t *sp, int *pp, int *offset) {
+    for (size_t i = 0; i < countof(js_tzabbr); i++) {
+        if (string_match(sp, pp, js_tzabbr[i].name)) {
+            *offset = js_tzabbr[i].offset;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
 
-                str = JS_ToCStringLen(ctx, &len, val);
-                JS_FreeValue(ctx, val);
-                if (!str)
-                    return JS_EXCEPTION;
-                p = str;
-                p += skip_spaces(p);
-                if ((p - str) == len) {
-                    bf_t *r;
-                    val = JS_NewBigFloat(ctx);
-                    if (JS_IsException(val))
-                        break;
-                    r = JS_GetBigFloat(val);
-                    bf_set_zero(r, 0);
-                    err = 0;
-                } else {
-                    val = js_atof(ctx, p, &p, 0, ATOD_ACCEPT_BIN_OCT |
-                                  ATOD_TYPE_BIG_FLOAT |
-                                  ATOD_ACCEPT_PREFIX_AFTER_SIGN);
-                    if (JS_IsException(val)) {
-                        JS_FreeCString(ctx, str);
-                        return JS_EXCEPTION;
+/* parse toString, toUTCString and other formats */
+static BOOL js_date_parse_otherstring(const uint8_t *sp,
+                                      int fields[minimum_length(9)],
+                                      BOOL *is_local) {
+    int c, i, val, p = 0, p_start;
+    int num[3];
+    BOOL has_year = FALSE;
+    BOOL has_mon = FALSE;
+    BOOL has_time = FALSE;
+    int num_index = 0;
+
+    /* initialize fields to the beginning of 2001-01-01 */
+    fields[0] = 2001;
+    fields[1] = 1;
+    fields[2] = 1;
+    for (i = 3; i < 9; i++) {
+        fields[i] = 0;
+    }
+    *is_local = TRUE;
+
+    while (string_skip_spaces(sp, &p)) {
+        p_start = p;
+        if ((c = sp[p]) == '+' || c == '-') {
+            if (has_time && string_get_tzoffset(sp, &p, &fields[8], FALSE)) {
+                *is_local = FALSE;
+            } else {
+                p++;
+                if (string_get_digits(sp, &p, &val, 1, 0)) {
+                    if (c == '-') {
+                        if (val == 0)
+                            return FALSE;
+                        val = -val;
                     }
-                    p += skip_spaces(p);
-                    err = ((p - str) != len);
+                    fields[0] = val;
+                    has_year = TRUE;
                 }
-                JS_FreeCString(ctx, str);
-                if (err) {
-                    JS_FreeValue(ctx, val);
-                    return JS_ThrowSyntaxError(ctx, "invalid bigfloat literal");
+            }
+        } else
+        if (string_get_digits(sp, &p, &val, 1, 0)) {
+            if (string_skip_char(sp, &p, ':')) {
+                /* time part */
+                fields[3] = val;
+                if (!string_get_digits(sp, &p, &fields[4], 1, 2))
+                    return FALSE;
+                if (string_skip_char(sp, &p, ':')) {
+                    if (!string_get_digits(sp, &p, &fields[5], 1, 2))
+                        return FALSE;
+                    string_get_milliseconds(sp, &p, &fields[6]);
+                }
+                has_time = TRUE;
+            } else {
+                if (p - p_start > 2) {
+                    fields[0] = val;
+                    has_year = TRUE;
+                } else
+                if (val < 1 || val > 31) {
+                    fields[0] = val + (val < 100) * 1900 + (val < 50) * 100;
+                    has_year = TRUE;
+                } else {
+                    if (num_index == 3)
+                        return FALSE;
+                    num[num_index++] = val;
                 }
             }
-            break;
-        case JS_TAG_OBJECT:
-            val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
-            if (JS_IsException(val))
-                break;
-            goto redo;
-        case JS_TAG_NULL:
-        case JS_TAG_UNDEFINED:
-        default:
-            JS_FreeValue(ctx, val);
-            return JS_ThrowTypeError(ctx, "cannot convert to bigfloat");
+        } else
+        if (string_get_month(sp, &p, &fields[1])) {
+            has_mon = TRUE;
+            string_skip_until(sp, &p, "0123456789 -/(");
+        } else
+        if (has_time && string_match(sp, &p, "PM")) {
+            if (fields[3] < 12)
+                fields[3] += 12;
+            continue;
+        } else
+        if (has_time && string_match(sp, &p, "AM")) {
+            if (fields[3] == 12)
+                fields[3] -= 12;
+            continue;
+        } else
+        if (string_get_tzabbr(sp, &p, &fields[8])) {
+            *is_local = FALSE;
+            continue;
+        } else
+        if (c == '(') {  /* skip parenthesized phrase */
+            int level = 0;
+            while ((c = sp[p]) != '\0') {
+                p++;
+                level += (c == '(');
+                level -= (c == ')');
+                if (!level)
+                    break;
+            }
+            if (level > 0)
+                return FALSE;
+        } else
+        if (c == ')') {
+            return FALSE;
+        } else {
+            if (has_year + has_mon + has_time + num_index)
+                return FALSE;
+            /* skip a word */
+            string_skip_until(sp, &p, " -/(");
         }
+        string_skip_separators(sp, &p);
     }
-    return val;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
-}
+    if (num_index + has_year + has_mon > 3)
+        return FALSE;
 
-static JSValue js_bigfloat_get_const(JSContext *ctx,
-                                     JSValueConst this_val, int magic)
-{
-    bf_t *r;
-    JSValue val;
-    val = JS_NewBigFloat(ctx);
-    if (JS_IsException(val))
-        return val;
-    r = JS_GetBigFloat(val);
-    switch(magic) {
-    case 0: /* PI */
-        bf_const_pi(r, ctx->fp_env.prec, ctx->fp_env.flags);
+    switch (num_index) {
+    case 0:
+        if (!has_year)
+            return FALSE;
         break;
-    case 1: /* LN2 */
-        bf_const_log2(r, ctx->fp_env.prec, ctx->fp_env.flags);
+    case 1:
+        if (has_mon)
+            fields[2] = num[0];
+        else
+            fields[1] = num[0];
         break;
-    case 2: /* MIN_VALUE */
-    case 3: /* MAX_VALUE */
-        {
-            slimb_t e_range, e;
-            e_range = (limb_t)1 << (bf_get_exp_bits(ctx->fp_env.flags) - 1);
-            bf_set_ui(r, 1);
-            if (magic == 2) {
-                e = -e_range + 2;
-                if (ctx->fp_env.flags & BF_FLAG_SUBNORMAL)
-                    e -= ctx->fp_env.prec - 1;
-                bf_mul_2exp(r, e, ctx->fp_env.prec, ctx->fp_env.flags);
-            } else {
-                bf_mul_2exp(r, ctx->fp_env.prec, ctx->fp_env.prec,
-                            ctx->fp_env.flags);
-                bf_add_si(r, r, -1, ctx->fp_env.prec, ctx->fp_env.flags);
-                bf_mul_2exp(r, e_range - ctx->fp_env.prec, ctx->fp_env.prec,
-                            ctx->fp_env.flags);
-            }
+    case 2:
+        if (has_year) {
+            fields[1] = num[0];
+            fields[2] = num[1];
+        } else
+        if (has_mon) {
+            fields[0] = num[1] + (num[1] < 100) * 1900 + (num[1] < 50) * 100;
+            fields[2] = num[0];
+        } else {
+            fields[1] = num[0];
+            fields[2] = num[1];
         }
         break;
-    case 4: /* EPSILON */
-        bf_set_ui(r, 1);
-        bf_mul_2exp(r, 1 - ctx->fp_env.prec,
-                    ctx->fp_env.prec, ctx->fp_env.flags);
+    case 3:
+        fields[0] = num[2] + (num[2] < 100) * 1900 + (num[2] < 50) * 100;
+        fields[1] = num[0];
+        fields[2] = num[1];
         break;
     default:
-        abort();
+        return FALSE;
     }
-    return val;
+    if (fields[1] < 1 || fields[2] < 1)
+        return FALSE;
+    fields[1] -= 1;
+    return TRUE;
 }
 
-static JSValue js_bigfloat_parseFloat(JSContext *ctx, JSValueConst this_val,
-                                      int argc, JSValueConst *argv)
+static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
 {
-    bf_t *a;
-    const char *str;
-    JSValue ret;
-    int radix;
-    JSFloatEnv *fe;
+    JSValue s, rv;
+    int fields[9];
+    double fields1[9];
+    double d;
+    int i, c;
+    JSString *sp;
+    uint8_t buf[128];
+    BOOL is_local;
 
-    str = JS_ToCString(ctx, argv[0]);
-    if (!str)
-        return JS_EXCEPTION;
-    if (JS_ToInt32(ctx, &radix, argv[1])) {
-    fail:
-        JS_FreeCString(ctx, str);
+    rv = JS_NAN;
+
+    s = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(s))
         return JS_EXCEPTION;
-    }
-    if (radix != 0 && (radix < 2 || radix > 36)) {
-        JS_ThrowRangeError(ctx, "radix must be between 2 and 36");
-        goto fail;
-    }
-    fe = &ctx->fp_env;
-    if (argc > 2) {
-        fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
-        if (!fe)
-            goto fail;
-    }
-    ret = JS_NewBigFloat(ctx);
-    if (JS_IsException(ret))
-        goto done;
-    a = JS_GetBigFloat(ret);
-    /* XXX: use js_atof() */
-    bf_atof(a, str, NULL, radix, fe->prec, fe->flags);
- done:
-    JS_FreeCString(ctx, str);
-    return ret;
-}
 
-static JSValue js_bigfloat_isFinite(JSContext *ctx, JSValueConst this_val,
-                                    int argc, JSValueConst *argv)
-{
-    JSValueConst val = argv[0];
-    JSBigFloat *p;
-    
-    if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
-        return JS_FALSE;
-    p = JS_VALUE_GET_PTR(val);
-    return JS_NewBool(ctx, bf_is_finite(&p->num));
+    sp = JS_VALUE_GET_STRING(s);
+    /* convert the string as a byte array */
+    for (i = 0; i < sp->len && i < (int)countof(buf) - 1; i++) {
+        c = string_get(sp, i);
+        if (c > 255)
+            c = (c == 0x2212) ? '-' : 'x';
+        buf[i] = c;
+    }
+    buf[i] = '\0';
+    if (js_date_parse_isostring(buf, fields, &is_local)
+    ||  js_date_parse_otherstring(buf, fields, &is_local)) {
+        static int const field_max[6] = { 0, 11, 31, 24, 59, 59 };
+        BOOL valid = TRUE;
+        /* check field maximum values */
+        for (i = 1; i < 6; i++) {
+            if (fields[i] > field_max[i])
+                valid = FALSE;
+        }
+        /* special case 24:00:00.000 */
+        if (fields[3] == 24 && (fields[4] | fields[5] | fields[6]))
+            valid = FALSE;
+        if (valid) {
+            for(i = 0; i < 7; i++)
+                fields1[i] = fields[i];
+            d = set_date_fields(fields1, is_local) - fields[8] * 60000;
+            rv = JS_NewFloat64(ctx, d);
+        }
+    }
+    JS_FreeValue(ctx, s);
+    return rv;
 }
 
-static JSValue js_bigfloat_isNaN(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
+static JSValue js_Date_now(JSContext *ctx, JSValueConst this_val,
+                           int argc, JSValueConst *argv)
 {
-    JSValueConst val = argv[0];
-    JSBigFloat *p;
-    
-    if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
-        return JS_FALSE;
-    p = JS_VALUE_GET_PTR(val);
-    return JS_NewBool(ctx, bf_is_nan(&p->num));
+    // now()
+    return JS_NewInt64(ctx, date_now());
 }
 
-enum {
-    MATH_OP_ABS,
-    MATH_OP_FLOOR,
-    MATH_OP_CEIL,
-    MATH_OP_ROUND,
-    MATH_OP_TRUNC,
-    MATH_OP_SQRT,
-    MATH_OP_FPROUND,
-    MATH_OP_ACOS,
-    MATH_OP_ASIN,
-    MATH_OP_ATAN,
-    MATH_OP_ATAN2,
-    MATH_OP_COS,
-    MATH_OP_EXP,
-    MATH_OP_LOG,
-    MATH_OP_POW,
-    MATH_OP_SIN,
-    MATH_OP_TAN,
-    MATH_OP_FMOD,
-    MATH_OP_REM,
-    MATH_OP_SIGN,
-
-    MATH_OP_ADD,
-    MATH_OP_SUB,
-    MATH_OP_MUL,
-    MATH_OP_DIV,
-};
-
-static JSValue js_bigfloat_fop(JSContext *ctx, JSValueConst this_val,
-                           int argc, JSValueConst *argv, int magic)
+static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValueConst this_val,
+                                          int argc, JSValueConst *argv)
 {
-    bf_t a_s, *a, *r;
-    JSFloatEnv *fe;
-    int rnd_mode;
-    JSValue op1, res;
-
-    op1 = JS_ToNumeric(ctx, argv[0]);
-    if (JS_IsException(op1))
-        return op1;
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a) {
-        JS_FreeValue(ctx, op1);
-        return JS_EXCEPTION;
-    }
-    fe = &ctx->fp_env;
-    if (argc > 1) {
-        fe = JS_GetOpaque2(ctx, argv[1], JS_CLASS_FLOAT_ENV);
-        if (!fe)
-            goto fail;
-    }
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res)) {
-    fail:
-        if (a == &a_s)
-            bf_delete(a);
-        JS_FreeValue(ctx, op1);
-        return JS_EXCEPTION;
-    }
-    r = JS_GetBigFloat(res);
-    switch (magic) {
-    case MATH_OP_ABS:
-        bf_set(r, a);
-        r->sign = 0;
-        break;
-    case MATH_OP_FLOOR:
-        rnd_mode = BF_RNDD;
-        goto rint;
-    case MATH_OP_CEIL:
-        rnd_mode = BF_RNDU;
-        goto rint;
-    case MATH_OP_ROUND:
-        rnd_mode = BF_RNDNA;
-        goto rint;
-    case MATH_OP_TRUNC:
-        rnd_mode = BF_RNDZ;
-    rint:
-        bf_set(r, a);
-        fe->status |= bf_rint(r, rnd_mode);
-        break;
-    case MATH_OP_SQRT:
-        fe->status |= bf_sqrt(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_FPROUND:
-        bf_set(r, a);
-        fe->status |= bf_round(r, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ACOS:
-        fe->status |= bf_acos(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ASIN:
-        fe->status |= bf_asin(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ATAN:
-        fe->status |= bf_atan(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_COS:
-        fe->status |= bf_cos(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_EXP:
-        fe->status |= bf_exp(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_LOG:
-        fe->status |= bf_log(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SIN:
-        fe->status |= bf_sin(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_TAN:
-        fe->status |= bf_tan(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SIGN:
-        if (bf_is_nan(a) || bf_is_zero(a)) {
-            bf_set(r, a);
-        } else {
-            bf_set_si(r, 1 - 2 * a->sign);
-        }
-        break;
-    default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    JS_FreeValue(ctx, op1);
-    return res;
-}
+    // Symbol_toPrimitive(hint)
+    JSValueConst obj = this_val;
+    JSAtom hint = JS_ATOM_NULL;
+    int hint_num;
 
-static JSValue js_bigfloat_fop2(JSContext *ctx, JSValueConst this_val,
-                            int argc, JSValueConst *argv, int magic)
-{
-    bf_t a_s, *a, b_s, *b, r_s, *r = &r_s;
-    JSFloatEnv *fe;
-    JSValue op1, op2, res;
+    if (!JS_IsObject(obj))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
 
-    op1 = JS_ToNumeric(ctx, argv[0]);
-    if (JS_IsException(op1))
-        return op1;
-    op2 = JS_ToNumeric(ctx, argv[1]);
-    if (JS_IsException(op2)) {
-        JS_FreeValue(ctx, op1);
-        return op2;
-    }
-    a = JS_ToBigFloat(ctx, &a_s, op1);
-    if (!a)
-        goto fail1;
-    b = JS_ToBigFloat(ctx, &b_s, op2);
-    if (!b)
-        goto fail2;
-    fe = &ctx->fp_env;
-    if (argc > 2) {
-        fe = JS_GetOpaque2(ctx, argv[2], JS_CLASS_FLOAT_ENV);
-        if (!fe)
-            goto fail;
-    }
-    res = JS_NewBigFloat(ctx);
-    if (JS_IsException(res)) {
-    fail:
-        if (b == &b_s)
-            bf_delete(b);
-    fail2:
-        if (a == &a_s)
-            bf_delete(a);
-    fail1:
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        return JS_EXCEPTION;
+    if (JS_IsString(argv[0])) {
+        hint = JS_ValueToAtom(ctx, argv[0]);
+        if (hint == JS_ATOM_NULL)
+            return JS_EXCEPTION;
+        JS_FreeAtom(ctx, hint);
     }
-    r = JS_GetBigFloat(res);
-    switch (magic) {
-    case MATH_OP_ATAN2:
-        fe->status |= bf_atan2(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_POW:
-        fe->status |= bf_pow(r, a, b, fe->prec, fe->flags | BF_POW_JS_QUIRKS);
-        break;
-    case MATH_OP_FMOD:
-        fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
-        break;
-    case MATH_OP_REM:
-        fe->status |= bf_rem(r, a, b, fe->prec, fe->flags, BF_RNDN);
-        break;
-    case MATH_OP_ADD:
-        fe->status |= bf_add(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SUB:
-        fe->status |= bf_sub(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_MUL:
-        fe->status |= bf_mul(r, a, b, fe->prec, fe->flags);
+    switch (hint) {
+    case JS_ATOM_number:
+    case JS_ATOM_integer:
+        hint_num = HINT_NUMBER;
         break;
-    case MATH_OP_DIV:
-        fe->status |= bf_div(r, a, b, fe->prec, fe->flags);
+    case JS_ATOM_string:
+    case JS_ATOM_default:
+        hint_num = HINT_STRING;
         break;
     default:
-        abort();
-    }
-    if (a == &a_s)
-        bf_delete(a);
-    if (b == &b_s)
-        bf_delete(b);
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    return res;
+        return JS_ThrowTypeError(ctx, "invalid hint");
+    }
+    return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
 }
 
-static const JSCFunctionListEntry js_bigfloat_funcs[] = {
-    JS_CGETSET_MAGIC_DEF("PI", js_bigfloat_get_const, NULL, 0 ),
-    JS_CGETSET_MAGIC_DEF("LN2", js_bigfloat_get_const, NULL, 1 ),
-    JS_CGETSET_MAGIC_DEF("MIN_VALUE", js_bigfloat_get_const, NULL, 2 ),
-    JS_CGETSET_MAGIC_DEF("MAX_VALUE", js_bigfloat_get_const, NULL, 3 ),
-    JS_CGETSET_MAGIC_DEF("EPSILON", js_bigfloat_get_const, NULL, 4 ),
-    JS_CFUNC_DEF("parseFloat", 1, js_bigfloat_parseFloat ),
-    JS_CFUNC_DEF("isFinite", 1, js_bigfloat_isFinite ),
-    JS_CFUNC_DEF("isNaN", 1, js_bigfloat_isNaN ),
-    JS_CFUNC_MAGIC_DEF("abs", 1, js_bigfloat_fop, MATH_OP_ABS ),
-    JS_CFUNC_MAGIC_DEF("fpRound", 1, js_bigfloat_fop, MATH_OP_FPROUND ),
-    JS_CFUNC_MAGIC_DEF("floor", 1, js_bigfloat_fop, MATH_OP_FLOOR ),
-    JS_CFUNC_MAGIC_DEF("ceil", 1, js_bigfloat_fop, MATH_OP_CEIL ),
-    JS_CFUNC_MAGIC_DEF("round", 1, js_bigfloat_fop, MATH_OP_ROUND ),
-    JS_CFUNC_MAGIC_DEF("trunc", 1, js_bigfloat_fop, MATH_OP_TRUNC ),
-    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigfloat_fop, MATH_OP_SQRT ),
-    JS_CFUNC_MAGIC_DEF("acos", 1, js_bigfloat_fop, MATH_OP_ACOS ),
-    JS_CFUNC_MAGIC_DEF("asin", 1, js_bigfloat_fop, MATH_OP_ASIN ),
-    JS_CFUNC_MAGIC_DEF("atan", 1, js_bigfloat_fop, MATH_OP_ATAN ),
-    JS_CFUNC_MAGIC_DEF("atan2", 2, js_bigfloat_fop2, MATH_OP_ATAN2 ),
-    JS_CFUNC_MAGIC_DEF("cos", 1, js_bigfloat_fop, MATH_OP_COS ),
-    JS_CFUNC_MAGIC_DEF("exp", 1, js_bigfloat_fop, MATH_OP_EXP ),
-    JS_CFUNC_MAGIC_DEF("log", 1, js_bigfloat_fop, MATH_OP_LOG ),
-    JS_CFUNC_MAGIC_DEF("pow", 2, js_bigfloat_fop2, MATH_OP_POW ),
-    JS_CFUNC_MAGIC_DEF("sin", 1, js_bigfloat_fop, MATH_OP_SIN ),
-    JS_CFUNC_MAGIC_DEF("tan", 1, js_bigfloat_fop, MATH_OP_TAN ),
-    JS_CFUNC_MAGIC_DEF("sign", 1, js_bigfloat_fop, MATH_OP_SIGN ),
-    JS_CFUNC_MAGIC_DEF("add", 2, js_bigfloat_fop2, MATH_OP_ADD ),
-    JS_CFUNC_MAGIC_DEF("sub", 2, js_bigfloat_fop2, MATH_OP_SUB ),
-    JS_CFUNC_MAGIC_DEF("mul", 2, js_bigfloat_fop2, MATH_OP_MUL ),
-    JS_CFUNC_MAGIC_DEF("div", 2, js_bigfloat_fop2, MATH_OP_DIV ),
-    JS_CFUNC_MAGIC_DEF("fmod", 2, js_bigfloat_fop2, MATH_OP_FMOD ),
-    JS_CFUNC_MAGIC_DEF("remainder", 2, js_bigfloat_fop2, MATH_OP_REM ),
-};
-
-/* FloatEnv */
-
-static JSValue js_float_env_constructor(JSContext *ctx,
-                                        JSValueConst new_target,
-                                        int argc, JSValueConst *argv)
+static JSValue js_date_getTimezoneOffset(JSContext *ctx, JSValueConst this_val,
+                                         int argc, JSValueConst *argv)
 {
-    JSValue obj;
-    JSFloatEnv *fe;
-    int64_t prec;
-    int flags, rndmode;
-
-    prec = ctx->fp_env.prec;
-    flags = ctx->fp_env.flags;
-    if (!JS_IsUndefined(argv[0])) {
-        if (JS_ToInt64Sat(ctx, &prec, argv[0]))
-            return JS_EXCEPTION;
-        if (prec < BF_PREC_MIN || prec > BF_PREC_MAX)
-            return JS_ThrowRangeError(ctx, "invalid precision");
-        flags = BF_RNDN; /* RNDN, max exponent size, no subnormal */
-        if (argc > 1 && !JS_IsUndefined(argv[1])) {
-            if (JS_ToInt32Sat(ctx, &rndmode, argv[1]))
-                return JS_EXCEPTION;
-            if (rndmode < BF_RNDN || rndmode > BF_RNDF)
-                return JS_ThrowRangeError(ctx, "invalid rounding mode");
-            flags = rndmode;
-        }
-    }
+    // getTimezoneOffset()
+    double v;
 
-    obj = JS_NewObjectClass(ctx, JS_CLASS_FLOAT_ENV);
-    if (JS_IsException(obj))
-        return JS_EXCEPTION;
-    fe = js_malloc(ctx, sizeof(*fe));
-    if (!fe)
+    if (JS_ThisTimeValue(ctx, &v, this_val))
         return JS_EXCEPTION;
-    fe->prec = prec;
-    fe->flags = flags;
-    fe->status = 0;
-    JS_SetOpaque(obj, fe);
-    return obj;
+    if (isnan(v))
+        return JS_NAN;
+    else
+        /* assuming -8.64e15 <= v <= -8.64e15 */
+        return JS_NewInt64(ctx, getTimezoneOffset((int64_t)trunc(v)));
 }
 
-static void js_float_env_finalizer(JSRuntime *rt, JSValue val)
+static JSValue js_date_getTime(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
 {
-    JSFloatEnv *fe = JS_GetOpaque(val, JS_CLASS_FLOAT_ENV);
-    js_free_rt(rt, fe);
-}
+    // getTime()
+    double v;
 
-static JSValue js_float_env_get_prec(JSContext *ctx, JSValueConst this_val)
-{
-    return JS_NewInt64(ctx, ctx->fp_env.prec);
+    if (JS_ThisTimeValue(ctx, &v, this_val))
+        return JS_EXCEPTION;
+    return JS_NewFloat64(ctx, v);
 }
 
-static JSValue js_float_env_get_expBits(JSContext *ctx, JSValueConst this_val)
+static JSValue js_date_setTime(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
 {
-    return JS_NewInt32(ctx, bf_get_exp_bits(ctx->fp_env.flags));
+    // setTime(v)
+    double v;
+
+    if (JS_ThisTimeValue(ctx, &v, this_val) || JS_ToFloat64(ctx, &v, argv[0]))
+        return JS_EXCEPTION;
+    return JS_SetThisTimeValue(ctx, this_val, time_clip(v));
 }
 
-static JSValue js_float_env_setPrec(JSContext *ctx,
-                                    JSValueConst this_val,
-                                    int argc, JSValueConst *argv)
+static JSValue js_date_setYear(JSContext *ctx, JSValueConst this_val,
+                               int argc, JSValueConst *argv)
 {
-    JSValueConst func;
-    int exp_bits, flags, saved_flags;
-    JSValue ret;
-    limb_t saved_prec;
-    int64_t prec;
+    // setYear(y)
+    double y;
+    JSValueConst args[1];
 
-    func = argv[0];
-    if (JS_ToInt64Sat(ctx, &prec, argv[1]))
+    if (JS_ThisTimeValue(ctx, &y, this_val) || JS_ToFloat64(ctx, &y, argv[0]))
         return JS_EXCEPTION;
-    if (prec < BF_PREC_MIN || prec > BF_PREC_MAX)
-        return JS_ThrowRangeError(ctx, "invalid precision");
-    exp_bits = BF_EXP_BITS_MAX;
-
-    if (argc > 2 && !JS_IsUndefined(argv[2])) {
-        if (JS_ToInt32Sat(ctx, &exp_bits, argv[2]))
-            return JS_EXCEPTION;
-        if (exp_bits < BF_EXP_BITS_MIN || exp_bits > BF_EXP_BITS_MAX)
-            return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
+    y = +y;
+    if (isfinite(y)) {
+        y = trunc(y);
+        if (y >= 0 && y < 100)
+            y += 1900;
     }
+    args[0] = JS_NewFloat64(ctx, y);
+    return set_date_field(ctx, this_val, 1, args, 0x011);
+}
 
-    flags = BF_RNDN | BF_FLAG_SUBNORMAL | bf_set_exp_bits(exp_bits);
-
-    saved_prec = ctx->fp_env.prec;
-    saved_flags = ctx->fp_env.flags;
+static JSValue js_date_toJSON(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    // toJSON(key)
+    JSValue obj, tv, method, rv;
+    double d;
 
-    ctx->fp_env.prec = prec;
-    ctx->fp_env.flags = flags;
+    rv = JS_EXCEPTION;
+    tv = JS_UNDEFINED;
 
-    ret = JS_Call(ctx, func, JS_UNDEFINED, 0, NULL);
-    /* always restore the floating point precision */
-    ctx->fp_env.prec = saved_prec;
-    ctx->fp_env.flags = saved_flags;
-    return ret;
+    obj = JS_ToObject(ctx, this_val);
+    tv = JS_ToPrimitive(ctx, obj, HINT_NUMBER);
+    if (JS_IsException(tv))
+        goto exception;
+    if (JS_IsNumber(tv)) {
+        if (JS_ToFloat64(ctx, &d, tv) < 0)
+            goto exception;
+        if (!isfinite(d)) {
+            rv = JS_NULL;
+            goto done;
+        }
+    }
+    method = JS_GetPropertyStr(ctx, obj, "toISOString");
+    if (JS_IsException(method))
+        goto exception;
+    if (!JS_IsFunction(ctx, method)) {
+        JS_ThrowTypeError(ctx, "object needs toISOString method");
+        JS_FreeValue(ctx, method);
+        goto exception;
+    }
+    rv = JS_CallFree(ctx, method, obj, 0, NULL);
+exception:
+done:
+    JS_FreeValue(ctx, obj);
+    JS_FreeValue(ctx, tv);
+    return rv;
 }
 
-#define FE_PREC      (-1)
-#define FE_EXP       (-2)
-#define FE_RNDMODE   (-3)
-#define FE_SUBNORMAL (-4)
+static const JSCFunctionListEntry js_date_funcs[] = {
+    JS_CFUNC_DEF("now", 0, js_Date_now ),
+    JS_CFUNC_DEF("parse", 1, js_Date_parse ),
+    JS_CFUNC_DEF("UTC", 7, js_Date_UTC ),
+};
+
+static const JSCFunctionListEntry js_date_proto_funcs[] = {
+    JS_CFUNC_DEF("valueOf", 0, js_date_getTime ),
+    JS_CFUNC_MAGIC_DEF("toString", 0, get_date_string, 0x13 ),
+    JS_CFUNC_DEF("[Symbol.toPrimitive]", 1, js_date_Symbol_toPrimitive ),
+    JS_CFUNC_MAGIC_DEF("toUTCString", 0, get_date_string, 0x03 ),
+    JS_ALIAS_DEF("toGMTString", "toUTCString" ),
+    JS_CFUNC_MAGIC_DEF("toISOString", 0, get_date_string, 0x23 ),
+    JS_CFUNC_MAGIC_DEF("toDateString", 0, get_date_string, 0x11 ),
+    JS_CFUNC_MAGIC_DEF("toTimeString", 0, get_date_string, 0x12 ),
+    JS_CFUNC_MAGIC_DEF("toLocaleString", 0, get_date_string, 0x33 ),
+    JS_CFUNC_MAGIC_DEF("toLocaleDateString", 0, get_date_string, 0x31 ),
+    JS_CFUNC_MAGIC_DEF("toLocaleTimeString", 0, get_date_string, 0x32 ),
+    JS_CFUNC_DEF("getTimezoneOffset", 0, js_date_getTimezoneOffset ),
+    JS_CFUNC_DEF("getTime", 0, js_date_getTime ),
+    JS_CFUNC_MAGIC_DEF("getYear", 0, get_date_field, 0x101 ),
+    JS_CFUNC_MAGIC_DEF("getFullYear", 0, get_date_field, 0x01 ),
+    JS_CFUNC_MAGIC_DEF("getUTCFullYear", 0, get_date_field, 0x00 ),
+    JS_CFUNC_MAGIC_DEF("getMonth", 0, get_date_field, 0x11 ),
+    JS_CFUNC_MAGIC_DEF("getUTCMonth", 0, get_date_field, 0x10 ),
+    JS_CFUNC_MAGIC_DEF("getDate", 0, get_date_field, 0x21 ),
+    JS_CFUNC_MAGIC_DEF("getUTCDate", 0, get_date_field, 0x20 ),
+    JS_CFUNC_MAGIC_DEF("getHours", 0, get_date_field, 0x31 ),
+    JS_CFUNC_MAGIC_DEF("getUTCHours", 0, get_date_field, 0x30 ),
+    JS_CFUNC_MAGIC_DEF("getMinutes", 0, get_date_field, 0x41 ),
+    JS_CFUNC_MAGIC_DEF("getUTCMinutes", 0, get_date_field, 0x40 ),
+    JS_CFUNC_MAGIC_DEF("getSeconds", 0, get_date_field, 0x51 ),
+    JS_CFUNC_MAGIC_DEF("getUTCSeconds", 0, get_date_field, 0x50 ),
+    JS_CFUNC_MAGIC_DEF("getMilliseconds", 0, get_date_field, 0x61 ),
+    JS_CFUNC_MAGIC_DEF("getUTCMilliseconds", 0, get_date_field, 0x60 ),
+    JS_CFUNC_MAGIC_DEF("getDay", 0, get_date_field, 0x71 ),
+    JS_CFUNC_MAGIC_DEF("getUTCDay", 0, get_date_field, 0x70 ),
+    JS_CFUNC_DEF("setTime", 1, js_date_setTime ),
+    JS_CFUNC_MAGIC_DEF("setMilliseconds", 1, set_date_field, 0x671 ),
+    JS_CFUNC_MAGIC_DEF("setUTCMilliseconds", 1, set_date_field, 0x670 ),
+    JS_CFUNC_MAGIC_DEF("setSeconds", 2, set_date_field, 0x571 ),
+    JS_CFUNC_MAGIC_DEF("setUTCSeconds", 2, set_date_field, 0x570 ),
+    JS_CFUNC_MAGIC_DEF("setMinutes", 3, set_date_field, 0x471 ),
+    JS_CFUNC_MAGIC_DEF("setUTCMinutes", 3, set_date_field, 0x470 ),
+    JS_CFUNC_MAGIC_DEF("setHours", 4, set_date_field, 0x371 ),
+    JS_CFUNC_MAGIC_DEF("setUTCHours", 4, set_date_field, 0x370 ),
+    JS_CFUNC_MAGIC_DEF("setDate", 1, set_date_field, 0x231 ),
+    JS_CFUNC_MAGIC_DEF("setUTCDate", 1, set_date_field, 0x230 ),
+    JS_CFUNC_MAGIC_DEF("setMonth", 2, set_date_field, 0x131 ),
+    JS_CFUNC_MAGIC_DEF("setUTCMonth", 2, set_date_field, 0x130 ),
+    JS_CFUNC_DEF("setYear", 1, js_date_setYear ),
+    JS_CFUNC_MAGIC_DEF("setFullYear", 3, set_date_field, 0x031 ),
+    JS_CFUNC_MAGIC_DEF("setUTCFullYear", 3, set_date_field, 0x030 ),
+    JS_CFUNC_DEF("toJSON", 1, js_date_toJSON ),
+};
 
-static JSValue js_float_env_proto_get_status(JSContext *ctx, JSValueConst this_val, int magic)
+JSValue JS_NewDate(JSContext *ctx, double epoch_ms)
 {
-    JSFloatEnv *fe;
-    fe = JS_GetOpaque2(ctx, this_val, JS_CLASS_FLOAT_ENV);
-    if (!fe)
+    JSValue obj = js_create_from_ctor(ctx, JS_UNDEFINED, JS_CLASS_DATE);
+    if (JS_IsException(obj))
         return JS_EXCEPTION;
-    switch(magic) {
-    case FE_PREC:
-        return JS_NewInt64(ctx, fe->prec);
-    case FE_EXP:
-        return JS_NewInt32(ctx, bf_get_exp_bits(fe->flags));
-    case FE_RNDMODE:
-        return JS_NewInt32(ctx, fe->flags & BF_RND_MASK);
-    case FE_SUBNORMAL:
-        return JS_NewBool(ctx, (fe->flags & BF_FLAG_SUBNORMAL) != 0);
-    default:
-        return JS_NewBool(ctx, (fe->status & magic) != 0);
-    }
+    JS_SetObjectData(ctx, obj, __JS_NewFloat64(ctx, time_clip(epoch_ms)));
+    return obj;
 }
 
-static JSValue js_float_env_proto_set_status(JSContext *ctx, JSValueConst this_val, JSValueConst val, int magic)
+void JS_AddIntrinsicDate(JSContext *ctx)
 {
-    JSFloatEnv *fe;
-    int b;
-    int64_t prec;
+    JSValueConst obj;
 
-    fe = JS_GetOpaque2(ctx, this_val, JS_CLASS_FLOAT_ENV);
-    if (!fe)
-        return JS_EXCEPTION;
-    switch(magic) {
-    case FE_PREC:
-        if (JS_ToInt64Sat(ctx, &prec, val))
-            return JS_EXCEPTION;
-        if (prec < BF_PREC_MIN || prec > BF_PREC_MAX)
-            return JS_ThrowRangeError(ctx, "invalid precision");
-        fe->prec = prec;
-        break;
-    case FE_EXP:
-        if (JS_ToInt32Sat(ctx, &b, val))
-            return JS_EXCEPTION;
-        if (b < BF_EXP_BITS_MIN || b > BF_EXP_BITS_MAX)
-            return JS_ThrowRangeError(ctx, "invalid number of exponent bits");
-        fe->flags = (fe->flags & ~(BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)) |
-            bf_set_exp_bits(b);
-        break;
-    case FE_RNDMODE:
-        b = bigfloat_get_rnd_mode(ctx, val);
-        if (b < 0)
-            return JS_EXCEPTION;
-        fe->flags = (fe->flags & ~BF_RND_MASK) | b;
-        break;
-    case FE_SUBNORMAL:
-        b = JS_ToBool(ctx, val);
-        fe->flags = (fe->flags & ~BF_FLAG_SUBNORMAL) | (b ? BF_FLAG_SUBNORMAL: 0);
-        break;
-    default:
-        b = JS_ToBool(ctx, val);
-        fe->status = (fe->status & ~magic) & ((-b) & magic);
-        break;
-    }
-    return JS_UNDEFINED;
+    /* Date */
+    ctx->class_proto[JS_CLASS_DATE] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_DATE], js_date_proto_funcs,
+                               countof(js_date_proto_funcs));
+    obj = JS_NewGlobalCConstructor(ctx, "Date", js_date_constructor, 7,
+                                   ctx->class_proto[JS_CLASS_DATE]);
+    JS_SetPropertyFunctionList(ctx, obj, js_date_funcs, countof(js_date_funcs));
 }
 
-static JSValue js_float_env_clearStatus(JSContext *ctx,
-                                        JSValueConst this_val,
-                                        int argc, JSValueConst *argv)
+/* eval */
+
+void JS_AddIntrinsicEval(JSContext *ctx)
 {
-    JSFloatEnv *fe = JS_GetOpaque2(ctx, this_val, JS_CLASS_FLOAT_ENV);
-    if (!fe)
-        return JS_EXCEPTION;
-    fe->status = 0;
-    return JS_UNDEFINED;
+    ctx->eval_internal = __JS_EvalInternal;
 }
 
-static const JSCFunctionListEntry js_float_env_funcs[] = {
-    JS_CGETSET_DEF("prec", js_float_env_get_prec, NULL ),
-    JS_CGETSET_DEF("expBits", js_float_env_get_expBits, NULL ),
-    JS_CFUNC_DEF("setPrec", 2, js_float_env_setPrec ),
-    JS_PROP_INT32_DEF("RNDN", BF_RNDN, 0 ),
-    JS_PROP_INT32_DEF("RNDZ", BF_RNDZ, 0 ),
-    JS_PROP_INT32_DEF("RNDU", BF_RNDU, 0 ),
-    JS_PROP_INT32_DEF("RNDD", BF_RNDD, 0 ),
-    JS_PROP_INT32_DEF("RNDNA", BF_RNDNA, 0 ),
-    JS_PROP_INT32_DEF("RNDA", BF_RNDA, 0 ),
-    JS_PROP_INT32_DEF("RNDF", BF_RNDF, 0 ),
-    JS_PROP_INT32_DEF("precMin", BF_PREC_MIN, 0 ),
-    JS_PROP_INT64_DEF("precMax", BF_PREC_MAX, 0 ),
-    JS_PROP_INT32_DEF("expBitsMin", BF_EXP_BITS_MIN, 0 ),
-    JS_PROP_INT32_DEF("expBitsMax", BF_EXP_BITS_MAX, 0 ),
-};
-
-static const JSCFunctionListEntry js_float_env_proto_funcs[] = {
-    JS_CGETSET_MAGIC_DEF("prec", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, FE_PREC ),
-    JS_CGETSET_MAGIC_DEF("expBits", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, FE_EXP ),
-    JS_CGETSET_MAGIC_DEF("rndMode", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, FE_RNDMODE ),
-    JS_CGETSET_MAGIC_DEF("subnormal", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, FE_SUBNORMAL ),
-    JS_CGETSET_MAGIC_DEF("invalidOperation", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, BF_ST_INVALID_OP ),
-    JS_CGETSET_MAGIC_DEF("divideByZero", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, BF_ST_DIVIDE_ZERO ),
-    JS_CGETSET_MAGIC_DEF("overflow", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, BF_ST_OVERFLOW ),
-    JS_CGETSET_MAGIC_DEF("underflow", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, BF_ST_UNDERFLOW ),
-    JS_CGETSET_MAGIC_DEF("inexact", js_float_env_proto_get_status,
-                         js_float_env_proto_set_status, BF_ST_INEXACT ),
-    JS_CFUNC_DEF("clearStatus", 0, js_float_env_clearStatus ),
-};
+/* BigInt */
 
-void JS_AddIntrinsicBigFloat(JSContext *ctx)
-{
-    JSRuntime *rt = ctx->rt;
-    JSValueConst obj1;
-    
-    rt->bigfloat_ops.to_string = js_bigfloat_to_string;
-    rt->bigfloat_ops.from_string = js_string_to_bigfloat;
-    rt->bigfloat_ops.unary_arith = js_unary_arith_bigfloat;
-    rt->bigfloat_ops.binary_arith = js_binary_arith_bigfloat;
-    rt->bigfloat_ops.compare = js_compare_bigfloat;
-    rt->bigfloat_ops.mul_pow10_to_float64 = js_mul_pow10_to_float64;
-    rt->bigfloat_ops.mul_pow10 = js_mul_pow10;
-    
-    ctx->class_proto[JS_CLASS_BIG_FLOAT] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT],
-                               js_bigfloat_proto_funcs,
-                               countof(js_bigfloat_proto_funcs));
-    obj1 = JS_NewGlobalCConstructor(ctx, "BigFloat", js_bigfloat_constructor, 1,
-                                    ctx->class_proto[JS_CLASS_BIG_FLOAT]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_bigfloat_funcs,
-                               countof(js_bigfloat_funcs));
-
-    ctx->class_proto[JS_CLASS_FLOAT_ENV] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FLOAT_ENV],
-                               js_float_env_proto_funcs,
-                               countof(js_float_env_proto_funcs));
-    obj1 = JS_NewGlobalCConstructorOnly(ctx, "BigFloatEnv",
-                                        js_float_env_constructor, 1,
-                                        ctx->class_proto[JS_CLASS_FLOAT_ENV]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_float_env_funcs,
-                               countof(js_float_env_funcs));
-}
-
-/* BigDecimal */
-
-static JSValue JS_ToBigDecimalFree(JSContext *ctx, JSValue val,
-                                   BOOL allow_null_or_undefined)
+static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
 {
+    uint32_t tag;
+
  redo:
-    switch(JS_VALUE_GET_NORM_TAG(val)) {
-    case JS_TAG_BIG_DECIMAL:
-        break;
-    case JS_TAG_NULL:
-        if (!allow_null_or_undefined)
-            goto fail;
-        /* fall thru */
-    case JS_TAG_BOOL:
+    tag = JS_VALUE_GET_NORM_TAG(val);
+    switch(tag) {
     case JS_TAG_INT:
-        {
-            bfdec_t *r;
-            int32_t v = JS_VALUE_GET_INT(val);
-
-            val = JS_NewBigDecimal(ctx);
-            if (JS_IsException(val))
-                break;
-            r = JS_GetBigDecimal(val);
-            if (bfdec_set_si(r, v)) {
-                JS_FreeValue(ctx, val);
-                val = JS_EXCEPTION;
-                break;
-            }
-        }
+    case JS_TAG_BOOL:
+        val = JS_NewBigInt64(ctx, JS_VALUE_GET_INT(val));
         break;
-    case JS_TAG_FLOAT64:
+    case JS_TAG_SHORT_BIG_INT:
     case JS_TAG_BIG_INT:
-    case JS_TAG_BIG_FLOAT:
-        val = JS_ToStringFree(ctx, val);
-        if (JS_IsException(val))
-            break;
-        goto redo;
-    case JS_TAG_STRING:
+        break;
+    case JS_TAG_FLOAT64:
         {
-            const char *str, *p;
-            size_t len;
-            int err;
-
-            str = JS_ToCStringLen(ctx, &len, val);
-            JS_FreeValue(ctx, val);
-            if (!str)
-                return JS_EXCEPTION;
-            p = str;
-            p += skip_spaces(p);
-            if ((p - str) == len) {
-                bfdec_t *r;
-                val = JS_NewBigDecimal(ctx);
-                if (JS_IsException(val))
-                    break;
-                r = JS_GetBigDecimal(val);
-                bfdec_set_zero(r, 0);
-                err = 0;
+            double d = JS_VALUE_GET_FLOAT64(val);
+            JSBigInt *r;
+            int res;
+            r = js_bigint_from_float64(ctx, &res, d);
+            if (!r) {
+                if (res == 0) {
+                    val = JS_EXCEPTION;
+                } else if (res == 1) {
+                    val = JS_ThrowRangeError(ctx, "cannot convert to BigInt: not an integer");
+                } else {
+                    val = JS_ThrowRangeError(ctx, "cannot convert NaN or Infinity to BigInt");                }
             } else {
-                val = js_atof(ctx, p, &p, 0, ATOD_TYPE_BIG_DECIMAL);
-                if (JS_IsException(val)) {
-                    JS_FreeCString(ctx, str);
-                    return JS_EXCEPTION;
-                }
-                p += skip_spaces(p);
-                err = ((p - str) != len);
-            }
-            JS_FreeCString(ctx, str);
-            if (err) {
-                JS_FreeValue(ctx, val);
-                return JS_ThrowSyntaxError(ctx, "invalid bigdecimal literal");
+                val = JS_CompactBigInt(ctx, r);
             }
         }
         break;
+    case JS_TAG_STRING:
+    case JS_TAG_STRING_ROPE:
+        val = JS_StringToBigIntErr(ctx, val);
+        break;
     case JS_TAG_OBJECT:
         val = JS_ToPrimitiveFree(ctx, val, HINT_NUMBER);
         if (JS_IsException(val))
             break;
         goto redo;
+    case JS_TAG_NULL:
     case JS_TAG_UNDEFINED:
-        {
-            bfdec_t *r;
-            if (!allow_null_or_undefined)
-                goto fail;
-            val = JS_NewBigDecimal(ctx);
-            if (JS_IsException(val))
-                break;
-            r = JS_GetBigDecimal(val);
-            bfdec_set_nan(r);
-        }
-        break;
     default:
-    fail:
         JS_FreeValue(ctx, val);
-        return JS_ThrowTypeError(ctx, "cannot convert to bigdecimal");
+        return JS_ThrowTypeError(ctx, "cannot convert to BigInt");
     }
     return val;
 }
 
-static JSValue js_bigdecimal_constructor(JSContext *ctx,
-                                         JSValueConst new_target,
-                                         int argc, JSValueConst *argv)
+static JSValue js_bigint_constructor(JSContext *ctx,
+                                     JSValueConst new_target,
+                                     int argc, JSValueConst *argv)
 {
-    JSValue val;
     if (!JS_IsUndefined(new_target))
         return JS_ThrowTypeError(ctx, "not a constructor");
-    if (argc == 0) {
-        bfdec_t *r;
-        val = JS_NewBigDecimal(ctx);
-        if (JS_IsException(val))
-            return val;
-        r = JS_GetBigDecimal(val);
-        bfdec_set_zero(r, 0);
-    } else {
-        val = JS_ToBigDecimalFree(ctx, JS_DupValue(ctx, argv[0]), FALSE);
-    }
-    return val;
+    return JS_ToBigIntCtorFree(ctx, JS_DupValue(ctx, argv[0]));
 }
 
-static JSValue js_thisBigDecimalValue(JSContext *ctx, JSValueConst this_val)
+static JSValue js_thisBigIntValue(JSContext *ctx, JSValueConst this_val)
 {
-    if (JS_IsBigDecimal(this_val))
+    if (JS_IsBigInt(ctx, this_val))
         return JS_DupValue(ctx, this_val);
 
     if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
         JSObject *p = JS_VALUE_GET_OBJ(this_val);
-        if (p->class_id == JS_CLASS_BIG_DECIMAL) {
-            if (JS_IsBigDecimal(p->u.object_data))
+        if (p->class_id == JS_CLASS_BIG_INT) {
+            if (JS_IsBigInt(ctx, p->u.object_data))
                 return JS_DupValue(ctx, p->u.object_data);
         }
     }
-    return JS_ThrowTypeError(ctx, "not a bigdecimal");
+    return JS_ThrowTypeError(ctx, "not a BigInt");
 }
 
-static JSValue js_bigdecimal_toString(JSContext *ctx, JSValueConst this_val,
-                                      int argc, JSValueConst *argv)
+static JSValue js_bigint_toString(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv)
 {
     JSValue val;
+    int base;
+    JSValue ret;
 
-    val = js_thisBigDecimalValue(ctx, this_val);
+    val = js_thisBigIntValue(ctx, this_val);
     if (JS_IsException(val))
         return val;
-    return JS_ToStringFree(ctx, val);
-}
-
-static JSValue js_bigdecimal_valueOf(JSContext *ctx, JSValueConst this_val,
-                                   int argc, JSValueConst *argv)
-{
-    return js_thisBigDecimalValue(ctx, this_val);
-}
-
-static int js_bigdecimal_get_rnd_mode(JSContext *ctx, JSValueConst obj)
-{
-    const char *str;
-    size_t size;
-    int rnd_mode;
-    
-    str = JS_ToCStringLen(ctx, &size, obj);
-    if (!str)
-        return -1;
-    if (strlen(str) != size)
-        goto invalid_rounding_mode;
-    if (!strcmp(str, "floor")) {
-        rnd_mode = BF_RNDD;
-    } else if (!strcmp(str, "ceiling")) {
-        rnd_mode = BF_RNDU;
-    } else if (!strcmp(str, "down")) {
-        rnd_mode = BF_RNDZ;
-    } else if (!strcmp(str, "up")) {
-        rnd_mode = BF_RNDA;
-    } else if (!strcmp(str, "half-even")) {
-        rnd_mode = BF_RNDN;
-    } else if (!strcmp(str, "half-up")) {
-        rnd_mode = BF_RNDNA;
-    } else {
-    invalid_rounding_mode:
-        JS_FreeCString(ctx, str);
-        JS_ThrowTypeError(ctx, "invalid rounding mode");
-        return -1;
-    }
-    JS_FreeCString(ctx, str);
-    return rnd_mode;
-}
-
-typedef struct {
-    int64_t prec;
-    bf_flags_t flags;
-} BigDecimalEnv;
-
-static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
-                                 JSValueConst obj)
-{
-    JSValue prop;
-    int64_t val;
-    BOOL has_prec;
-    int rnd_mode;
-    
-    if (!JS_IsObject(obj)) {
-        JS_ThrowTypeErrorNotAnObject(ctx);
-        return -1;
-    }
-    prop = JS_GetProperty(ctx, obj, JS_ATOM_roundingMode);
-    if (JS_IsException(prop))
-        return -1;
-    rnd_mode = js_bigdecimal_get_rnd_mode(ctx, prop);
-    JS_FreeValue(ctx, prop);
-    if (rnd_mode < 0)
-        return -1;
-    fe->flags = rnd_mode;
-    
-    prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
-    if (JS_IsException(prop))
-        return -1;
-    has_prec = FALSE;
-    if (!JS_IsUndefined(prop)) {
-        if (JS_ToInt64SatFree(ctx, &val, prop))
-            return -1;
-        if (val < 1 || val > BF_PREC_MAX)
-            goto invalid_precision;
-        fe->prec = val;
-        has_prec = TRUE;
-    }
-
-    prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumFractionDigits);
-    if (JS_IsException(prop))
-        return -1;
-    if (!JS_IsUndefined(prop)) {
-        if (has_prec) {
-            JS_FreeValue(ctx, prop);
-            JS_ThrowTypeError(ctx, "cannot provide both maximumSignificantDigits and maximumFractionDigits");
-            return -1;
-        }
-        if (JS_ToInt64SatFree(ctx, &val, prop))
-            return -1;
-        if (val < 0 || val > BF_PREC_MAX) {
-        invalid_precision:
-            JS_ThrowTypeError(ctx, "invalid precision");
-            return -1;
-        }
-        fe->prec = val;
-        fe->flags |= BF_FLAG_RADPNT_PREC;
-        has_prec = TRUE;
-    }
-    if (!has_prec) {
-        JS_ThrowTypeError(ctx, "precision must be present");
-        return -1;
-    }
-    return 0;
-}
-
-
-static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv, int magic)
-{
-    bfdec_t *a, *b, r_s, *r = &r_s;
-    JSValue op1, op2, res;
-    BigDecimalEnv fe_s, *fe = &fe_s;
-    int op_count, ret;
-
-    if (magic == MATH_OP_SQRT ||
-        magic == MATH_OP_ROUND)
-        op_count = 1;
-    else
-        op_count = 2;
-    
-    op1 = JS_ToNumeric(ctx, argv[0]);
-    if (JS_IsException(op1))
-        return op1;
-    a = JS_ToBigDecimal(ctx, op1);
-    if (!a) {
-        JS_FreeValue(ctx, op1);
-        return JS_EXCEPTION;
-    }
-    if (op_count >= 2) {
-        op2 = JS_ToNumeric(ctx, argv[1]);
-        if (JS_IsException(op2)) {
-            JS_FreeValue(ctx, op1);
-            return op2;
-        }
-        b = JS_ToBigDecimal(ctx, op2);
-        if (!b)
-            goto fail;
-    } else {
-        op2 = JS_UNDEFINED;
-        b = NULL;
-    }
-    fe->flags = BF_RNDZ;
-    fe->prec = BF_PREC_INF;
-    if (op_count < argc) {
-        if (js_bigdecimal_get_env(ctx, fe, argv[op_count]))
-            goto fail;
-    }
-
-    res = JS_NewBigDecimal(ctx);
-    if (JS_IsException(res)) {
-    fail:
-        JS_FreeValue(ctx, op1);
-        JS_FreeValue(ctx, op2);
-        return JS_EXCEPTION;
-    }
-    r = JS_GetBigDecimal(res);
-    switch (magic) {
-    case MATH_OP_ADD:
-        ret = bfdec_add(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_SUB:
-        ret = bfdec_sub(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_MUL:
-        ret = bfdec_mul(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_DIV:
-        ret = bfdec_div(r, a, b, fe->prec, fe->flags);
-        break;
-    case MATH_OP_FMOD:
-        ret = bfdec_rem(r, a, b, fe->prec, fe->flags, BF_RNDZ);
-        break;
-    case MATH_OP_SQRT:
-        ret = bfdec_sqrt(r, a, fe->prec, fe->flags);
-        break;
-    case MATH_OP_ROUND:
-        ret = bfdec_set(r, a);
-        if (!(ret & BF_ST_MEM_ERROR))
-            ret = bfdec_round(r, fe->prec, fe->flags);
-        break;
-    default:
-        abort();
-    }
-    JS_FreeValue(ctx, op1);
-    JS_FreeValue(ctx, op2);
-    ret &= BF_ST_MEM_ERROR | BF_ST_DIVIDE_ZERO | BF_ST_INVALID_OP |
-        BF_ST_OVERFLOW;
-    if (ret != 0) {
-        JS_FreeValue(ctx, res);
-        return throw_bf_exception(ctx, ret);
+    if (argc == 0 || JS_IsUndefined(argv[0])) {
+        base = 10;
     } else {
-        return res;
-    }
-}
-
-static JSValue js_bigdecimal_toFixed(JSContext *ctx, JSValueConst this_val,
-                                 int argc, JSValueConst *argv)
-{
-    JSValue val, ret;
-    int64_t f;
-    int rnd_mode;
-
-    val = js_thisBigDecimalValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (f < 0 || f > BF_PREC_MAX) {
-        JS_ThrowRangeError(ctx, "invalid number of digits");
-        goto fail;
-    }
-    rnd_mode = BF_RNDNA;
-    if (argc > 1) {
-        rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
-        if (rnd_mode < 0)
+        base = js_get_radix(ctx, argv[0]);
+        if (base < 0)
             goto fail;
     }
-    ret = js_bigdecimal_to_string1(ctx, val, f, rnd_mode | BF_FTOA_FORMAT_FRAC);
+    ret = js_bigint_to_string1(ctx, val, base);
     JS_FreeValue(ctx, val);
     return ret;
  fail:
@@ -50514,123 +52179,100 @@ static JSValue js_bigdecimal_toFixed(JSContext *ctx, JSValueConst this_val,
     return JS_EXCEPTION;
 }
 
-static JSValue js_bigdecimal_toExponential(JSContext *ctx, JSValueConst this_val,
-                                       int argc, JSValueConst *argv)
+static JSValue js_bigint_valueOf(JSContext *ctx, JSValueConst this_val,
+                                 int argc, JSValueConst *argv)
 {
-    JSValue val, ret;
-    int64_t f;
-    int rnd_mode;
-
-    val = js_thisBigDecimalValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_ToInt64Sat(ctx, &f, argv[0]))
-        goto fail;
-    if (JS_IsUndefined(argv[0])) {
-        ret = js_bigdecimal_to_string1(ctx, val, 0,
-                  BF_RNDN | BF_FTOA_FORMAT_FREE_MIN | BF_FTOA_FORCE_EXP);
-    } else {
-        if (f < 0 || f > BF_PREC_MAX) {
-            JS_ThrowRangeError(ctx, "invalid number of digits");
-            goto fail;
-        }
-        rnd_mode = BF_RNDNA;
-        if (argc > 1) {
-            rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
-            if (rnd_mode < 0)
-                goto fail;
-        }
-        ret = js_bigdecimal_to_string1(ctx, val, f + 1,
-                      rnd_mode | BF_FTOA_FORMAT_FIXED | BF_FTOA_FORCE_EXP);
-    }
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
+    return js_thisBigIntValue(ctx, this_val);
 }
 
-static JSValue js_bigdecimal_toPrecision(JSContext *ctx, JSValueConst this_val,
-                                     int argc, JSValueConst *argv)
+static JSValue js_bigint_asUintN(JSContext *ctx,
+                                  JSValueConst this_val,
+                                  int argc, JSValueConst *argv, int asIntN)
 {
-    JSValue val, ret;
-    int64_t p;
-    int rnd_mode;
-
-    val = js_thisBigDecimalValue(ctx, this_val);
-    if (JS_IsException(val))
-        return val;
-    if (JS_IsUndefined(argv[0])) {
-        return JS_ToStringFree(ctx, val);
-    }
-    if (JS_ToInt64Sat(ctx, &p, argv[0]))
-        goto fail;
-    if (p < 1 || p > BF_PREC_MAX) {
-        JS_ThrowRangeError(ctx, "invalid number of digits");
-        goto fail;
-    }
-    rnd_mode = BF_RNDNA;
-    if (argc > 1) {
-        rnd_mode = js_bigdecimal_get_rnd_mode(ctx, argv[1]);
-        if (rnd_mode < 0)
-            goto fail;
+    uint64_t bits;
+    JSValue res, a;
+    
+    if (JS_ToIndex(ctx, &bits, argv[0]))
+        return JS_EXCEPTION;
+    a = JS_ToBigInt(ctx, argv[1]);
+    if (JS_IsException(a))
+        return JS_EXCEPTION;
+    if (bits == 0) {
+        JS_FreeValue(ctx, a);
+        res = __JS_NewShortBigInt(ctx, 0);
+    } else if (JS_VALUE_GET_TAG(a) == JS_TAG_SHORT_BIG_INT) {
+        /* fast case */
+        if (bits >= JS_SHORT_BIG_INT_BITS) {
+            res = a;
+        } else {
+            uint64_t v;
+            int shift;
+            shift = 64 - bits;
+            v = JS_VALUE_GET_SHORT_BIG_INT(a);
+            v = v << shift;
+            if (asIntN)
+                v = (int64_t)v >> shift;
+            else
+                v = v >> shift;
+            res = __JS_NewShortBigInt(ctx, v);
+        }
+    } else {
+        JSBigInt *r, *p = JS_VALUE_GET_PTR(a);
+        if (bits >= p->len * JS_LIMB_BITS) {
+            res = a;
+        } else {
+            int len, shift, i;
+            js_limb_t v;
+            len = (bits + JS_LIMB_BITS - 1) / JS_LIMB_BITS;
+            r = js_bigint_new(ctx, len);
+            if (!r) {
+                JS_FreeValue(ctx, a);
+                return JS_EXCEPTION;
+            }
+            r->len = len;
+            for(i = 0; i < len - 1; i++)
+                r->tab[i] = p->tab[i];
+            shift = (-bits) & (JS_LIMB_BITS - 1);
+            /* 0 <= shift <= JS_LIMB_BITS - 1 */
+            v = p->tab[len - 1] << shift;
+            if (asIntN)
+                v = (js_slimb_t)v >> shift;
+            else
+                v = v >> shift;
+            r->tab[len - 1] = v;
+            r = js_bigint_normalize(ctx, r);
+            JS_FreeValue(ctx, a);
+            res = JS_CompactBigInt(ctx, r);
+        }
     }
-    ret = js_bigdecimal_to_string1(ctx, val, p,
-                                   rnd_mode | BF_FTOA_FORMAT_FIXED);
-    JS_FreeValue(ctx, val);
-    return ret;
- fail:
-    JS_FreeValue(ctx, val);
-    return JS_EXCEPTION;
+    return res;
 }
 
-static const JSCFunctionListEntry js_bigdecimal_proto_funcs[] = {
-    JS_CFUNC_DEF("toString", 0, js_bigdecimal_toString ),
-    JS_CFUNC_DEF("valueOf", 0, js_bigdecimal_valueOf ),
-    JS_CFUNC_DEF("toPrecision", 1, js_bigdecimal_toPrecision ),
-    JS_CFUNC_DEF("toFixed", 1, js_bigdecimal_toFixed ),
-    JS_CFUNC_DEF("toExponential", 1, js_bigdecimal_toExponential ),
+static const JSCFunctionListEntry js_bigint_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("asUintN", 2, js_bigint_asUintN, 0 ),
+    JS_CFUNC_MAGIC_DEF("asIntN", 2, js_bigint_asUintN, 1 ),
 };
 
-static const JSCFunctionListEntry js_bigdecimal_funcs[] = {
-    JS_CFUNC_MAGIC_DEF("add", 2, js_bigdecimal_fop, MATH_OP_ADD ),
-    JS_CFUNC_MAGIC_DEF("sub", 2, js_bigdecimal_fop, MATH_OP_SUB ),
-    JS_CFUNC_MAGIC_DEF("mul", 2, js_bigdecimal_fop, MATH_OP_MUL ),
-    JS_CFUNC_MAGIC_DEF("div", 2, js_bigdecimal_fop, MATH_OP_DIV ),
-    JS_CFUNC_MAGIC_DEF("mod", 2, js_bigdecimal_fop, MATH_OP_FMOD ),
-    JS_CFUNC_MAGIC_DEF("round", 1, js_bigdecimal_fop, MATH_OP_ROUND ),
-    JS_CFUNC_MAGIC_DEF("sqrt", 1, js_bigdecimal_fop, MATH_OP_SQRT ),
+static const JSCFunctionListEntry js_bigint_proto_funcs[] = {
+    JS_CFUNC_DEF("toString", 0, js_bigint_toString ),
+    JS_CFUNC_DEF("valueOf", 0, js_bigint_valueOf ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "BigInt", JS_PROP_CONFIGURABLE ),
 };
 
-void JS_AddIntrinsicBigDecimal(JSContext *ctx)
+static void JS_AddIntrinsicBigInt(JSContext *ctx)
 {
-    JSRuntime *rt = ctx->rt;
     JSValueConst obj1;
 
-    rt->bigdecimal_ops.to_string = js_bigdecimal_to_string;
-    rt->bigdecimal_ops.from_string = js_string_to_bigdecimal;
-    rt->bigdecimal_ops.unary_arith = js_unary_arith_bigdecimal;
-    rt->bigdecimal_ops.binary_arith = js_binary_arith_bigdecimal;
-    rt->bigdecimal_ops.compare = js_compare_bigdecimal;
-
-    ctx->class_proto[JS_CLASS_BIG_DECIMAL] = JS_NewObject(ctx);
-    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_DECIMAL],
-                               js_bigdecimal_proto_funcs,
-                               countof(js_bigdecimal_proto_funcs));
-    obj1 = JS_NewGlobalCConstructor(ctx, "BigDecimal",
-                                    js_bigdecimal_constructor, 1,
-                                    ctx->class_proto[JS_CLASS_BIG_DECIMAL]);
-    JS_SetPropertyFunctionList(ctx, obj1, js_bigdecimal_funcs,
-                               countof(js_bigdecimal_funcs));
-}
-
-void JS_EnableBignumExt(JSContext *ctx, BOOL enable)
-{
-    ctx->bignum_ext = enable;
+    ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
+                               js_bigint_proto_funcs,
+                               countof(js_bigint_proto_funcs));
+    obj1 = JS_NewGlobalCConstructor(ctx, "BigInt", js_bigint_constructor, 1,
+                                    ctx->class_proto[JS_CLASS_BIG_INT]);
+    JS_SetPropertyFunctionList(ctx, obj1, js_bigint_funcs,
+                               countof(js_bigint_funcs));
 }
 
-#endif /* CONFIG_BIGNUM */
-
 static const char * const native_error_name[JS_NATIVE_ERROR_COUNT] = {
     "EvalError", "RangeError", "ReferenceError",
     "SyntaxError", "TypeError", "URIError",
@@ -50645,6 +52287,8 @@ static void JS_AddIntrinsicBasicObjects(JSContext *ctx)
     int i;
 
     ctx->class_proto[JS_CLASS_OBJECT] = JS_NewObjectProto(ctx, JS_NULL);
+    JS_SetImmutablePrototype(ctx, ctx->class_proto[JS_CLASS_OBJECT]);
+    
     ctx->function_proto = JS_NewCFunction3(ctx, js_function_proto, "", 0,
                                            JS_CFUNC_generic, 0,
                                            ctx->class_proto[JS_CLASS_OBJECT]);
@@ -50702,16 +52346,14 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     ctx->throw_type_error = JS_NewCFunction(ctx, js_throw_type_error, NULL, 0);
 
     /* add caller and arguments properties to throw a TypeError */
-    obj1 = JS_NewCFunction(ctx, js_function_proto_caller, NULL, 0);
     JS_DefineProperty(ctx, ctx->function_proto, JS_ATOM_caller, JS_UNDEFINED,
-                      obj1, ctx->throw_type_error,
+                      ctx->throw_type_error, ctx->throw_type_error,
                       JS_PROP_HAS_GET | JS_PROP_HAS_SET |
                       JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE);
     JS_DefineProperty(ctx, ctx->function_proto, JS_ATOM_arguments, JS_UNDEFINED,
-                      obj1, ctx->throw_type_error,
+                      ctx->throw_type_error, ctx->throw_type_error,
                       JS_PROP_HAS_GET | JS_PROP_HAS_SET |
                       JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE);
-    JS_FreeValue(ctx, obj1);
     JS_FreeValue(ctx, js_object_seal(ctx, JS_UNDEFINED, 1, (JSValueConst *)&ctx->throw_type_error, 1));
 
     ctx->global_obj = JS_NewObject(ctx);
@@ -50737,12 +52379,15 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                                 "Error", 1, JS_CFUNC_constructor_or_func_magic, -1);
     JS_NewGlobalCConstructor2(ctx, obj1,
                               "Error", ctx->class_proto[JS_CLASS_ERROR]);
+    JS_SetPropertyFunctionList(ctx, obj1, js_error_funcs, countof(js_error_funcs));
 
+    /* Used to squelch a -Wcast-function-type warning. */
+    JSCFunctionType ft = { .generic_magic = js_error_constructor };
     for(i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
         JSValue func_obj;
         int n_args;
         n_args = 1 + (i == JS_AGGREGATE_ERROR);
-        func_obj = JS_NewCFunction3(ctx, (JSCFunction *)js_error_constructor,
+        func_obj = JS_NewCFunction3(ctx, ft.generic,
                                     native_error_name[i], n_args,
                                     JS_CFUNC_constructor_or_func_magic, i, obj1);
         JS_NewGlobalCConstructor2(ctx, func_obj, native_error_name[i],
@@ -50769,7 +52414,8 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     /* XXX: create auto_initializer */
     {
         /* initialize Array.prototype[Symbol.unscopables] */
-        char const unscopables[] =
+        static const char unscopables[] =
+            "at" "\0"
             "copyWithin" "\0"
             "entries" "\0"
             "fill" "\0"
@@ -50781,6 +52427,9 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
             "flatMap" "\0"
             "includes" "\0"
             "keys" "\0"
+            "toReversed" "\0"
+            "toSorted" "\0"
+            "toSpliced" "\0"
             "values" "\0";
         const char *p = unscopables;
         obj1 = JS_NewObjectProto(ctx, JS_NULL);
@@ -50876,9 +52525,10 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
                                countof(js_generator_proto_funcs));
 
     ctx->class_proto[JS_CLASS_GENERATOR_FUNCTION] = JS_NewObjectProto(ctx, ctx->function_proto);
-    obj1 = JS_NewCFunctionMagic(ctx, js_function_constructor,
-                                "GeneratorFunction", 1,
-                                JS_CFUNC_constructor_or_func_magic, JS_FUNC_GENERATOR);
+    obj1 = JS_NewCFunction3(ctx, (JSCFunction *)js_function_constructor,
+                            "GeneratorFunction", 1,
+                            JS_CFUNC_constructor_or_func_magic, JS_FUNC_GENERATOR,
+                            ctx->function_ctor);
     JS_SetPropertyFunctionList(ctx,
                                ctx->class_proto[JS_CLASS_GENERATOR_FUNCTION],
                                js_generator_function_proto_funcs,
@@ -50899,14 +52549,17 @@ void JS_AddIntrinsicBaseObjects(JSContext *ctx)
     JS_DefinePropertyValue(ctx, ctx->global_obj, JS_ATOM_globalThis,
                            JS_DupValue(ctx, ctx->global_obj),
                            JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE);
+
+    /* BigInt */
+    JS_AddIntrinsicBigInt(ctx);
 }
 
 /* Typed Arrays */
 
 static uint8_t const typed_array_size_log2[JS_TYPED_ARRAY_COUNT] = {
     0, 0, 0, 1, 1, 2, 2,
-    3, 3, /* BigInt64Array, BigUint64Array */
-    2, 3
+    3, 3,                   // BigInt64Array, BigUint64Array
+    1, 2, 3                 // Float16Array, Float32Array, Float64Array
 };
 
 static JSValue js_array_buffer_constructor3(JSContext *ctx,
@@ -51035,11 +52688,26 @@ static void js_array_buffer_finalizer(JSRuntime *rt, JSValue val)
 {
     JSObject *p = JS_VALUE_GET_OBJ(val);
     JSArrayBuffer *abuf = p->u.array_buffer;
+    struct list_head *el, *el1;
+
     if (abuf) {
         /* The ArrayBuffer finalizer may be called before the typed
            array finalizers using it, so abuf->array_list is not
            necessarily empty. */
-        // assert(list_empty(&abuf->array_list));
+        list_for_each_safe(el, el1, &abuf->array_list) {
+            JSTypedArray *ta;
+            JSObject *p1;
+
+            ta = list_entry(el, JSTypedArray, link);
+            ta->link.prev = NULL;
+            ta->link.next = NULL;
+            p1 = ta->obj;
+            /* Note: the typed array length and offset fields are not modified */
+            if (p1->class_id != JS_CLASS_DATAVIEW) {
+                p1->u.array.count = 0;
+                p1->u.array.u.ptr = NULL;
+            }
+        }
         if (abuf->shared && rt->sab_funcs.sab_free) {
             rt->sab_funcs.sab_free(rt->sab_funcs.sab_opaque, abuf->data);
         } else {
@@ -51349,6 +53017,16 @@ static JSValue js_typed_array_get_byteOffset(JSContext *ctx,
     return JS_NewInt32(ctx, ta->offset);
 }
 
+JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValueConst *argv,
+                         JSTypedArrayEnum type)
+{
+    if (type < JS_TYPED_ARRAY_UINT8C || type > JS_TYPED_ARRAY_FLOAT64)
+        return JS_ThrowRangeError(ctx, "invalid typed array type");
+
+    return js_typed_array_constructor(ctx, JS_UNDEFINED, argc, argv,
+                                      JS_CLASS_UINT8C_ARRAY + type);
+}
+
 /* Return the buffer associated to the typed array or an exception if
    it is not a typed array or if the buffer is detached. pbyte_offset,
    pbyte_length or pbytes_per_element can be NULL. */
@@ -51374,7 +53052,7 @@ JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
     }
     return JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, ta->buffer));
 }
-                               
+
 static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
                                               JSValueConst this_val)
 {
@@ -51492,6 +53170,46 @@ static JSValue js_typed_array_at(JSContext *ctx, JSValueConst this_val,
     return JS_GetPropertyInt64(ctx, this_val, idx);
 }
 
+static JSValue js_typed_array_with(JSContext *ctx, JSValueConst this_val,
+                                   int argc, JSValueConst *argv)
+{
+    JSValue arr, val;
+    JSObject *p;
+    int64_t idx, len;
+
+    p = get_typed_array(ctx, this_val, /*is_dataview*/0);
+    if (!p)
+        return JS_EXCEPTION;
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+
+    if (JS_ToInt64Sat(ctx, &idx, argv[0]))
+        return JS_EXCEPTION;
+
+    len = p->u.array.count;
+    if (idx < 0)
+        idx = len + idx;
+
+    val = JS_ToPrimitive(ctx, argv[1], HINT_NUMBER);
+    if (JS_IsException(val))
+        return JS_EXCEPTION;
+
+    if (typed_array_is_detached(ctx, p) || idx < 0 || idx >= len)
+        return JS_ThrowRangeError(ctx, "invalid array index");
+
+    arr = js_typed_array_constructor_ta(ctx, JS_UNDEFINED, this_val,
+                                        p->class_id);
+    if (JS_IsException(arr)) {
+        JS_FreeValue(ctx, val);
+        return JS_EXCEPTION;
+    }
+    if (JS_SetPropertyInt64(ctx, arr, idx, val) < 0) {
+        JS_FreeValue(ctx, arr);
+        return JS_EXCEPTION;
+    }
+    return arr;
+}
+
 static JSValue js_typed_array_set(JSContext *ctx,
                                   JSValueConst this_val,
                                   int argc, JSValueConst *argv)
@@ -51616,18 +53334,16 @@ static JSValue js_typed_array_from(JSContext *ctx, JSValueConst this_val,
     // from(items, mapfn = void 0, this_arg = void 0)
     JSValueConst items = argv[0], mapfn, this_arg;
     JSValueConst args[2];
-    JSValue stack[2];
     JSValue iter, arr, r, v, v2;
     int64_t k, len;
-    int done, mapping;
+    int mapping;
 
     mapping = FALSE;
     mapfn = JS_UNDEFINED;
     this_arg = JS_UNDEFINED;
     r = JS_UNDEFINED;
     arr = JS_UNDEFINED;
-    stack[0] = JS_UNDEFINED;
-    stack[1] = JS_UNDEFINED;
+    iter = JS_UNDEFINED;
 
     if (argc > 1) {
         mapfn = argv[1];
@@ -51642,30 +53358,23 @@ static JSValue js_typed_array_from(JSContext *ctx, JSValueConst this_val,
     iter = JS_GetProperty(ctx, items, JS_ATOM_Symbol_iterator);
     if (JS_IsException(iter))
         goto exception;
-    if (!JS_IsUndefined(iter)) {
-        JS_FreeValue(ctx, iter);
-        arr = JS_NewArray(ctx);
-        if (JS_IsException(arr))
-            goto exception;
-        stack[0] = JS_DupValue(ctx, items);
-        if (js_for_of_start(ctx, &stack[1], FALSE))
+    if (!JS_IsUndefined(iter) && !JS_IsNull(iter)) {
+        uint32_t len1;
+        if (!JS_IsFunction(ctx, iter)) {
+            JS_ThrowTypeError(ctx, "value is not iterable");
             goto exception;
-        for (k = 0;; k++) {
-            v = JS_IteratorNext(ctx, stack[0], stack[1], 0, NULL, &done);
-            if (JS_IsException(v))
-                goto exception_close;
-            if (done)
-                break;
-            if (JS_DefinePropertyValueInt64(ctx, arr, k, v, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
-                goto exception_close;
         }
+        arr = js_array_from_iterator(ctx, &len1, items, iter);
+        if (JS_IsException(arr))
+            goto exception;
+        len = len1;
     } else {
         arr = JS_ToObject(ctx, items);
         if (JS_IsException(arr))
             goto exception;
+        if (js_get_length64(ctx, &len, arr) < 0)
+            goto exception;
     }
-    if (js_get_length64(ctx, &len, arr) < 0)
-        goto exception;
     v = JS_NewInt64(ctx, len);
     args[0] = v;
     r = js_typed_array_create(ctx, this_val, 1, args);
@@ -51689,17 +53398,12 @@ static JSValue js_typed_array_from(JSContext *ctx, JSValueConst this_val,
             goto exception;
     }
     goto done;
-
- exception_close:
-    if (!JS_IsUndefined(stack[0]))
-        JS_IteratorClose(ctx, stack[0], TRUE);
  exception:
     JS_FreeValue(ctx, r);
     r = JS_EXCEPTION;
  done:
     JS_FreeValue(ctx, arr);
-    JS_FreeValue(ctx, stack[0]);
-    JS_FreeValue(ctx, stack[1]);
+    JS_FreeValue(ctx, iter);
     return r;
 }
 
@@ -51788,7 +53492,9 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
         double d;
         if (JS_ToFloat64(ctx, &d, argv[0]))
             return JS_EXCEPTION;
-        if (p->class_id == JS_CLASS_FLOAT32_ARRAY) {
+        if (p->class_id == JS_CLASS_FLOAT16_ARRAY) {
+            v64 = tofp16(d);
+        } else if (p->class_id == JS_CLASS_FLOAT32_ARRAY) {
             union {
                 float f;
                 uint32_t u32;
@@ -51816,7 +53522,7 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
 
     if (typed_array_is_detached(ctx, p))
         return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-    
+
     shift = typed_array_size_log2(p->class_id);
     switch(shift) {
     case 0:
@@ -51867,14 +53573,13 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
     if (argc > 1)
         this_arg = argv[1];
 
-    if (mode == special_findLast || mode == special_findLastIndex) {
+    k = 0;
+    dir = 1;
+    end = len;
+    if (mode == ArrayFindLast || mode == ArrayFindLastIndex) {
         k = len - 1;
         dir = -1;
         end = -1;
-    } else {
-        k = 0;
-        dir = 1;
-        end = len;
     }
 
     for(; k != end; k += dir) {
@@ -51889,7 +53594,7 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
         if (JS_IsException(res))
             goto exception;
         if (JS_ToBoolFree(ctx, res)) {
-            if (mode == special_findIndex || mode == special_findLastIndex) {
+            if (mode == ArrayFindIndex || mode == ArrayFindLastIndex) {
                 JS_FreeValue(ctx, val);
                 return index_val;
             } else {
@@ -51898,7 +53603,7 @@ static JSValue js_typed_array_find(JSContext *ctx, JSValueConst this_val,
         }
         JS_FreeValue(ctx, val);
     }
-    if (mode == special_findIndex || mode == special_findLastIndex)
+    if (mode == ArrayFindIndex || mode == ArrayFindLastIndex)
         return JS_NewInt32(ctx, -1);
     else
         return JS_UNDEFINED;
@@ -51920,6 +53625,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
     int64_t v64;
     double d;
     float f;
+    uint16_t hf;
 
     len = js_typed_array_get_length_internal(ctx, this_val);
     if (len < 0)
@@ -51968,7 +53674,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
             res = 0;
         goto done;
     }
-    
+
     is_bigint = 0;
     is_int = 0; /* avoid warning */
     v64 = 0; /* avoid warning */
@@ -51980,20 +53686,37 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
     } else
     if (tag == JS_TAG_FLOAT64) {
         d = JS_VALUE_GET_FLOAT64(argv[0]);
-        v64 = d;
-        is_int = (v64 == d);
-    } else if (tag == JS_TAG_BIG_INT) {
-        JSBigFloat *p1 = JS_VALUE_GET_PTR(argv[0]);
+        if (d >= INT64_MIN && d < 0x1p63) {
+            v64 = d;
+            is_int = (v64 == d);
+        }
+    } else if (tag == JS_TAG_BIG_INT || tag == JS_TAG_SHORT_BIG_INT) {
+        JSBigIntBuf buf1;
+        JSBigInt *p1;
+        int sz = (64 / JS_LIMB_BITS);
+        if (tag == JS_TAG_SHORT_BIG_INT)
+            p1 = js_bigint_set_short(&buf1, argv[0]);
+        else
+            p1 = JS_VALUE_GET_PTR(argv[0]);
         
         if (p->class_id == JS_CLASS_BIG_INT64_ARRAY) {
-            if (bf_get_int64(&v64, &p1->num, 0) != 0)
-                goto done;
+            if (p1->len > sz)
+                goto done; /* does not fit an int64 : cannot be found */
         } else if (p->class_id == JS_CLASS_BIG_UINT64_ARRAY) {
-            if (bf_get_uint64((uint64_t *)&v64, &p1->num) != 0)
+            if (js_bigint_sign(p1))
+                goto done; /* v < 0 */
+            if (p1->len <= sz) {
+                /* OK */
+            } else if (p1->len == sz + 1 && p1->tab[sz] == 0) {
+                /* 2^63 <= v <= 2^64-1 */
+            } else {
                 goto done;
+            }
         } else {
             goto done;
         }
+        if (JS_ToBigInt64(ctx, &v64, argv[0]))
+            goto exception;
         d = 0;
         is_bigint = 1;
     } else {
@@ -52065,6 +53788,39 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
             }
         }
         break;
+    case JS_CLASS_FLOAT16_ARRAY:
+        if (is_bigint)
+            break;
+        if (isnan(d)) {
+            const uint16_t *pv = p->u.array.u.fp16_ptr;
+            /* special case: indexOf returns -1, includes finds NaN */
+            if (special != special_includes)
+                goto done;
+            for (; k != stop; k += inc) {
+                if (isfp16nan(pv[k])) {
+                    res = k;
+                    break;
+                }
+            }
+        } else if (d == 0) {
+            // special case: includes also finds negative zero
+            const uint16_t *pv = p->u.array.u.fp16_ptr;
+            for (; k != stop; k += inc) {
+                if (isfp16zero(pv[k])) {
+                    res = k;
+                    break;
+                }
+            }
+        } else if (hf = tofp16(d), d == fromfp16(hf)) {
+            const uint16_t *pv = p->u.array.u.fp16_ptr;
+            for (; k != stop; k += inc) {
+                if (pv[k] == hf) {
+                    res = k;
+                    break;
+                }
+            }
+        }
+        break;
     case JS_CLASS_FLOAT32_ARRAY:
         if (is_bigint)
             break;
@@ -52114,15 +53870,12 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
         }
         break;
     case JS_CLASS_BIG_INT64_ARRAY:
-        if (is_bigint || (is_math_mode(ctx) && is_int &&
-                          v64 >= -MAX_SAFE_INTEGER &&
-                          v64 <= MAX_SAFE_INTEGER)) {
+        if (is_bigint) {
             goto scan64;
         }
         break;
     case JS_CLASS_BIG_UINT64_ARRAY:
-        if (is_bigint || (is_math_mode(ctx) && is_int &&
-                          v64 >= 0 && v64 <= MAX_SAFE_INTEGER)) {
+        if (is_bigint) {
             const uint64_t *pv;
             uint64_t v;
         scan64:
@@ -52270,6 +54023,36 @@ static JSValue js_typed_array_reverse(JSContext *ctx, JSValueConst this_val,
     return JS_DupValue(ctx, this_val);
 }
 
+static JSValue js_typed_array_toReversed(JSContext *ctx, JSValueConst this_val,
+                                         int argc, JSValueConst *argv)
+{
+    JSValue arr, ret;
+    JSObject *p;
+
+    p = get_typed_array(ctx, this_val, /*is_dataview*/0);
+    if (!p)
+        return JS_EXCEPTION;
+    arr = js_typed_array_constructor_ta(ctx, JS_UNDEFINED, this_val,
+                                        p->class_id);
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    ret = js_typed_array_reverse(ctx, arr, argc, argv);
+    JS_FreeValue(ctx, arr);
+    return ret;
+}
+
+static void slice_memcpy(uint8_t *dst, const uint8_t *src, size_t len)
+{
+    if (dst + len <= src || dst >= src + len) {
+        /* no overlap: can use memcpy */
+        memcpy(dst, src, len);
+    } else {
+        /* otherwise the spec mandates byte copy */
+        while (len-- != 0)
+            *dst++ = *src++;
+    }
+}
+
 static JSValue js_typed_array_slice(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv)
 {
@@ -52312,9 +54095,9 @@ static JSValue js_typed_array_slice(JSContext *ctx, JSValueConst this_val,
         if (p1 != NULL && p->class_id == p1->class_id &&
             typed_array_get_length(ctx, p1) >= count &&
             typed_array_get_length(ctx, p) >= start + count) {
-            memcpy(p1->u.array.u.uint8_ptr,
-                   p->u.array.u.uint8_ptr + (start << shift),
-                   count << shift);
+            slice_memcpy(p1->u.array.u.uint8_ptr,
+                         p->u.array.u.uint8_ptr + (start << shift),
+                         count << shift);
         } else {
             for (n = 0; n < count; n++) {
                 val = JS_GetPropertyValue(ctx, this_val, JS_NewInt32(ctx, start + n));
@@ -52337,7 +54120,8 @@ static JSValue js_typed_array_subarray(JSContext *ctx, JSValueConst this_val,
                                        int argc, JSValueConst *argv)
 {
     JSValueConst args[4];
-    JSValue arr, byteOffset, ta_buffer;
+    JSValue arr, ta_buffer;
+    JSTypedArray *ta;
     JSObject *p;
     int len, start, final, count, shift, offset;
 
@@ -52354,12 +54138,10 @@ static JSValue js_typed_array_subarray(JSContext *ctx, JSValueConst this_val,
             goto exception;
     }
     count = max_int(final - start, 0);
-    byteOffset = js_typed_array_get_byteOffset(ctx, this_val, 0);
-    if (JS_IsException(byteOffset))
-        goto exception;
     shift = typed_array_size_log2(p->class_id);
-    offset = JS_VALUE_GET_INT(byteOffset) + (start << shift);
-    JS_FreeValue(ctx, byteOffset);
+    ta = p->u.typed_array;
+    /* Read byteOffset (ta->offset) even if detached */
+    offset = ta->offset + (start << shift);
     ta_buffer = js_typed_array_get_buffer(ctx, this_val, 0);
     if (JS_IsException(ta_buffer))
         goto exception;
@@ -52428,6 +54210,11 @@ static int js_TA_cmp_uint64(const void *a, const void *b, void *opaque) {
     return (y < x) - (y > x);
 }
 
+static int js_TA_cmp_float16(const void *a, const void *b, void *opaque) {
+    return js_cmp_doubles(fromfp16(*(const uint16_t *)a),
+                          fromfp16(*(const uint16_t *)b));
+}
+
 static int js_TA_cmp_float32(const void *a, const void *b, void *opaque) {
     return js_cmp_doubles(*(const float *)a, *(const float *)b);
 }
@@ -52468,6 +54255,10 @@ static JSValue js_TA_get_uint64(JSContext *ctx, const void *a) {
     return JS_NewBigUint64(ctx, *(uint64_t *)a);
 }
 
+static JSValue js_TA_get_float16(JSContext *ctx, const void *a) {
+    return __JS_NewFloat64(ctx, fromfp16(*(const uint16_t *)a));
+}
+
 static JSValue js_TA_get_float32(JSContext *ctx, const void *a) {
     return __JS_NewFloat64(ctx, *(const float *)a);
 }
@@ -52478,7 +54269,7 @@ static JSValue js_TA_get_float64(JSContext *ctx, const void *a) {
 
 struct TA_sort_context {
     JSContext *ctx;
-    int exception;
+    int exception; /* 1 = exception, 2 = detached typed array */
     JSValueConst arr;
     JSValueConst cmp;
     JSValue (*getfun)(JSContext *ctx, const void *a);
@@ -52496,6 +54287,8 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
 
     cmp = 0;
     if (!psc->exception) {
+        /* Note: the typed array can be detached without causing an
+           error */
         a_idx = *(uint32_t *)a;
         b_idx = *(uint32_t *)b;
         argv[0] = psc->getfun(ctx, psc->array_ptr +
@@ -52523,8 +54316,9 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
             /* make sort stable: compare array offsets */
             cmp = (a_idx > b_idx) - (a_idx < b_idx);
         }
-        if (validate_typed_array(ctx, psc->arr) < 0) {
-            psc->exception = 1;
+        if (unlikely(typed_array_is_detached(ctx,
+                                             JS_VALUE_GET_PTR(psc->arr)))) {
+            psc->exception = 2;
         }
     done:
         JS_FreeValue(ctx, (JSValue)argv[0]);
@@ -52548,11 +54342,11 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
     tsc.arr = this_val;
     tsc.cmp = argv[0];
 
+    if (!JS_IsUndefined(tsc.cmp) && check_function(ctx, tsc.cmp))
+        return JS_EXCEPTION;
     len = js_typed_array_get_length_internal(ctx, this_val);
     if (len < 0)
         return JS_EXCEPTION;
-    if (!JS_IsUndefined(tsc.cmp) && check_function(ctx, tsc.cmp))
-        return JS_EXCEPTION;
 
     if (len > 1) {
         p = JS_VALUE_GET_OBJ(this_val);
@@ -52590,6 +54384,10 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             tsc.getfun = js_TA_get_uint64;
             cmpfun = js_TA_cmp_uint64;
             break;
+        case JS_CLASS_FLOAT16_ARRAY:
+            tsc.getfun = js_TA_get_float16;
+            cmpfun = js_TA_cmp_float16;
+            break;
         case JS_CLASS_FLOAT32_ARRAY:
             tsc.getfun = js_TA_get_float32;
             cmpfun = js_TA_cmp_float32;
@@ -52607,7 +54405,7 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             uint32_t *array_idx;
             void *array_tmp;
             size_t i, j;
-            
+
             /* XXX: a stable sort would use less memory */
             array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
             if (!array_idx)
@@ -52618,44 +54416,48 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             tsc.elt_size = elt_size;
             rqsort(array_idx, len, sizeof(array_idx[0]),
                    js_TA_cmp_generic, &tsc);
-            if (tsc.exception)
-                goto fail;
-            array_tmp = js_malloc(ctx, len * elt_size);
-            if (!array_tmp) {
-            fail:
-                js_free(ctx, array_idx);
-                return JS_EXCEPTION;
-            }
-            memcpy(array_tmp, array_ptr, len * elt_size);
-            switch(elt_size) {
-            case 1:
-                for(i = 0; i < len; i++) {
-                    j = array_idx[i];
-                    ((uint8_t *)array_ptr)[i] = ((uint8_t *)array_tmp)[j];
-                }
-                break;
-            case 2:
-                for(i = 0; i < len; i++) {
-                    j = array_idx[i];
-                    ((uint16_t *)array_ptr)[i] = ((uint16_t *)array_tmp)[j];
-                }
-                break;
-            case 4:
-                for(i = 0; i < len; i++) {
-                    j = array_idx[i];
-                    ((uint32_t *)array_ptr)[i] = ((uint32_t *)array_tmp)[j];
+            if (tsc.exception) {
+                if (tsc.exception == 1)
+                    goto fail;
+                /* detached typed array during the sort: no error */
+            } else {
+                array_tmp = js_malloc(ctx, len * elt_size);
+                if (!array_tmp) {
+                fail:
+                    js_free(ctx, array_idx);
+                    return JS_EXCEPTION;
                 }
-                break;
-            case 8:
-                for(i = 0; i < len; i++) {
-                    j = array_idx[i];
-                    ((uint64_t *)array_ptr)[i] = ((uint64_t *)array_tmp)[j];
+                memcpy(array_tmp, array_ptr, len * elt_size);
+                switch(elt_size) {
+                case 1:
+                    for(i = 0; i < len; i++) {
+                        j = array_idx[i];
+                        ((uint8_t *)array_ptr)[i] = ((uint8_t *)array_tmp)[j];
+                    }
+                    break;
+                case 2:
+                    for(i = 0; i < len; i++) {
+                        j = array_idx[i];
+                        ((uint16_t *)array_ptr)[i] = ((uint16_t *)array_tmp)[j];
+                    }
+                    break;
+                case 4:
+                    for(i = 0; i < len; i++) {
+                        j = array_idx[i];
+                        ((uint32_t *)array_ptr)[i] = ((uint32_t *)array_tmp)[j];
+                    }
+                    break;
+                case 8:
+                    for(i = 0; i < len; i++) {
+                        j = array_idx[i];
+                        ((uint64_t *)array_ptr)[i] = ((uint64_t *)array_tmp)[j];
+                    }
+                    break;
+                default:
+                    abort();
                 }
-                break;
-            default:
-                abort();
+                js_free(ctx, array_tmp);
             }
-            js_free(ctx, array_tmp);
             js_free(ctx, array_idx);
         } else {
             rqsort(array_ptr, len, elt_size, cmpfun, &tsc);
@@ -52666,6 +54468,24 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
     return JS_DupValue(ctx, this_val);
 }
 
+static JSValue js_typed_array_toSorted(JSContext *ctx, JSValueConst this_val,
+                                       int argc, JSValueConst *argv)
+{
+    JSValue arr, ret;
+    JSObject *p;
+
+    p = get_typed_array(ctx, this_val, /*is_dataview*/0);
+    if (!p)
+        return JS_EXCEPTION;
+    arr = js_typed_array_constructor_ta(ctx, JS_UNDEFINED, this_val,
+                                        p->class_id);
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    ret = js_typed_array_sort(ctx, arr, argc, argv);
+    JS_FreeValue(ctx, arr);
+    return ret;
+}
+
 static const JSCFunctionListEntry js_typed_array_base_funcs[] = {
     JS_CFUNC_DEF("from", 1, js_typed_array_from ),
     JS_CFUNC_DEF("of", 0, js_typed_array_of ),
@@ -52678,6 +54498,7 @@ static const JSCFunctionListEntry js_typed_array_base_funcs[] = {
 static const JSCFunctionListEntry js_typed_array_base_proto_funcs[] = {
     JS_CGETSET_DEF("length", js_typed_array_get_length, NULL ),
     JS_CFUNC_DEF("at", 1, js_typed_array_at ),
+    JS_CFUNC_DEF("with", 2, js_typed_array_with ),
     JS_CGETSET_MAGIC_DEF("buffer", js_typed_array_get_buffer, NULL, 0 ),
     JS_CGETSET_MAGIC_DEF("byteLength", js_typed_array_get_byteLength, NULL, 0 ),
     JS_CGETSET_MAGIC_DEF("byteOffset", js_typed_array_get_byteOffset, NULL, 0 ),
@@ -52696,14 +54517,16 @@ static const JSCFunctionListEntry js_typed_array_base_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("reduce", 1, js_array_reduce, special_reduce | special_TA ),
     JS_CFUNC_MAGIC_DEF("reduceRight", 1, js_array_reduce, special_reduceRight | special_TA ),
     JS_CFUNC_DEF("fill", 1, js_typed_array_fill ),
-    JS_CFUNC_MAGIC_DEF("find", 1, js_typed_array_find, special_find ),
-    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_typed_array_find, special_findIndex ),
-    JS_CFUNC_MAGIC_DEF("findLast", 1, js_typed_array_find, special_findLast ),
-    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_typed_array_find, special_findLastIndex ),
+    JS_CFUNC_MAGIC_DEF("find", 1, js_typed_array_find, ArrayFind ),
+    JS_CFUNC_MAGIC_DEF("findIndex", 1, js_typed_array_find, ArrayFindIndex ),
+    JS_CFUNC_MAGIC_DEF("findLast", 1, js_typed_array_find, ArrayFindLast ),
+    JS_CFUNC_MAGIC_DEF("findLastIndex", 1, js_typed_array_find, ArrayFindLastIndex ),
     JS_CFUNC_DEF("reverse", 0, js_typed_array_reverse ),
+    JS_CFUNC_DEF("toReversed", 0, js_typed_array_toReversed ),
     JS_CFUNC_DEF("slice", 2, js_typed_array_slice ),
     JS_CFUNC_DEF("subarray", 2, js_typed_array_subarray ),
     JS_CFUNC_DEF("sort", 1, js_typed_array_sort ),
+    JS_CFUNC_DEF("toSorted", 1, js_typed_array_toSorted ),
     JS_CFUNC_MAGIC_DEF("join", 1, js_typed_array_join, 0 ),
     JS_CFUNC_MAGIC_DEF("toLocaleString", 0, js_typed_array_join, 1 ),
     JS_CFUNC_MAGIC_DEF("indexOf", 1, js_typed_array_indexOf, special_indexOf ),
@@ -52771,10 +54594,8 @@ static JSValue js_array_from_iterator(JSContext *ctx, uint32_t *plen,
         val = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
         if (JS_IsException(val))
             goto fail;
-        if (done) {
-            JS_FreeValue(ctx, val);
+        if (done)
             break;
-        }
         if (JS_CreateDataPropertyUint32(ctx, arr, k, val, JS_PROP_THROW) < 0)
             goto fail;
         k++;
@@ -52975,7 +54796,7 @@ static void js_typed_array_finalizer(JSRuntime *rt, JSValue val)
     if (ta) {
         /* during the GC the finalizers are called in an arbitrary
            order so the ArrayBuffer finalizer may have been called */
-        if (JS_IsLiveObject(rt, JS_MKPTR(JS_TAG_OBJECT, ta->buffer))) {
+        if (ta->link.next) {
             list_del(&ta->link);
         }
         JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_OBJECT, ta->buffer));
@@ -53058,7 +54879,8 @@ static JSValue js_dataview_getValue(JSContext *ctx,
 {
     JSTypedArray *ta;
     JSArrayBuffer *abuf;
-    int is_swap, size;
+    BOOL littleEndian, is_swap;
+    int size;
     uint8_t *ptr;
     uint32_t v;
     uint64_t pos;
@@ -53069,12 +54891,8 @@ static JSValue js_dataview_getValue(JSContext *ctx,
     size = 1 << typed_array_size_log2(class_id);
     if (JS_ToIndex(ctx, &pos, argv[0]))
         return JS_EXCEPTION;
-    is_swap = FALSE;
-    if (argc > 1)
-        is_swap = JS_ToBool(ctx, argv[1]);
-#ifndef WORDS_BIGENDIAN
-    is_swap ^= 1;
-#endif
+    littleEndian = argc > 1 && JS_ToBool(ctx, argv[1]);
+    is_swap = littleEndian ^ !is_be();
     abuf = ta->buffer->u.array_buffer;
     if (abuf->detached)
         return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
@@ -53125,6 +54943,14 @@ static JSValue js_dataview_getValue(JSContext *ctx,
             return JS_NewBigUint64(ctx, v);
         }
         break;
+    case JS_CLASS_FLOAT16_ARRAY:
+        {
+            uint16_t v;
+            v = get_u16(ptr);
+            if (is_swap)
+                v = bswap16(v);
+            return __JS_NewFloat64(ctx, fromfp16(v));
+        }
     case JS_CLASS_FLOAT32_ARRAY:
         {
             union {
@@ -53159,7 +54985,8 @@ static JSValue js_dataview_setValue(JSContext *ctx,
 {
     JSTypedArray *ta;
     JSArrayBuffer *abuf;
-    int is_swap, size;
+    BOOL littleEndian, is_swap;
+    int size;
     uint8_t *ptr;
     uint64_t v64;
     uint32_t v;
@@ -53185,7 +55012,9 @@ static JSValue js_dataview_setValue(JSContext *ctx,
         double d;
         if (JS_ToFloat64(ctx, &d, val))
             return JS_EXCEPTION;
-        if (class_id == JS_CLASS_FLOAT32_ARRAY) {
+        if (class_id == JS_CLASS_FLOAT16_ARRAY) {
+            v = tofp16(d);
+        } else if (class_id == JS_CLASS_FLOAT32_ARRAY) {
             union {
                 float f;
                 uint32_t i;
@@ -53198,12 +55027,8 @@ static JSValue js_dataview_setValue(JSContext *ctx,
             v64 = u.u64;
         }
     }
-    is_swap = FALSE;
-    if (argc > 2)
-        is_swap = JS_ToBool(ctx, argv[2]);
-#ifndef WORDS_BIGENDIAN
-    is_swap ^= 1;
-#endif
+    littleEndian = argc > 2 && JS_ToBool(ctx, argv[2]);
+    is_swap = littleEndian ^ !is_be();
     abuf = ta->buffer->u.array_buffer;
     if (abuf->detached)
         return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
@@ -53218,6 +55043,7 @@ static JSValue js_dataview_setValue(JSContext *ctx,
         break;
     case JS_CLASS_INT16_ARRAY:
     case JS_CLASS_UINT16_ARRAY:
+    case JS_CLASS_FLOAT16_ARRAY:
         if (is_swap)
             v = bswap16(v);
         put_u16(ptr, v);
@@ -53254,6 +55080,7 @@ static const JSCFunctionListEntry js_dataview_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("getUint32", 1, js_dataview_getValue, JS_CLASS_UINT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getBigInt64", 1, js_dataview_getValue, JS_CLASS_BIG_INT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getBigUint64", 1, js_dataview_getValue, JS_CLASS_BIG_UINT64_ARRAY ),
+    JS_CFUNC_MAGIC_DEF("getFloat16", 1, js_dataview_getValue, JS_CLASS_FLOAT16_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getFloat32", 1, js_dataview_getValue, JS_CLASS_FLOAT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("getFloat64", 1, js_dataview_getValue, JS_CLASS_FLOAT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setInt8", 2, js_dataview_setValue, JS_CLASS_INT8_ARRAY ),
@@ -53264,6 +55091,7 @@ static const JSCFunctionListEntry js_dataview_proto_funcs[] = {
     JS_CFUNC_MAGIC_DEF("setUint32", 2, js_dataview_setValue, JS_CLASS_UINT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setBigInt64", 2, js_dataview_setValue, JS_CLASS_BIG_INT64_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setBigUint64", 2, js_dataview_setValue, JS_CLASS_BIG_UINT64_ARRAY ),
+    JS_CFUNC_MAGIC_DEF("setFloat16", 2, js_dataview_setValue, JS_CLASS_FLOAT16_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setFloat32", 2, js_dataview_setValue, JS_CLASS_FLOAT32_ARRAY ),
     JS_CFUNC_MAGIC_DEF("setFloat64", 2, js_dataview_setValue, JS_CLASS_FLOAT64_ARRAY ),
     JS_PROP_STRING_DEF("[Symbol.toStringTag]", "DataView", JS_PROP_CONFIGURABLE ),
@@ -53326,6 +55154,11 @@ static void *js_atomics_get_ptr(JSContext *ctx,
     if (JS_ToIndex(ctx, &idx, idx_val)) {
         return NULL;
     }
+    /* RevalidateAtomicAccess(): must test again detached after JS_ToIndex() */
+    if (abuf->detached) {
+        JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return NULL;
+    }
     /* if the array buffer is detached, p->u.array.count = 0 */
     if (idx >= p->u.array.count) {
         JS_ThrowRangeError(ctx, "out-of-bound access");
@@ -53387,7 +55220,7 @@ static JSValue js_atomics_op(JSContext *ctx,
    }
 
    switch(op | (size_log2 << 3)) {
-            
+
 #define OP(op_name, func_name)                          \
     case ATOMICS_OP_ ## op_name | (0 << 3):             \
        a = func_name((_Atomic(uint8_t) *)ptr, v);       \
@@ -53401,7 +55234,7 @@ static JSValue js_atomics_op(JSContext *ctx,
     case ATOMICS_OP_ ## op_name | (3 << 3):             \
         a = func_name((_Atomic(uint64_t) *)ptr, v);     \
         break;
-       
+
         OP(ADD, atomic_fetch_add)
         OP(AND, atomic_fetch_and)
         OP(OR, atomic_fetch_or)
@@ -53422,7 +55255,7 @@ static JSValue js_atomics_op(JSContext *ctx,
     case ATOMICS_OP_LOAD | (3 << 3):
         a = atomic_load((_Atomic(uint64_t) *)ptr);
         break;
-        
+
     case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
         {
             uint8_t v1 = v;
@@ -53502,7 +55335,7 @@ static JSValue js_atomics_store(JSContext *ctx,
         return JS_EXCEPTION;
     if (size_log2 == 3) {
         int64_t v64;
-        ret = JS_ToBigIntValueFree(ctx, JS_DupValue(ctx, argv[2]));
+        ret = JS_ToBigIntFree(ctx, JS_DupValue(ctx, argv[2]));
         if (JS_IsException(ret))
             return ret;
         if (JS_ToBigInt64(ctx, &v64, ret)) {
@@ -53583,14 +55416,15 @@ static JSValue js_atomics_wait(JSContext *ctx,
     if (size_log2 == 3) {
         if (JS_ToBigInt64(ctx, &v, argv[2]))
             return JS_EXCEPTION;
-    } else {        
+    } else {
         if (JS_ToInt32(ctx, &v32, argv[2]))
             return JS_EXCEPTION;
         v = v32;
     }
     if (JS_ToFloat64(ctx, &d, argv[3]))
         return JS_EXCEPTION;
-    if (isnan(d) || d > INT64_MAX)
+    /* must use INT64_MAX + 1 because INT64_MAX cannot be exactly represented as a double */
+    if (isnan(d) || d >= 0x1p63)
         timeout = INT64_MAX;
     else if (d < 0)
         timeout = 0;
@@ -53761,13 +55595,15 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
     JS_DefinePropertyValue(ctx, typed_array_base_proto, JS_ATOM_toString, obj,
                            JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
 
-    typed_array_base_func = JS_NewCFunction(ctx, js_typed_array_base_constructor,
-                                            "TypedArray", 0);
+    typed_array_base_func = JS_NewCFunction2(ctx, js_typed_array_base_constructor,
+                                             "TypedArray", 0, JS_CFUNC_constructor_or_func, 0);
     JS_SetPropertyFunctionList(ctx, typed_array_base_func,
                                js_typed_array_base_funcs,
                                countof(js_typed_array_base_funcs));
     JS_SetConstructor(ctx, typed_array_base_func, typed_array_base_proto);
 
+    /* Used to squelch a -Wcast-function-type warning. */
+    JSCFunctionType ft = { .generic_magic = js_typed_array_constructor };
     for(i = JS_CLASS_UINT8C_ARRAY; i < JS_CLASS_UINT8C_ARRAY + JS_TYPED_ARRAY_COUNT; i++) {
         JSValue func_obj;
         char buf[ATOM_GET_STR_BUF_SIZE];
@@ -53780,7 +55616,7 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
                                   0);
         name = JS_AtomGetStr(ctx, buf, sizeof(buf),
                              JS_ATOM_Uint8ClampedArray + i - JS_CLASS_UINT8C_ARRAY);
-        func_obj = JS_NewCFunction3(ctx, (JSCFunction *)js_typed_array_constructor,
+        func_obj = JS_NewCFunction3(ctx, ft.generic,
                                     name, 3, JS_CFUNC_constructor_magic, i,
                                     typed_array_base_func);
         JS_NewGlobalCConstructor2(ctx, func_obj, name, ctx->class_proto[i]);
@@ -53806,13 +55642,281 @@ void JS_AddIntrinsicTypedArrays(JSContext *ctx)
 #endif
 }
 
-JSClassID JS_GetClassID(JSValueConst v)
+/* WeakRef */
+
+typedef struct JSWeakRefData {
+    JSWeakRefHeader weakref_header;
+    JSValue target;
+} JSWeakRefData;
+
+static void js_weakref_finalizer(JSRuntime *rt, JSValue val)
 {
-    JSObject *p;
+    JSWeakRefData *wrd = JS_GetOpaque(val, JS_CLASS_WEAK_REF);
+    if (!wrd)
+        return;
+    js_weakref_free(rt, wrd->target);
+    list_del(&wrd->weakref_header.link);
+    js_free_rt(rt, wrd);
+}
 
-    if (JS_VALUE_GET_TAG(v) != JS_TAG_OBJECT)
-        return 0;
-    p = JS_VALUE_GET_OBJ(v);
-    assert(p != 0);
-    return p->class_id;
+static void weakref_delete_weakref(JSRuntime *rt, JSWeakRefHeader *wh)
+{
+    JSWeakRefData *wrd = container_of(wh, JSWeakRefData, weakref_header);
+
+    if (!js_weakref_is_live(wrd->target)) {
+        js_weakref_free(rt, wrd->target);
+        wrd->target = JS_UNDEFINED;
+    }
+}
+
+static JSValue js_weakref_constructor(JSContext *ctx, JSValueConst new_target,
+                                      int argc, JSValueConst *argv)
+{
+    JSValueConst arg;
+    JSValue obj;
+
+    if (JS_IsUndefined(new_target))
+        return JS_ThrowTypeError(ctx, "constructor requires 'new'");
+    arg = argv[0];
+    if (!js_weakref_is_target(arg))
+        return JS_ThrowTypeError(ctx, "invalid target");
+    obj = js_create_from_ctor(ctx, new_target, JS_CLASS_WEAK_REF);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    JSWeakRefData *wrd = js_mallocz(ctx, sizeof(*wrd));
+    if (!wrd) {
+        JS_FreeValue(ctx, obj);
+        return JS_EXCEPTION;
+    }
+    wrd->target = js_weakref_new(ctx, arg);
+    wrd->weakref_header.weakref_type = JS_WEAKREF_TYPE_WEAKREF;
+    list_add_tail(&wrd->weakref_header.link, &ctx->rt->weakref_list);
+    JS_SetOpaque(obj, wrd);
+    return obj;
+}
+
+static JSValue js_weakref_deref(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+    JSWeakRefData *wrd = JS_GetOpaque2(ctx, this_val, JS_CLASS_WEAK_REF);
+    if (!wrd)
+        return JS_EXCEPTION;
+    if (js_weakref_is_live(wrd->target)) 
+        return JS_DupValue(ctx, wrd->target);
+    else
+        return JS_UNDEFINED;
+}
+
+static const JSCFunctionListEntry js_weakref_proto_funcs[] = {
+    JS_CFUNC_DEF("deref", 0, js_weakref_deref ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "WeakRef", JS_PROP_CONFIGURABLE ),
+};
+
+static const JSClassShortDef js_weakref_class_def[] = {
+    { JS_ATOM_WeakRef, js_weakref_finalizer, NULL }, /* JS_CLASS_WEAK_REF */
+};
+
+typedef struct JSFinRecEntry {
+    struct list_head link;
+    JSValue target;
+    JSValue held_val;
+    JSValue token;
+} JSFinRecEntry;
+
+typedef struct JSFinalizationRegistryData {
+    JSWeakRefHeader weakref_header;
+    struct list_head entries; /* list of JSFinRecEntry.link */
+    JSContext *realm;
+    JSValue cb;
+} JSFinalizationRegistryData;
+
+static void js_finrec_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSFinalizationRegistryData *frd = JS_GetOpaque(val, JS_CLASS_FINALIZATION_REGISTRY);
+    if (frd) {
+        struct list_head *el, *el1;
+        list_for_each_safe(el, el1, &frd->entries) {
+            JSFinRecEntry *fre = list_entry(el, JSFinRecEntry, link);
+            js_weakref_free(rt, fre->target);
+            js_weakref_free(rt, fre->token);
+            JS_FreeValueRT(rt, fre->held_val);
+            js_free_rt(rt, fre);
+        }
+        JS_FreeValueRT(rt, frd->cb);
+        JS_FreeContext(frd->realm);
+        list_del(&frd->weakref_header.link);
+        js_free_rt(rt, frd);
+    }
+}
+
+static void js_finrec_mark(JSRuntime *rt, JSValueConst val,
+                           JS_MarkFunc *mark_func)
+{
+    JSFinalizationRegistryData *frd = JS_GetOpaque(val, JS_CLASS_FINALIZATION_REGISTRY);
+    struct list_head *el;
+    if (frd) {
+        list_for_each(el, &frd->entries) {
+            JSFinRecEntry *fre = list_entry(el, JSFinRecEntry, link);
+            JS_MarkValue(rt, fre->held_val, mark_func);
+        }
+        JS_MarkValue(rt, frd->cb, mark_func);
+        mark_func(rt, &frd->realm->header);
+    }
+}
+
+static JSValue js_finrec_job(JSContext *ctx, int argc, JSValueConst *argv)
+{
+    return JS_Call(ctx, argv[0], JS_UNDEFINED, 1, &argv[1]);
+}
+
+static void finrec_delete_weakref(JSRuntime *rt, JSWeakRefHeader *wh)
+{
+    JSFinalizationRegistryData *frd = container_of(wh, JSFinalizationRegistryData, weakref_header);
+    struct list_head *el, *el1;
+
+    list_for_each_safe(el, el1, &frd->entries) {
+        JSFinRecEntry *fre = list_entry(el, JSFinRecEntry, link);
+
+        if (!js_weakref_is_live(fre->token)) {
+            js_weakref_free(rt, fre->token);
+            fre->token = JS_UNDEFINED;
+        }
+
+        if (!js_weakref_is_live(fre->target)) {
+            JSValueConst args[2];
+            args[0] = frd->cb;
+            args[1] = fre->held_val;
+            JS_EnqueueJob(frd->realm, js_finrec_job, 2, args);
+                
+            js_weakref_free(rt, fre->target);
+            js_weakref_free(rt, fre->token);
+            JS_FreeValueRT(rt, fre->held_val);
+            list_del(&fre->link);
+            js_free_rt(rt, fre);
+        }
+    }
+}
+
+static JSValue js_finrec_constructor(JSContext *ctx, JSValueConst new_target,
+                                     int argc, JSValueConst *argv)
+{
+    JSValueConst cb;
+    JSValue obj;
+    JSFinalizationRegistryData *frd;
+    
+    if (JS_IsUndefined(new_target))
+        return JS_ThrowTypeError(ctx, "constructor requires 'new'");
+    cb = argv[0];
+    if (!JS_IsFunction(ctx, cb))
+        return JS_ThrowTypeError(ctx, "argument must be a function");
+
+    obj = js_create_from_ctor(ctx, new_target, JS_CLASS_FINALIZATION_REGISTRY);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    frd = js_mallocz(ctx, sizeof(*frd));
+    if (!frd) {
+        JS_FreeValue(ctx, obj);
+        return JS_EXCEPTION;
+    }
+    frd->weakref_header.weakref_type = JS_WEAKREF_TYPE_FINREC;
+    list_add_tail(&frd->weakref_header.link, &ctx->rt->weakref_list);
+    init_list_head(&frd->entries);
+    frd->realm = JS_DupContext(ctx);
+    frd->cb = JS_DupValue(ctx, cb);
+    JS_SetOpaque(obj, frd);
+    return obj;
+}
+
+static JSValue js_finrec_register(JSContext *ctx, JSValueConst this_val,
+                                  int argc, JSValueConst *argv)
+{
+    JSValueConst target, held_val, token;
+    JSFinalizationRegistryData *frd;
+    JSFinRecEntry *fre;
+
+    frd = JS_GetOpaque2(ctx, this_val, JS_CLASS_FINALIZATION_REGISTRY);
+    if (!frd)
+        return JS_EXCEPTION;
+    target = argv[0];
+    held_val = argv[1];
+    token = argc > 2 ? argv[2] : JS_UNDEFINED;
+
+    if (!js_weakref_is_target(target))
+        return JS_ThrowTypeError(ctx, "invalid target");
+    if (js_same_value(ctx, target, held_val))
+        return JS_ThrowTypeError(ctx, "held value cannot be the target");
+    if (!JS_IsUndefined(token) && !js_weakref_is_target(token))
+        return JS_ThrowTypeError(ctx, "invalid unregister token");
+    fre = js_malloc(ctx, sizeof(*fre));
+    if (!fre)
+        return JS_EXCEPTION;
+    fre->target = js_weakref_new(ctx, target);
+    fre->held_val = JS_DupValue(ctx, held_val);
+    fre->token = js_weakref_new(ctx, token);
+    list_add_tail(&fre->link, &frd->entries);
+    return JS_UNDEFINED;
+}
+
+static JSValue js_finrec_unregister(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+    JSFinalizationRegistryData *frd = JS_GetOpaque2(ctx, this_val, JS_CLASS_FINALIZATION_REGISTRY);
+    JSValueConst token;
+    BOOL removed;
+    struct list_head *el, *el1;
+
+    if (!frd)
+        return JS_EXCEPTION;
+    token = argv[0];
+    if (!js_weakref_is_target(token))
+        return JS_ThrowTypeError(ctx, "invalid unregister token");
+
+    removed = FALSE;
+    list_for_each_safe(el, el1, &frd->entries) {
+        JSFinRecEntry *fre = list_entry(el, JSFinRecEntry, link);
+        if (js_weakref_is_live(fre->token) && js_same_value(ctx, fre->token, token)) {
+            js_weakref_free(ctx->rt, fre->target);
+            js_weakref_free(ctx->rt, fre->token);
+            JS_FreeValue(ctx, fre->held_val);
+            list_del(&fre->link);
+            js_free(ctx, fre);
+            removed = TRUE;
+        }
+    }
+    return JS_NewBool(ctx, removed);
+}
+
+static const JSCFunctionListEntry js_finrec_proto_funcs[] = {
+    JS_CFUNC_DEF("register", 2, js_finrec_register ),
+    JS_CFUNC_DEF("unregister", 1, js_finrec_unregister ),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "FinalizationRegistry", JS_PROP_CONFIGURABLE ),
+};
+
+static const JSClassShortDef js_finrec_class_def[] = {
+    { JS_ATOM_FinalizationRegistry, js_finrec_finalizer, js_finrec_mark }, /* JS_CLASS_FINALIZATION_REGISTRY */
+};
+
+void JS_AddIntrinsicWeakRef(JSContext *ctx)
+{
+    JSRuntime *rt = ctx->rt;
+
+    /* WeakRef */
+    if (!JS_IsRegisteredClass(rt, JS_CLASS_WEAK_REF)) {
+        init_class_range(rt, js_weakref_class_def, JS_CLASS_WEAK_REF,
+                         countof(js_weakref_class_def));
+    }
+    ctx->class_proto[JS_CLASS_WEAK_REF] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_WEAK_REF],
+                               js_weakref_proto_funcs,
+                               countof(js_weakref_proto_funcs));
+    JS_NewGlobalCConstructor(ctx, "WeakRef", js_weakref_constructor, 1, ctx->class_proto[JS_CLASS_WEAK_REF]);
+
+    /* FinalizationRegistry */
+    if (!JS_IsRegisteredClass(rt, JS_CLASS_FINALIZATION_REGISTRY)) {
+        init_class_range(rt, js_finrec_class_def, JS_CLASS_FINALIZATION_REGISTRY,
+                         countof(js_finrec_class_def));
+    }
+    ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY] = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY],
+                               js_finrec_proto_funcs,
+                               countof(js_finrec_proto_funcs));
+    JS_NewGlobalCConstructor(ctx, "FinalizationRegistry", js_finrec_constructor, 1, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY]);
 }
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
index 296137e741..2083f73738 100644
--- a/quickjs/quickjs.h
+++ b/quickjs/quickjs.h
@@ -27,6 +27,7 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,7 +49,6 @@ extern "C" {
 
 typedef struct JSRuntime JSRuntime;
 typedef struct JSContext JSContext;
-typedef struct JSObject JSObject;
 typedef struct JSClass JSClass;
 typedef uint32_t JSClassID;
 typedef uint32_t JSAtom;
@@ -64,14 +64,21 @@ typedef uint32_t JSAtom;
 #define JS_NAN_BOXING
 #endif
 
+#if defined(__SIZEOF_INT128__) && (INTPTR_MAX >= INT64_MAX)
+#define JS_LIMB_BITS 64
+#else
+#define JS_LIMB_BITS 32
+#endif
+
+#define JS_SHORT_BIG_INT_BITS JS_LIMB_BITS
+    
 enum {
     /* all tags with a reference count are negative */
-    JS_TAG_FIRST       = -11, /* first negative tag */
-    JS_TAG_BIG_DECIMAL = -11,
-    JS_TAG_BIG_INT     = -10,
-    JS_TAG_BIG_FLOAT   = -9,
+    JS_TAG_FIRST       = -9, /* first negative tag */
+    JS_TAG_BIG_INT     = -9,
     JS_TAG_SYMBOL      = -8,
     JS_TAG_STRING      = -7,
+    JS_TAG_STRING_ROPE = -6,
     JS_TAG_MODULE      = -3, /* used internally */
     JS_TAG_FUNCTION_BYTECODE = -2, /* used internally */
     JS_TAG_OBJECT      = -1,
@@ -83,7 +90,8 @@ enum {
     JS_TAG_UNINITIALIZED = 4,
     JS_TAG_CATCH_OFFSET = 5,
     JS_TAG_EXCEPTION   = 6,
-    JS_TAG_FLOAT64     = 7,
+    JS_TAG_SHORT_BIG_INT = 7,
+    JS_TAG_FLOAT64     = 8,
     /* any larger tag is FLOAT64 if JS_NAN_BOXING */
 };
 
@@ -108,6 +116,7 @@ typedef const struct __JSValue *JSValueConst;
 #define JS_VALUE_GET_INT(v) (int)((intptr_t)(v) >> 4)
 #define JS_VALUE_GET_BOOL(v) JS_VALUE_GET_INT(v)
 #define JS_VALUE_GET_FLOAT64(v) (double)JS_VALUE_GET_INT(v)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) JS_VALUE_GET_INT(v)
 #define JS_VALUE_GET_PTR(v) (void *)((intptr_t)(v) & ~0xf)
 
 #define JS_MKVAL(tag, val) (JSValue)(intptr_t)(((val) << 4) | (tag))
@@ -126,7 +135,12 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 {
     return 0;
 }
-    
+
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int32_t d)
+{
+    return JS_MKVAL(JS_TAG_SHORT_BIG_INT, d);
+}
+
 #elif defined(JS_NAN_BOXING)
 
 typedef uint64_t JSValue;
@@ -136,6 +150,7 @@ typedef uint64_t JSValue;
 #define JS_VALUE_GET_TAG(v) (int)((v) >> 32)
 #define JS_VALUE_GET_INT(v) (int)(v)
 #define JS_VALUE_GET_BOOL(v) (int)(v)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) (int)(v)
 #define JS_VALUE_GET_PTR(v) (void *)(intptr_t)(v)
 
 #define JS_MKVAL(tag, val) (((uint64_t)(tag) << 32) | (uint32_t)(val))
@@ -191,13 +206,23 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     tag = JS_VALUE_GET_TAG(v);
     return tag == (JS_NAN >> 32);
 }
-    
+
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int32_t d)
+{
+    return JS_MKVAL(JS_TAG_SHORT_BIG_INT, d);
+}
+
 #else /* !JS_NAN_BOXING */
 
 typedef union JSValueUnion {
     int32_t int32;
     double float64;
     void *ptr;
+#if JS_SHORT_BIG_INT_BITS == 32
+    int32_t short_big_int;
+#else
+    int64_t short_big_int;
+#endif
 } JSValueUnion;
 
 typedef struct JSValue {
@@ -213,6 +238,7 @@ typedef struct JSValue {
 #define JS_VALUE_GET_INT(v) ((v).u.int32)
 #define JS_VALUE_GET_BOOL(v) ((v).u.int32)
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) ((v).u.short_big_int)
 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
 
 #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
@@ -242,13 +268,19 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;
 }
 
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int64_t d)
+{
+    JSValue v;
+    v.tag = JS_TAG_SHORT_BIG_INT;
+    v.u.short_big_int = d;
+    return v;
+}
+
 #endif /* !JS_NAN_BOXING */
 
 #define JS_VALUE_IS_BOTH_INT(v1, v2) ((JS_VALUE_GET_TAG(v1) | JS_VALUE_GET_TAG(v2)) == 0)
 #define JS_VALUE_IS_BOTH_FLOAT(v1, v2) (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v1)) && JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v2)))
 
-#define JS_VALUE_GET_OBJ(v) ((JSObject *)JS_VALUE_GET_PTR(v))
-#define JS_VALUE_GET_STRING(v) ((JSString *)JS_VALUE_GET_PTR(v))
 #define JS_VALUE_HAS_REF_COUNT(v) ((unsigned)JS_VALUE_GET_TAG(v) >= (unsigned)JS_TAG_FIRST)
 
 /* special values */
@@ -290,7 +322,9 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 #define JS_PROP_NO_ADD           (1 << 16) /* internal use */
 #define JS_PROP_NO_EXOTIC        (1 << 17) /* internal use */
 
-#define JS_DEFAULT_STACK_SIZE (256 * 1024)
+#ifndef JS_DEFAULT_STACK_SIZE
+#define JS_DEFAULT_STACK_SIZE (1024 * 1024)
+#endif
 
 /* JS_Eval() flags */
 #define JS_EVAL_TYPE_GLOBAL   (0 << 0) /* global code (default) */
@@ -300,13 +334,15 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 #define JS_EVAL_TYPE_MASK     (3 << 0)
 
 #define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
-#define JS_EVAL_FLAG_STRIP    (1 << 4) /* force 'strip' mode */
 /* compile but do not run. The result is an object with a
    JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
    with JS_EvalFunction(). */
 #define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5)
 /* don't include the stack frames before this eval in the Error() backtraces */
 #define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6)
+/* allow top-level await in normal script. JS_Eval() returns a
+   promise. Only allowed with JS_EVAL_TYPE_GLOBAL */
+#define JS_EVAL_FLAG_ASYNC (1 << 7)
 
 typedef JSValue JSCFunction(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
@@ -370,13 +406,7 @@ void JS_AddIntrinsicProxy(JSContext *ctx);
 void JS_AddIntrinsicMapSet(JSContext *ctx);
 void JS_AddIntrinsicTypedArrays(JSContext *ctx);
 void JS_AddIntrinsicPromise(JSContext *ctx);
-void JS_AddIntrinsicBigInt(JSContext *ctx);
-void JS_AddIntrinsicBigFloat(JSContext *ctx);
-void JS_AddIntrinsicBigDecimal(JSContext *ctx);
-/* enable operator overloading */
-void JS_AddIntrinsicOperators(JSContext *ctx);
-/* enable "use math" */
-void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
+void JS_AddIntrinsicWeakRef(JSContext *ctx);
 
 JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv);
@@ -426,7 +456,11 @@ void JS_FreeAtom(JSContext *ctx, JSAtom v);
 void JS_FreeAtomRT(JSRuntime *rt, JSAtom v);
 JSValue JS_AtomToValue(JSContext *ctx, JSAtom atom);
 JSValue JS_AtomToString(JSContext *ctx, JSAtom atom);
-const char *JS_AtomToCString(JSContext *ctx, JSAtom atom);
+const char *JS_AtomToCStringLen(JSContext *ctx, size_t *plen, JSAtom atom);
+static inline const char *JS_AtomToCString(JSContext *ctx, JSAtom atom)
+{
+    return JS_AtomToCStringLen(ctx, NULL, atom);
+}
 JSAtom JS_ValueToAtom(JSContext *ctx, JSValueConst val);
 
 /* object class support */
@@ -471,6 +505,17 @@ typedef struct JSClassExoticMethods {
     /* return < 0 if exception or TRUE/FALSE */
     int (*set_property)(JSContext *ctx, JSValueConst obj, JSAtom atom,
                         JSValueConst value, JSValueConst receiver, int flags);
+
+    /* To get a consistent object behavior when get_prototype != NULL,
+       get_property, set_property and set_prototype must be != NULL
+       and the object must be created with a JS_NULL prototype. */
+    JSValue (*get_prototype)(JSContext *ctx, JSValueConst obj);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*set_prototype)(JSContext *ctx, JSValueConst obj, JSValueConst proto_val);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*is_extensible)(JSContext *ctx, JSValueConst obj);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*prevent_extensions)(JSContext *ctx, JSValueConst obj);
 } JSClassExoticMethods;
 
 typedef void JSClassFinalizer(JSRuntime *rt, JSValue val);
@@ -496,7 +541,9 @@ typedef struct JSClassDef {
     JSClassExoticMethods *exotic;
 } JSClassDef;
 
+#define JS_INVALID_CLASS_ID 0
 JSClassID JS_NewClassID(JSClassID *pclass_id);
+/* Returns the class ID if `v` is an object, otherwise returns JS_INVALID_CLASS_ID. */
 JSClassID JS_GetClassID(JSValueConst v);
 int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);
 int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
@@ -545,23 +592,21 @@ JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);
 
 static js_force_inline JSValue JS_NewFloat64(JSContext *ctx, double d)
 {
-    JSValue v;
     int32_t val;
     union {
         double d;
         uint64_t u;
     } u, t;
-    u.d = d;
-    val = (int32_t)d;
-    t.d = val;
-    /* -0 cannot be represented as integer, so we compare the bit
-        representation */
-    if (u.u == t.u) {
-        v = JS_MKVAL(JS_TAG_INT, val);
-    } else {
-        v = __JS_NewFloat64(ctx, d);
+    if (d >= INT32_MIN && d <= INT32_MAX) {
+        u.d = d;
+        val = (int32_t)d;
+        t.d = val;
+        /* -0 cannot be represented as integer, so we compare the bit
+           representation */
+        if (u.u == t.u)
+            return JS_MKVAL(JS_TAG_INT, val);
     }
-    return v;
+    return __JS_NewFloat64(ctx, d);
 }
 
 static inline JS_BOOL JS_IsNumber(JSValueConst v)
@@ -573,19 +618,7 @@ static inline JS_BOOL JS_IsNumber(JSValueConst v)
 static inline JS_BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
 {
     int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_INT;
-}
-
-static inline JS_BOOL JS_IsBigFloat(JSValueConst v)
-{
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_FLOAT;
-}
-
-static inline JS_BOOL JS_IsBigDecimal(JSValueConst v)
-{
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_DECIMAL;
+    return tag == JS_TAG_BIG_INT || tag == JS_TAG_SHORT_BIG_INT;
 }
 
 static inline JS_BOOL JS_IsBool(JSValueConst v)
@@ -615,7 +648,8 @@ static inline JS_BOOL JS_IsUninitialized(JSValueConst v)
 
 static inline JS_BOOL JS_IsString(JSValueConst v)
 {
-    return JS_VALUE_GET_TAG(v) == JS_TAG_STRING;
+    return JS_VALUE_GET_TAG(v) == JS_TAG_STRING ||
+        JS_VALUE_GET_TAG(v) == JS_TAG_STRING_ROPE;
 }
 
 static inline JS_BOOL JS_IsSymbol(JSValueConst v)
@@ -629,9 +663,10 @@ static inline JS_BOOL JS_IsObject(JSValueConst v)
 }
 
 JSValue JS_Throw(JSContext *ctx, JSValue obj);
+void JS_SetUncatchableException(JSContext *ctx, JS_BOOL flag);
 JSValue JS_GetException(JSContext *ctx);
+JS_BOOL JS_HasException(JSContext *ctx);
 JS_BOOL JS_IsError(JSContext *ctx, JSValueConst val);
-void JS_ResetUncatchableError(JSContext *ctx);
 JSValue JS_NewError(JSContext *ctx);
 JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...);
 JSValue __js_printf_like(2, 3) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...);
@@ -679,6 +714,10 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
     return (JSValue)v;
 }
 
+JS_BOOL JS_StrictEq(JSContext *ctx, JSValueConst op1, JSValueConst op2);
+JS_BOOL JS_SameValue(JSContext *ctx, JSValueConst op1, JSValueConst op2);
+JS_BOOL JS_SameValueZero(JSContext *ctx, JSValueConst op1, JSValueConst op2);
+
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
 int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val);
 static inline int JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
@@ -694,7 +733,10 @@ int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val);
 
 JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);
-JSValue JS_NewString(JSContext *ctx, const char *str);
+static inline JSValue JS_NewString(JSContext *ctx, const char *str)
+{
+    return JS_NewStringLen(ctx, str, strlen(str));
+}
 JSValue JS_NewAtomString(JSContext *ctx, const char *str);
 JSValue JS_ToString(JSContext *ctx, JSValueConst val);
 JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val);
@@ -721,6 +763,8 @@ JS_BOOL JS_SetConstructorBit(JSContext *ctx, JSValueConst func_obj, JS_BOOL val)
 JSValue JS_NewArray(JSContext *ctx);
 int JS_IsArray(JSContext *ctx, JSValueConst val);
 
+JSValue JS_NewDate(JSContext *ctx, double epoch_ms);
+
 JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
                                JSAtom prop, JSValueConst receiver,
                                JS_BOOL throw_ref_error);
@@ -765,6 +809,8 @@ JSValue JS_GetPrototype(JSContext *ctx, JSValueConst val);
 
 int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
                            uint32_t *plen, JSValueConst obj, int flags);
+void JS_FreePropertyEnum(JSContext *ctx, JSPropertyEnum *tab,
+                         uint32_t len);
 int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
                       JSValueConst obj, JSAtom prop);
 
@@ -802,6 +848,7 @@ int JS_DefinePropertyGetSet(JSContext *ctx, JSValueConst this_obj,
 void JS_SetOpaque(JSValue obj, void *opaque);
 void *JS_GetOpaque(JSValueConst obj, JSClassID class_id);
 void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id);
+void *JS_GetAnyOpaque(JSValueConst obj, JSClassID *class_id);
 
 /* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
@@ -819,6 +866,24 @@ JSValue JS_NewArrayBuffer(JSContext *ctx, uint8_t *buf, size_t len,
 JSValue JS_NewArrayBufferCopy(JSContext *ctx, const uint8_t *buf, size_t len);
 void JS_DetachArrayBuffer(JSContext *ctx, JSValueConst obj);
 uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValueConst obj);
+
+typedef enum JSTypedArrayEnum {
+    JS_TYPED_ARRAY_UINT8C = 0,
+    JS_TYPED_ARRAY_INT8,
+    JS_TYPED_ARRAY_UINT8,
+    JS_TYPED_ARRAY_INT16,
+    JS_TYPED_ARRAY_UINT16,
+    JS_TYPED_ARRAY_INT32,
+    JS_TYPED_ARRAY_UINT32,
+    JS_TYPED_ARRAY_BIG_INT64,
+    JS_TYPED_ARRAY_BIG_UINT64,
+    JS_TYPED_ARRAY_FLOAT16,
+    JS_TYPED_ARRAY_FLOAT32,
+    JS_TYPED_ARRAY_FLOAT64,
+} JSTypedArrayEnum;
+
+JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValueConst *argv,
+                         JSTypedArrayEnum array_type);
 JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
                                size_t *pbyte_offset,
                                size_t *pbyte_length,
@@ -832,7 +897,15 @@ typedef struct {
 void JS_SetSharedArrayBufferFunctions(JSRuntime *rt,
                                       const JSSharedArrayBufferFunctions *sf);
 
+typedef enum JSPromiseStateEnum {
+    JS_PROMISE_PENDING,
+    JS_PROMISE_FULFILLED,
+    JS_PROMISE_REJECTED,
+} JSPromiseStateEnum;
+
 JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
+JSPromiseStateEnum JS_PromiseState(JSContext *ctx, JSValue promise);
+JSValue JS_PromiseResult(JSContext *ctx, JSValue promise);
 
 /* is_handled = TRUE means that the rejection is handled */
 typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
@@ -846,6 +919,12 @@ typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);
 /* if can_block is TRUE, Atomics.wait() can be used */
 void JS_SetCanBlock(JSRuntime *rt, JS_BOOL can_block);
+/* select which debug info is stripped from the compiled code */
+#define JS_STRIP_SOURCE (1 << 0) /* strip source code */
+#define JS_STRIP_DEBUG  (1 << 1) /* strip all debug info including source code */
+void JS_SetStripInfo(JSRuntime *rt, int flags);
+int JS_GetStripInfo(JSRuntime *rt);
+
 /* set the [IsHTMLDDA] internal slot */
 void JS_SetIsHTMLDDA(JSContext *ctx, JSValueConst obj);
 
@@ -858,15 +937,29 @@ typedef char *JSModuleNormalizeFunc(JSContext *ctx,
                                     const char *module_name, void *opaque);
 typedef JSModuleDef *JSModuleLoaderFunc(JSContext *ctx,
                                         const char *module_name, void *opaque);
-
+typedef JSModuleDef *JSModuleLoaderFunc2(JSContext *ctx,
+                                         const char *module_name, void *opaque,
+                                         JSValueConst attributes);
+/* return -1 if exception, 0 if OK */
+typedef int JSModuleCheckSupportedImportAttributes(JSContext *ctx, void *opaque,
+                                                   JSValueConst attributes);
+                                                   
 /* module_normalize = NULL is allowed and invokes the default module
    filename normalizer */
 void JS_SetModuleLoaderFunc(JSRuntime *rt,
                             JSModuleNormalizeFunc *module_normalize,
                             JSModuleLoaderFunc *module_loader, void *opaque);
+/* same as JS_SetModuleLoaderFunc but with attributes. if
+   module_check_attrs = NULL, no attribute checking is done. */
+void JS_SetModuleLoaderFunc2(JSRuntime *rt,
+                             JSModuleNormalizeFunc *module_normalize,
+                             JSModuleLoaderFunc2 *module_loader,
+                             JSModuleCheckSupportedImportAttributes *module_check_attrs,
+                             void *opaque);
 /* return the import.meta object of a module */
 JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m);
 JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m);
+JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m);
 
 /* JS Job support */
 
@@ -904,8 +997,8 @@ int JS_ResolveModule(JSContext *ctx, JSValueConst obj);
 /* only exported for os.Worker() */
 JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels);
 /* only exported for os.Worker() */
-JSModuleDef *JS_RunModule(JSContext *ctx, const char *basename,
-                          const char *filename);
+JSValue JS_LoadModule(JSContext *ctx, const char *basename,
+                      const char *filename);
 
 /* C function definition */
 typedef enum JSCFunctionEnum {  /* XXX: should rename for namespace isolation */
@@ -959,7 +1052,7 @@ static inline JSValue JS_NewCFunctionMagic(JSContext *ctx, JSCFunctionMagic *fun
 {
     return JS_NewCFunction2(ctx, (JSCFunction *)func, name, length, cproto, magic);
 }
-void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
                        JSValueConst proto);
 
 /* C property definition */
@@ -1021,9 +1114,9 @@ typedef struct JSCFunctionListEntry {
 #define JS_ALIAS_DEF(name, from) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, -1 } } }
 #define JS_ALIAS_BASE_DEF(name, from, base) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, base } } }
 
-void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
-                                const JSCFunctionListEntry *tab,
-                                int len);
+int JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
+                               const JSCFunctionListEntry *tab,
+                               int len);
 
 /* C module definition */
 
@@ -1040,6 +1133,29 @@ int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
                        JSValue val);
 int JS_SetModuleExportList(JSContext *ctx, JSModuleDef *m,
                            const JSCFunctionListEntry *tab, int len);
+/* associate a JSValue to a C module */
+int JS_SetModulePrivateValue(JSContext *ctx, JSModuleDef *m, JSValue val);
+JSValue JS_GetModulePrivateValue(JSContext *ctx, JSModuleDef *m);
+                        
+/* debug value output */
+
+typedef struct {
+    JS_BOOL show_hidden : 8; /* only show enumerable properties */
+    JS_BOOL raw_dump : 8; /* avoid doing autoinit and avoid any malloc() call (for internal use) */
+    uint32_t max_depth; /* recurse up to this depth, 0 = no limit */
+    uint32_t max_string_length; /* print no more than this length for
+                                   strings, 0 = no limit */
+    uint32_t max_item_count; /*  print no more than this count for
+                                 arrays or objects, 0 = no limit */
+} JSPrintValueOptions;
+
+typedef void JSPrintValueWrite(void *opaque, const char *buf, size_t len);
+
+void JS_PrintValueSetDefaultOptions(JSPrintValueOptions *options);
+void JS_PrintValueRT(JSRuntime *rt, JSPrintValueWrite *write_func, void *write_opaque,
+                     JSValueConst val, const JSPrintValueOptions *options);
+void JS_PrintValue(JSContext *ctx, JSPrintValueWrite *write_func, void *write_opaque,
+                   JSValueConst val, const JSPrintValueOptions *options);
 
 #undef js_unlikely
 #undef js_force_inline
diff --git a/quickjspp.hpp b/quickjspp.hpp
index b1a2e3f25c..f2e1e59740 100644
--- a/quickjspp.hpp
+++ b/quickjspp.hpp
@@ -406,10 +406,6 @@ struct js_traits<std::variant<Ts...>>
             case JS_TAG_BOOL:
                 return is_boolean<T>::value || std::is_integral_v<T> || std::is_floating_point_v<T>;
 
-            case JS_TAG_BIG_DECIMAL:
-                [[fallthrough]];
-            case JS_TAG_BIG_FLOAT:
-                [[fallthrough]];
             case JS_TAG_FLOAT64:
             default: // >JS_TAG_FLOAT64 (JS_NAN_BOXING)
                 return is_double<T>::value || std::is_floating_point_v<T>;
@@ -474,11 +470,6 @@ struct js_traits<std::variant<Ts...>>
             case JS_TAG_EXCEPTION:
                 break;
 
-            case JS_TAG_BIG_DECIMAL:
-                [[fallthrough]];
-            case JS_TAG_BIG_FLOAT:
-                [[fallthrough]];
-
             case JS_TAG_FLOAT64:
                 [[fallthrough]];
             default: // more than JS_TAG_FLOAT64 (nan boxing)
@@ -1775,6 +1766,11 @@ class Context
 
     ~Context()
     {
+        // We need to run the GC to flush finalization of any pending unhandled
+        // rejected promises before we free the context, as they depend on it's
+        // opaque value.
+        JS_RunGC(JS_GetRuntime(ctx));
+        
         modules.clear();
         JS_FreeContext(ctx);
     }
@@ -1836,6 +1832,19 @@ class Context
     {
         assert(buffer.data()[buffer.size()] == '\0' && "eval buffer is not null-terminated"); // JS_Eval requirement
         JSValue v = JS_Eval(ctx, buffer.data(), buffer.size(), filename, flags);
+
+        // For some time now module loads can return a (rejected) promise on
+        // failure. Keep old compatibility API for quickjspp's eval.
+        if(JS_PromiseState(ctx, v) == JS_PROMISE_REJECTED) {
+            JSValue result = JS_PromiseResult(ctx, v);
+            if(JS_IsError(ctx, result)) {
+                JS_FreeValue(ctx, v);
+                v = JS_Throw(ctx, result);
+            }
+            else {
+                JS_FreeValue(ctx, result);
+            }
+        }
         return Value{ctx, std::move(v)};
     }
 
diff --git a/test/class.cpp b/test/class.cpp
index 158996a516..73e43653b7 100644
--- a/test/class.cpp
+++ b/test/class.cpp
@@ -104,7 +104,7 @@ int main()
 
         js_std_init_handlers(rt);
         /* loader for ES6 modules */
-        JS_SetModuleLoaderFunc(rt, nullptr, js_module_loader, nullptr);
+        JS_SetModuleLoaderFunc2(rt, nullptr, js_module_loader, nullptr, nullptr);
         js_std_add_helpers(ctx, 0, nullptr);
 
         /* system modules */